photoplaces/backend/internal/handlers/services.go

package handlers

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

	"github.com/go-chi/chi/v5"
	"github.com/photoplaces/backend/internal/middleware"
	"github.com/photoplaces/backend/internal/models"
	"github.com/photoplaces/backend/internal/repository"
)

type ServiceHandler struct {
	serviceRepo *repository.ServiceRepo
	tagRepo     *repository.TagRepo
}

func NewServiceHandler(serviceRepo *repository.ServiceRepo, tagRepo *repository.TagRepo) *ServiceHandler {
	return &ServiceHandler{serviceRepo: serviceRepo, tagRepo: tagRepo}
}

func (h *ServiceHandler) List(w http.ResponseWriter, r *http.Request) {
	q := r.URL.Query()
	filter := models.ServiceFilter{Status: "published"}

	if tags := q["tags"]; len(tags) > 0 {
		filter.Tags = tags
	}
	if mr := q.Get("min_rating"); mr != "" {
		if v, err := strconv.ParseFloat(mr, 64); err == nil {
			filter.MinRating = v
		}
	}
	if pmin := q.Get("price_min"); pmin != "" {
		if v, err := strconv.Atoi(pmin); err == nil {
			filter.PriceMin = &v
		}
	}
	if pmax := q.Get("price_max"); pmax != "" {
		if v, err := strconv.Atoi(pmax); err == nil {
			filter.PriceMax = &v
		}
	}
	if limit := q.Get("limit"); limit != "" {
		if v, err := strconv.Atoi(limit); err == nil {
			filter.Limit_ = v
		}
	}

	services, err := h.serviceRepo.List(r.Context(), filter)
	if err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	if services == nil {
		services = []*models.Service{}
	}

	writeJSON(w, http.StatusOK, map[string]interface{}{"data": services})
}

func (h *ServiceHandler) GetByID(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")

	svc, err := h.serviceRepo.GetByID(r.Context(), id)
	if err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	if svc == nil {
		writeError(w, http.StatusNotFound, "service not found")
		return
	}

	tags, err := h.serviceRepo.GetTags(r.Context(), id)
	if err == nil {
		svc.Tags = tags
	}

	writeJSON(w, http.StatusOK, svc)
}

type createServiceRequest struct {
	Title           string   `json:"title"`
	Description     *string  `json:"description"`
	Price           int      `json:"price"`
	Currency        string   `json:"currency"`
	DurationMinutes *int     `json:"duration_minutes"`
	Tags            []string `json:"tags"`
}

func (h *ServiceHandler) Create(w http.ResponseWriter, r *http.Request) {
	userID := middleware.GetUserID(r.Context())

	var req createServiceRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	if req.Title == "" || req.Price <= 0 {
		writeError(w, http.StatusBadRequest, "title and price are required")
		return
	}

	tags := make([]models.Tag, len(req.Tags))
	for i, t := range req.Tags {
		tags[i] = models.Tag{ID: t}
	}

	svc := &models.Service{
		ExecutorID:      userID,
		Title:           req.Title,
		Description:     req.Description,
		Price:           req.Price,
		Currency:        req.Currency,
		DurationMinutes: req.DurationMinutes,
		Status:          "published",
		Tags:            tags,
	}

	if err := h.serviceRepo.Create(r.Context(), svc); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	writeJSON(w, http.StatusCreated, svc)
}

func (h *ServiceHandler) Update(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")

	var req createServiceRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid request body")
		return
	}

	svc, err := h.serviceRepo.GetByID(r.Context(), id)
	if err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	if svc == nil {
		writeError(w, http.StatusNotFound, "service not found")
		return
	}

	svc.Title = req.Title
	svc.Description = req.Description
	svc.Price = req.Price
	svc.Currency = req.Currency
	svc.DurationMinutes = req.DurationMinutes

	if err := h.serviceRepo.Update(r.Context(), svc); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}

	writeJSON(w, http.StatusOK, svc)
}

func (h *ServiceHandler) Delete(w http.ResponseWriter, r *http.Request) {
	id := chi.URLParam(r, "id")
	if err := h.serviceRepo.SoftDelete(r.Context(), id); err != nil {
		writeError(w, http.StatusInternalServerError, err.Error())
		return
	}
	w.WriteHeader(http.StatusNoContent)
}