You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
395 lines
12 KiB
395 lines
12 KiB
package api
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"net/http"
|
|
"net/url"
|
|
"strconv"
|
|
"time"
|
|
)
|
|
|
|
// SearchJobsParams defines parameters for searching jobs
|
|
type SearchJobsParams struct {
|
|
Query string
|
|
Status string
|
|
StartDate time.Time
|
|
EndDate time.Time
|
|
Page int
|
|
Limit int
|
|
IncludeArchived bool
|
|
}
|
|
|
|
// SearchJobs searches for jobs based on the provided parameters
|
|
func (s *Session) SearchJobs(params SearchJobsParams) ([]map[string]interface{}, error) {
|
|
queryValues := url.Values{}
|
|
|
|
if params.Query != "" {
|
|
queryValues.Add("q", params.Query)
|
|
}
|
|
|
|
if params.Status != "" {
|
|
queryValues.Add("status", params.Status)
|
|
}
|
|
|
|
if !params.StartDate.IsZero() {
|
|
queryValues.Add("start", params.StartDate.Format("2006-01-02"))
|
|
}
|
|
|
|
if !params.EndDate.IsZero() {
|
|
queryValues.Add("end", params.EndDate.Format("2006-01-02"))
|
|
}
|
|
|
|
if params.Page > 0 {
|
|
queryValues.Add("page", strconv.Itoa(params.Page))
|
|
} else {
|
|
queryValues.Add("page", "1")
|
|
}
|
|
|
|
if params.Limit > 0 {
|
|
queryValues.Add("limit", strconv.Itoa(params.Limit))
|
|
} else {
|
|
queryValues.Add("limit", "50")
|
|
}
|
|
|
|
if params.IncludeArchived {
|
|
queryValues.Add("include", "archived")
|
|
}
|
|
|
|
endpoint := fmt.Sprintf("/job?%s", queryValues.Encode())
|
|
resp, err := s.DoRequest(http.MethodGet, endpoint, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %v", err)
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return nil, fmt.Errorf("API returned error: %s - %s", resp.Status, string(body))
|
|
}
|
|
|
|
var result struct {
|
|
Data struct {
|
|
Jobs []map[string]interface{} `json:"records"`
|
|
} `json:"data"`
|
|
}
|
|
|
|
if err := json.Unmarshal(body, &result); err != nil {
|
|
return nil, fmt.Errorf("error unmarshalling response: %v", err)
|
|
}
|
|
|
|
log.Printf("Found %d jobs", len(result.Data.Jobs))
|
|
log.Printf("Parsed Data: %+v", result.Data)
|
|
return result.Data.Jobs, nil
|
|
}
|
|
|
|
// GetJobDetails retrieves detailed information about a specific job
|
|
func (s *Session) GetJobDetails(jobID string) (map[string]interface{}, error) {
|
|
endpoint := fmt.Sprintf("/job/%s", jobID)
|
|
resp, err := s.DoRequest(http.MethodGet, endpoint, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("error reading response body: %v", err)
|
|
}
|
|
|
|
if resp.StatusCode != 200 {
|
|
return nil, fmt.Errorf("API returned error: %s - %s", resp.Status, string(body))
|
|
}
|
|
|
|
var result struct {
|
|
Data map[string]interface{} `json:"data"`
|
|
}
|
|
|
|
if err := json.Unmarshal(body, &result); err != nil {
|
|
return nil, fmt.Errorf("error unmarshalling response: %v", err)
|
|
}
|
|
|
|
return result.Data, nil
|
|
}
|
|
|
|
// GetAttachmentsForJob retrieves attachments for a specific job
|
|
func (s *Session) GetAttachmentsForJob(jobID string) (map[string]interface{}, error) {
|
|
log.Printf("GetAttachmentsForJob: Fetching attachments for job %s", jobID)
|
|
|
|
// Check if we have a valid cookie
|
|
if s.Cookie == "" {
|
|
log.Printf("GetAttachmentsForJob: No cookie found in session for job %s", jobID)
|
|
return nil, fmt.Errorf("no authentication cookie found")
|
|
}
|
|
|
|
// Use the new API endpoint that returns attachments directly
|
|
url := fmt.Sprintf("%s/job/%s", BaseURL, jobID)
|
|
log.Printf("GetAttachmentsForJob: Using URL: %s", url)
|
|
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
log.Printf("GetAttachmentsForJob: Error creating request: %v", err)
|
|
return nil, fmt.Errorf("error creating request: %v", err)
|
|
}
|
|
|
|
// Add authorization header
|
|
req.Header.Set("Cookie", s.Cookie)
|
|
log.Printf("GetAttachmentsForJob: Authorization cookie length: %d", len(s.Cookie))
|
|
|
|
// Set Accept header to get all data in one call
|
|
req.Header.Set("Accept", "application/json")
|
|
|
|
// Add query parameter to include attachments
|
|
q := req.URL.Query()
|
|
q.Add("include", "attachments")
|
|
q.Add("include", "paperwork")
|
|
req.URL.RawQuery = q.Encode()
|
|
|
|
log.Printf("GetAttachmentsForJob: Full URL with params: %s", req.URL.String())
|
|
|
|
// Debug headers
|
|
log.Printf("GetAttachmentsForJob: Request headers: %+v", req.Header)
|
|
|
|
// Send the request
|
|
log.Printf("GetAttachmentsForJob: Sending request for job %s", jobID)
|
|
resp, err := s.Client.Do(req)
|
|
if err != nil {
|
|
log.Printf("GetAttachmentsForJob: Error sending request: %v", err)
|
|
return nil, fmt.Errorf("error sending request: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
// Read the full response body for complete debugging
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
log.Printf("GetAttachmentsForJob: Error reading response body: %v", err)
|
|
return nil, fmt.Errorf("error reading response body: %v", err)
|
|
}
|
|
|
|
log.Printf("GetAttachmentsForJob: Response status for job %s: %s", jobID, resp.Status)
|
|
|
|
// Check for errors
|
|
if resp.StatusCode != http.StatusOK {
|
|
log.Printf("GetAttachmentsForJob: API error for job %s: %s - %s", jobID, resp.Status, string(body))
|
|
return nil, fmt.Errorf("API error: %s - %s", resp.Status, string(body))
|
|
}
|
|
|
|
// Log a truncated version of the response for debugging
|
|
responsePreview := string(body)
|
|
if len(responsePreview) > 500 {
|
|
responsePreview = responsePreview[:500] + "... [truncated]"
|
|
}
|
|
log.Printf("GetAttachmentsForJob: Response preview for job %s: %s", jobID, responsePreview)
|
|
|
|
// Parse the response
|
|
var result map[string]interface{}
|
|
if err := json.Unmarshal(body, &result); err != nil {
|
|
log.Printf("GetAttachmentsForJob: Error parsing response: %v", err)
|
|
return nil, fmt.Errorf("error parsing response: %v", err)
|
|
}
|
|
|
|
// Log the structure of the response
|
|
log.Printf("GetAttachmentsForJob: Root keys for job %s: %v", jobID, mapKeys(result))
|
|
|
|
// Check for data object structure
|
|
if data, ok := result["data"].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Data keys for job %s: %v", jobID, mapKeys(data))
|
|
|
|
// Look for job information
|
|
if jobData, ok := data["job"].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Job data keys: %v", mapKeys(jobData))
|
|
}
|
|
|
|
// First try to find attachments directly
|
|
if attachments, ok := data["attachments"]; ok {
|
|
switch att := attachments.(type) {
|
|
case []interface{}:
|
|
log.Printf("GetAttachmentsForJob: Found %d attachments in data.attachments array for job %s", len(att), jobID)
|
|
if len(att) > 0 {
|
|
log.Printf("GetAttachmentsForJob: First attachment type: %T", att[0])
|
|
if attMap, ok := att[0].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: First attachment keys: %v", mapKeys(attMap))
|
|
}
|
|
}
|
|
case map[string]interface{}:
|
|
log.Printf("GetAttachmentsForJob: Attachments is a map with keys: %v", mapKeys(att))
|
|
|
|
// Check for attachments in items or objects
|
|
for _, key := range []string{"items", "objects", "components", "records"} {
|
|
if items, ok := att[key].([]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Found %d items in attachments.%s for job %s", len(items), key, jobID)
|
|
if len(items) > 0 {
|
|
if itemMap, ok := items[0].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: First item in %s keys: %v", key, mapKeys(itemMap))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
default:
|
|
log.Printf("GetAttachmentsForJob: Attachments has unexpected type: %T", attachments)
|
|
}
|
|
} else {
|
|
log.Printf("GetAttachmentsForJob: No 'attachments' field in data for job %s", jobID)
|
|
|
|
// Try to find paperwork directly
|
|
if paperwork, ok := data["paperwork"].([]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Found %d items in data.paperwork for job %s", len(paperwork), jobID)
|
|
if len(paperwork) > 0 {
|
|
if papMap, ok := paperwork[0].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: First paperwork keys: %v", mapKeys(papMap))
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for other potential containers
|
|
for _, key := range []string{"objects", "components", "items", "records"} {
|
|
if items, ok := data[key].([]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Found %d items in data.%s for job %s", len(items), key, jobID)
|
|
if len(items) > 0 {
|
|
if itemMap, ok := items[0].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: First item in %s keys: %v", key, mapKeys(itemMap))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
log.Printf("GetAttachmentsForJob: No 'data' field or it's not a map for job %s", jobID)
|
|
|
|
// Try to find objects at root level
|
|
if objects, ok := result["objects"].([]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: Found %d objects at root level for job %s", len(objects), jobID)
|
|
if len(objects) > 0 {
|
|
if objMap, ok := objects[0].(map[string]interface{}); ok {
|
|
log.Printf("GetAttachmentsForJob: First root object keys: %v", mapKeys(objMap))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If response has an empty data structure, try a direct paperwork endpoint
|
|
if emptyAttachments := isEmptyResponse(result); emptyAttachments {
|
|
log.Printf("GetAttachmentsForJob: No attachments found in primary response, trying paperwork endpoint for job %s", jobID)
|
|
|
|
paperworkURL := fmt.Sprintf("%s/job/%s/paperwork", BaseURL, jobID)
|
|
paperworkReq, err := http.NewRequest("GET", paperworkURL, nil)
|
|
if err == nil {
|
|
paperworkReq.Header.Set("Cookie", s.Cookie)
|
|
paperworkResp, err := s.Client.Do(paperworkReq)
|
|
|
|
if err == nil && paperworkResp.StatusCode == http.StatusOK {
|
|
defer paperworkResp.Body.Close()
|
|
paperworkBody, err := io.ReadAll(paperworkResp.Body)
|
|
|
|
if err == nil {
|
|
var paperworkResult map[string]interface{}
|
|
if err := json.Unmarshal(paperworkBody, &paperworkResult); err == nil {
|
|
log.Printf("GetAttachmentsForJob: Paperwork endpoint response keys: %v", mapKeys(paperworkResult))
|
|
|
|
// Merge the paperwork result with our original result
|
|
result["paperwork_data"] = paperworkResult
|
|
|
|
// If the original result had a data field, add paperwork to it
|
|
if data, ok := result["data"].(map[string]interface{}); ok {
|
|
if objects, ok := paperworkResult["objects"].([]interface{}); ok && len(objects) > 0 {
|
|
log.Printf("GetAttachmentsForJob: Found %d objects in paperwork response", len(objects))
|
|
data["paperwork_objects"] = objects
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// Helper function to check if the response has no attachments
|
|
func isEmptyResponse(result map[string]interface{}) bool {
|
|
if data, ok := result["data"].(map[string]interface{}); ok {
|
|
// Check if attachments exist and have content
|
|
if attachments, ok := data["attachments"]; ok {
|
|
switch att := attachments.(type) {
|
|
case []interface{}:
|
|
return len(att) == 0
|
|
case map[string]interface{}:
|
|
// Check items/objects inside the attachments map
|
|
hasItems := false
|
|
for _, key := range []string{"items", "objects", "components", "records"} {
|
|
if items, ok := att[key].([]interface{}); ok && len(items) > 0 {
|
|
hasItems = true
|
|
break
|
|
}
|
|
}
|
|
return !hasItems
|
|
default:
|
|
return true // Unknown type, consider empty
|
|
}
|
|
}
|
|
|
|
// Check for paperwork
|
|
if paperwork, ok := data["paperwork"].([]interface{}); ok && len(paperwork) > 0 {
|
|
return false
|
|
}
|
|
|
|
// Check for paperwork in job
|
|
if job, ok := data["job"].(map[string]interface{}); ok {
|
|
if paperwork, ok := job["paperwork"].([]interface{}); ok && len(paperwork) > 0 {
|
|
return false
|
|
}
|
|
}
|
|
|
|
// Check other containers
|
|
for _, key := range []string{"objects", "components", "items", "records"} {
|
|
if items, ok := data[key].([]interface{}); ok && len(items) > 0 {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check root level objects
|
|
if objects, ok := result["objects"].([]interface{}); ok && len(objects) > 0 {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
// Helper function to get map keys for logging
|
|
func mapKeys(m map[string]interface{}) []string {
|
|
keys := make([]string, 0, len(m))
|
|
for k := range m {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|
|
|
|
// GetDeficiencyInfoForJob retrieves deficiency information for a specific job
|
|
func (s *Session) GetDeficiencyInfoForJob(jobID string) ([]map[string]interface{}, error) {
|
|
resp, err := s.DoRequest("GET", fmt.Sprintf("/deficiency/%s", jobID), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, _ := io.ReadAll(resp.Body)
|
|
if resp.StatusCode != 200 {
|
|
return nil, fmt.Errorf("failed to get deficiency info: %s, response: %s", resp.Status, string(body))
|
|
}
|
|
|
|
var result struct {
|
|
Data []map[string]interface{} `json:"data"`
|
|
}
|
|
if err := json.Unmarshal(body, &result); err != nil {
|
|
return nil, fmt.Errorf("error unmarshalling response: %v", err)
|
|
}
|
|
|
|
return result.Data, nil
|
|
}
|
|
|