Merge pull request #80 from deploymenttheory/dev

Dev

Author: ShocOne

apihandlers/jamfpro/README.MD

@@ -1,13 +1,17 @@
-------------------------------Summary----------------------------------------
-This module is a api handler module for the go-api-http-client to accommodate specifics of
-jamf's api(s). It handles the encoding (marshalling) and decoding (unmarshalling)
-of data. It also sets the correct content headers for the various http methods.
+# Jamf Pro API Handler
 
-This module integrates with the go-api-http-client logger for wrapped error handling
-for human readable return codes. It also supports the go-api-http-client tiered logging
-functionality for logging support.
+The Jamf Pro API Handler is an integral component of the Go API HTTP Client, designed specifically for seamless integration with the Jamf Pro API. This handler facilitates the encoding and decoding of requests and responses, manages API-specific headers, and constructs endpoints for efficient API communication.
 
-The logic of this module is defined as follows:
+## Features
+
+- **Endpoint Construction**: Dynamically constructs API resource and authentication endpoints based on the instance name and predefined URL patterns.
+- **Content-Type Handling**: Determines the appropriate `Content-Type` header for requests, with specialized handling for both the Classic API (XML) and the JamfPro API (JSON).
+- **Accept Header Management**: Generates a weighted `Accept` header to indicate the client's capability to process various MIME types, prioritizing XML for compatibility with the Classic API.
+- **Standard Headers**: Provides a set of standard headers required for API requests, including `Accept`, `Content-Type`, and `Authorization`.
+- **Request Marshaling**: Encodes request bodies into the appropriate format (XML or JSON) based on the target API endpoint, with support for multipart/form-data encoding for file uploads.
+- **Response Handling**: Processes API responses, decoding them into the desired data structures and handling binary data responses where applicable.
+
+The logic of this api handler is defined as follows:
 Classic API:
 
 For requests (GET, POST, PUT, DELETE):
@@ -33,3 +37,42 @@ For responses (DELETE):
 Headers
 - Sets accept headers based on weighting. Jamf Pro API doesn't support XML, so MIME type is skipped and returns JSON
 - Set content header as application/json with edge case exceptions based on need.
+
+
+## Usage
+
+To utilize the Jamf Pro API Handler within the Go API HTTP Client, instantiate the client with the Jamf Pro-specific configuration:
+
+```go
+package main
+
+import (
+    "log"
+
+    "github.com/deploymenttheory/go-api-http-client/httpclient"
+    "github.com/deploymenttheory/go-api-http-client/apihandlers/jamfpro"
+)
+
+func main() {
+    // Configuration for the HTTP client specific to Jamf Pro
+    config := httpclient.ClientConfig{
+        Environment: httpclient.EnvironmentConfig{
+            InstanceName: "your-instance-name",
+            APIType:      "jamfpro", // Specify the API type as "jamfpro"
+        },
+        // Other configuration settings...
+    }
+
+    // Initialize the Jamf Pro API handler with the configuration
+    jamfHandler, err := jamfpro.LoadAPIHandler(config.Environment.APIType, config.Logger)
+    if err != nil {
+        log.Fatalf("Failed to initialize Jamf Pro API handler: %v", err)
+    }
+
+    // Use the handler for API interactions
+    // Example: Constructing an API resource endpoint
+    resourceURL := jamfHandler.ConstructAPIResourceEndpoint(config.Environment.InstanceName, "/path/to/resource", config.Logger)
+    log.Printf("Constructed Resource URL: %s", resourceURL)
+
+    // Proceed with making API calls using the constructed URLs and the configured HTTP client...
+}

apihandlers/jamfpro/jamfpro_api_response.go

@@ -72,55 +72,6 @@ func (j *JamfAPIHandler) HandleAPIErrorResponse(resp *http.Response, out interfa
 	return fmt.Errorf("received non-success status code: %d, raw response: %s", resp.StatusCode, rawResponse)
 }
 
-/*
-// HandleResponse processes an HTTP response for a Jamf API request. It handles different response types and errors accordingly.
-func (j *JamfAPIHandler) HandleResponse(resp *http.Response, out interface{}, log logger.Logger) error {
-	// Special handling for DELETE requests
-	if resp.Request.Method == "DELETE" {
-		return j.handleDeleteRequest(resp)
-	}
-
-	// Read the response body
-	bodyBytes, err := j.readResponseBody(resp)
-	if err != nil {
-		return err
-	}
-
-	// Convert bodyBytes to a string to represent the raw response body
-	rawResponse := string(bodyBytes)
-
-	// Log the raw response details for debugging
-	j.logResponseDetails(resp, bodyBytes)
-
-	// Get the content type from the response headers
-	contentType := resp.Header.Get("Content-Type")
-
-	// Check for binary data handling
-	contentDisposition := resp.Header.Get("Content-Disposition")
-	if err := j.handleBinaryData(contentType, contentDisposition, bodyBytes, out); err != nil {
-		return err
-	}
-
-	// Process based on the content type and status code
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		// Handle known error content types
-		if strings.Contains(contentType, "text/html") {
-			return j.handleErrorHTMLResponse(bodyBytes, resp.StatusCode)
-		} else if strings.Contains(contentType, "application/json") {
-			return j.handleErrorJSONResponse(bodyBytes, resp.StatusCode, rawResponse)
-		}
-		// Log generic error for unknown content types
-		j.Logger.Error("Received non-success status code without detailed error response",
-			zap.Int("status_code", resp.StatusCode),
-			zap.String("raw_response", rawResponse),
-		)
-		return fmt.Errorf("received non-success status code: %d", resp.StatusCode)
-	}
-
-	// Unmarshal the response based on content type
-	return j.unmarshalResponse(contentType, bodyBytes, out)
-}
-*/
 // handleDeleteRequest handles the special case for DELETE requests, where a successful response might not contain a body.
 func (j *JamfAPIHandler) handleDeleteRequest(resp *http.Response) error {
 	if resp.StatusCode >= 200 && resp.StatusCode < 300 {