Update Microsoft Graph API constants

Author: ShocOne

apihandlers/graph/graph_api_exceptions.go

@@ -0,0 +1,46 @@
+// graph_api_exceptions.go
+package graph
+
+import (
+	_ "embed"
+
+	"encoding/json"
+	"log"
+)
+
+// EndpointConfig is a struct that holds configuration details for a specific API endpoint.
+// It includes what type of content it can accept and what content type it should send.
+type EndpointConfig struct {
+	Accept      string  `json:"accept"`       // Accept specifies the MIME type the endpoint can handle in responses.
+	ContentType *string `json:"content_type"` // ContentType, if not nil, specifies the MIME type to set for requests sent to the endpoint. A pointer is used to distinguish between a missing field and an empty string.
+}
+
+// ConfigMap is a map that associates endpoint URL patterns with their corresponding configurations.
+// The map's keys are strings that identify the endpoint, and the values are EndpointConfig structs
+// that hold the configuration for that endpoint.
+type ConfigMap map[string]EndpointConfig
+
+// Variables
+var configMap ConfigMap
+
+// Embedded Resources
+//
+//go:embed graph_api_exceptions_configuration.json
+var graph_api_exceptions_configuration []byte
+
+// init is invoked automatically on package initialization and is responsible for
+// setting up the default state of the package by loading the api exceptions configuration.
+func init() {
+	// Load the default configuration from an embedded resource.
+	err := loadAPIExceptionsConfiguration()
+	if err != nil {
+		log.Fatalf("Error loading Jamf Pro API exceptions configuration: %s", err)
+	}
+}
+
+// loadAPIExceptionsConfiguration reads and unmarshals the jamfpro_api_exceptions_configuration JSON data from an embedded file
+// into the configMap variable, which holds the exceptions configuration for endpoint-specific headers.
+func loadAPIExceptionsConfiguration() error {
+	// Unmarshal the embedded default configuration into the global configMap.
+	return json.Unmarshal(graph_api_exceptions_configuration, &configMap)
+}

apihandlers/graph/graph_api_handler.go

@@ -1,3 +1,4 @@
+// graph_api_handler.go
 package graph
 
 import "github.com/deploymenttheory/go-api-http-client/logger"

apihandlers/graph/graph_api_handler_constants.go

@@ -1,13 +1,14 @@
+// graph_api_handler_constants.go
 package graph
 
 // Endpoint constants represent the URL suffixes used for Jamf API token interactions.
 const (
-	APIName                            = "graph"               // APIName: represents the name of the API.
+	APIName                            = "microsoft graph"     // APIName: represents the name of the API.
 	DefaultBaseDomain                  = "graph.microsoft.com" // DefaultBaseDomain: represents the base domain for the jamf instance.
-	OAuthTokenEndpoint                 = ""                    // OAuthTokenEndpoint: The endpoint to obtain an OAuth token.
-	BearerTokenEndpoint                = ""                    // BearerTokenEndpoint: The endpoint to obtain a bearer token.
-	TokenRefreshEndpoint               = ""                    // TokenRefreshEndpoint: The endpoint to refresh an existing token.
-	TokenInvalidateEndpoint            = ""                    // TokenInvalidateEndpoint: The endpoint to invalidate an active token.
+	OAuthTokenEndpoint                 = "graph.microsoft.com" // OAuthTokenEndpoint: The endpoint to obtain an OAuth token.
+	BearerTokenEndpoint                = "graph.microsoft.com" // BearerTokenEndpoint: The endpoint to obtain a bearer token.
+	TokenRefreshEndpoint               = "graph.microsoft.com" // TokenRefreshEndpoint: The endpoint to refresh an existing token.
+	TokenInvalidateEndpoint            = "graph.microsoft.com" // TokenInvalidateEndpoint: The endpoint to invalidate an active token.
 	BearerTokenAuthenticationSupport   = true                  // BearerTokenAuthSuppport: A boolean to indicate if the API supports bearer token authentication.
 	OAuthAuthenticationSupport         = true                  // OAuthAuthSuppport: A boolean to indicate if the API supports OAuth authentication.
 	OAuthWithCertAuthenticationSupport = true                  // OAuthWithCertAuthSuppport: A boolean to indicate if the API supports OAuth with client certificate authentication.

apihandlers/graph/jamfpro_api_headers.go

@@ -0,0 +1,70 @@
+// graph_api_headers.go
+package graph
+
+import (
+	"strings"
+
+	"github.com/deploymenttheory/go-api-http-client/logger"
+	"go.uber.org/zap"
+)
+
+// GetContentTypeHeader determines the appropriate Content-Type header for a given API endpoint.
+// It attempts to find a content type that matches the endpoint prefix in the global configMap.
+// If a match is found and the content type is defined (not nil), it returns the specified content type.
+// If the endpoint does not match any of the predefined patterns, "application/json" is used as a fallback.
+// This method logs the decision process at various stages for debugging purposes.
+func (g *GraphAPIHandler) GetContentTypeHeader(endpoint string, log logger.Logger) string {
+	// Dynamic lookup from configuration should be the first priority
+	for key, config := range configMap {
+		if strings.HasPrefix(endpoint, key) {
+			if config.ContentType != nil {
+				g.Logger.Debug("Content-Type for endpoint found in configMap", zap.String("endpoint", endpoint), zap.String("content_type", *config.ContentType))
+				return *config.ContentType
+			}
+			g.Logger.Debug("Content-Type for endpoint is nil in configMap, handling as special case", zap.String("endpoint", endpoint))
+			// If a nil ContentType is an expected case, do not set Content-Type header.
+			return "" // Return empty to indicate no Content-Type should be set.
+		}
+	}
+
+	// Fallback to JSON if no other match is found.
+	g.Logger.Debug("Content-Type for endpoint not found in configMap or standard patterns, using default JSON", zap.String("endpoint", endpoint))
+	return "application/json"
+}
+
+// GetAcceptHeader constructs and returns a weighted Accept header string for HTTP requests.
+// The Accept header indicates the MIME types that the client can process and prioritizes them
+// based on the quality factor (q) parameter. Higher q-values signal greater preference.
+// This function specifies a range of MIME types with their respective weights, ensuring that
+// the server is informed of the client's versatile content handling capabilities while
+// indicating a preference for XML. The specified MIME types cover common content formats like
+// images, JSON, XML, HTML, plain text, and certificates, with a fallback option for all other types.
+func (g *GraphAPIHandler) GetAcceptHeader() string {
+	weightedAcceptHeader := "application/x-x509-ca-cert;q=0.95," +
+		"application/pkix-cert;q=0.94," +
+		"application/pem-certificate-chain;q=0.93," +
+		"application/octet-stream;q=0.8," + // For general binary files
+		"image/png;q=0.75," +
+		"image/jpeg;q=0.74," +
+		"image/*;q=0.7," +
+		"application/xml;q=0.65," +
+		"text/xml;q=0.64," +
+		"text/xml;charset=UTF-8;q=0.63," +
+		"application/json;q=0.5," +
+		"text/html;q=0.5," +
+		"text/plain;q=0.4," +
+		"*/*;q=0.05" // Fallback for any other types
+
+	return weightedAcceptHeader
+}
+
+// GetAPIRequestHeaders returns a map of standard headers required for making API requests.
+func (g *GraphAPIHandler) GetAPIRequestHeaders(endpoint string) map[string]string {
+	headers := map[string]string{
+		"Accept":        g.GetAcceptHeader(),                        // Dynamically set based on API requirements.
+		"Content-Type":  g.GetContentTypeHeader(endpoint, g.Logger), // Dynamically set based on the endpoint.
+		"Authorization": "",                                         // To be set by the client with the actual token.
+		"User-Agent":    "go-api-http-client-graph-handler",         // To be set by the client, usually with application info.
+	}
+	return headers
+}