servicetrade-toolbox-wmv/internal/handlers/web/jobs.go

package web

import (
	"fmt"
	"log"
	root "marmic/servicetrade-toolbox"
	"marmic/servicetrade-toolbox/internal/api"
	"marmic/servicetrade-toolbox/internal/middleware"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

func JobsHandler(w http.ResponseWriter, r *http.Request) {
	session, ok := r.Context().Value(middleware.SessionKey).(*api.Session)
	if !ok {
		http.Error(w, "Unauthorized", http.StatusUnauthorized)
		return
	}

	tmpl := root.WebTemplates
	data := map[string]interface{}{
		"Title": "Jobs",
	}

	switch r.URL.Path {
	case "/jobs":
		// Fetch and display search results only
		jobs, err := handleJobSearch(r, session)
		if err != nil {
			log.Printf("Error in job search: %v", err)
			data["Error"] = true
			data["ErrorMsg"] = "Failed to fetch jobs. Please try again later."
		} else {
			data["Jobs"] = jobs
		}
		err = tmpl.ExecuteTemplate(w, "job_search_results", data)
		if err != nil {
			log.Printf("Template execution error: %v", err)
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}

	case "/jobs/documents":
		// Fetch jobs and uploaded documents
		jobs, err := handleJobSearch(r, session)
		if err != nil {
			log.Printf("Error in job search: %v", err)
			data["Error"] = true
			data["ErrorMsg"] = "Failed to fetch jobs. Please try again later."
		} else {
			data["Jobs"] = jobs
		}

		err = tmpl.ExecuteTemplate(w, "job_document_management", data)
		if err != nil {
			log.Printf("Template execution error: %v", err)
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}

	default:
		http.Error(w, "Not Found", http.StatusNotFound)
	}
}

func convertDatesToUnix(params url.Values) url.Values {
	cleanedParams := url.Values{}

	const layout = "2006-01-02"

	if beginDate := params.Get("dueByBegin"); beginDate != "" {
		if t, err := time.Parse(layout, beginDate); err == nil {
			cleanedParams.Add("dueByBegin", fmt.Sprintf("%d", t.Unix()))
		} else {
			fmt.Printf("Error parsing dueByBegin: %v\n", err)
		}
	}

	if endDate := params.Get("dueByEnd"); endDate != "" {
		if t, err := time.Parse(layout, endDate); err == nil {
			cleanedParams.Add("dueByEnd", fmt.Sprintf("%d", t.Unix()))
		} else {
			fmt.Printf("Error parsing dueByEnd: %v\n", err)
		}
	}

	for key, values := range params {
		if key != "dueByBegin" && key != "dueByEnd" {
			for _, value := range values {
				if value != "" {
					cleanedParams.Add(key, value)
				}
			}
		}
	}

	return cleanedParams
}

func handleJobSearch(r *http.Request, session *api.Session) ([]map[string]interface{}, error) {
	queryParams := r.URL.Query()
	cleanedParams := convertDatesToUnix(queryParams)

	// Convert url.Values to SearchJobsParams
	params := api.SearchJobsParams{
		Query:  cleanedParams.Get("q"),
		Status: cleanedParams.Get("status"),
	}

	// Convert page and limit if present
	if pageStr := cleanedParams.Get("page"); pageStr != "" {
		if page, err := strconv.Atoi(pageStr); err == nil {
			params.Page = page
		}
	}

	if limitStr := cleanedParams.Get("limit"); limitStr != "" {
		if limit, err := strconv.Atoi(limitStr); err == nil {
			params.Limit = limit
		}
	}

	// Handle start/end dates
	if startStr := cleanedParams.Get("start"); startStr != "" {
		if start, err := time.Parse("2006-01-02", startStr); err == nil {
			params.StartDate = start
		}
	}

	if endStr := cleanedParams.Get("end"); endStr != "" {
		if end, err := time.Parse("2006-01-02", endStr); err == nil {
			params.EndDate = end
		}
	}

	// Handle include archived
	params.IncludeArchived = cleanedParams.Get("include") == "archived"

	jobs, err := session.SearchJobs(params)
	if err != nil {
		return nil, fmt.Errorf("error fetching jobs: %w", err)
	}

	return jobs, nil
}