gohorsejobs/backend/internal/handlers/job_handler.go

package handlers

import (
        "encoding/json"
        "net/http"
        "strconv"

        "github.com/rede5/gohorsejobs/backend/internal/dto"
        "github.com/rede5/gohorsejobs/backend/internal/models"
        "github.com/rede5/gohorsejobs/backend/internal/services"
)

// swaggerTypes ensures swagger can resolve referenced response models.
var (
        _ models.Job
        _ models.JobWithCompany
)

type JobHandler struct {
	Service *services.JobService
}

func NewJobHandler(service *services.JobService) *JobHandler {
	return &JobHandler{Service: service}
}

// GetJobs godoc
// @Summary      List all jobs
// @Description  Get a paginated list of job postings with optional filters
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        page       query    int     false  "Page number (default: 1)"
// @Param        limit      query    int     false  "Items per page (default: 10, max: 100)"
// @Param        companyId  query    int     false  "Filter by company ID"
// @Param        featured   query    bool    false  "Filter by featured status"
// @Success      200  {object}  dto.PaginatedResponse
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /jobs [get]
func (h *JobHandler) GetJobs(w http.ResponseWriter, r *http.Request) {
	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
	limit, _ := strconv.Atoi(r.URL.Query().Get("limit"))
	companyID, _ := strconv.Atoi(r.URL.Query().Get("companyId"))
	isFeaturedStr := r.URL.Query().Get("featured")

	filter := dto.JobFilterQuery{
		PaginationQuery: dto.PaginationQuery{
			Page:  page,
			Limit: limit,
		},
	}
	if companyID > 0 {
		filter.CompanyID = &companyID
	}
	if isFeaturedStr == "true" {
		val := true
		filter.IsFeatured = &val
	}

	jobs, total, err := h.Service.GetJobs(filter)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	response := dto.PaginatedResponse{
		Data: jobs,
		Pagination: dto.Pagination{
			Page:  page,
			Limit: limit,
			Total: total,
		},
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(response)
}

// CreateJob godoc
// @Summary      Create a new job
// @Description  Create a new job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        job  body      dto.CreateJobRequest  true  "Job data"
// @Success      201  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /jobs [post]
func (h *JobHandler) CreateJob(w http.ResponseWriter, r *http.Request) {
	var req dto.CreateJobRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Validate request (omitted for brevity, assume validation middleware or service validation)

	job, err := h.Service.CreateJob(req)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(job)
}

// GetJobByID godoc
// @Summary      Get job by ID
// @Description  Get a single job posting by its ID
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      int  true  "Job ID"
// @Success      200  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      404  {string}  string  "Not Found"
// @Router       /jobs/{id} [get]
func (h *JobHandler) GetJobByID(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id") // Go 1.22+ routing

	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid job ID", http.StatusBadRequest)
		return
	}

	job, err := h.Service.GetJobByID(id)
	if err != nil {
		http.Error(w, err.Error(), http.StatusNotFound)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(job)
}

// UpdateJob godoc
// @Summary      Update a job
// @Description  Update an existing job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      int                   true  "Job ID"
// @Param        job  body      dto.UpdateJobRequest  true  "Updated job data"
// @Success      200  {object}  models.Job
// @Failure      400  {string}  string  "Bad Request"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /jobs/{id} [put]
func (h *JobHandler) UpdateJob(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid job ID", http.StatusBadRequest)
		return
	}

	var req dto.UpdateJobRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	job, err := h.Service.UpdateJob(id, req)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(job)
}

// DeleteJob godoc
// @Summary      Delete a job
// @Description  Delete a job posting
// @Tags         Jobs
// @Accept       json
// @Produce      json
// @Param        id   path      int  true  "Job ID"
// @Success      204  "No Content"
// @Failure      400  {string}  string  "Bad Request"
// @Failure      500  {string}  string  "Internal Server Error"
// @Router       /jobs/{id} [delete]
func (h *JobHandler) DeleteJob(w http.ResponseWriter, r *http.Request) {
	idStr := r.PathValue("id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		http.Error(w, "Invalid job ID", http.StatusBadRequest)
		return
	}

	if err := h.Service.DeleteJob(id); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.WriteHeader(http.StatusNoContent)
}