CalendarApi/internal/api/handlers/project.go

package handlers

import (
	"net/http"

	"github.com/calendarapi/internal/middleware"
	"github.com/calendarapi/internal/models"
	"github.com/calendarapi/internal/service"
	"github.com/calendarapi/internal/utils"
	"github.com/go-chi/chi/v5"
)

type ProjectHandler struct {
	projectSvc *service.ProjectService
}

func NewProjectHandler(projectSvc *service.ProjectService) *ProjectHandler {
	return &ProjectHandler{projectSvc: projectSvc}
}

func (h *ProjectHandler) List(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())

	projects, err := h.projectSvc.List(r.Context(), userID)
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteList(w, projects, models.PageInfo{Limit: len(projects)})
}

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

	var req struct {
		Name     string  `json:"name"`
		Color    *string `json:"color"`
		IsShared *bool   `json:"is_shared"`
		Deadline *string `json:"deadline"`
		SortOrder *int   `json:"sort_order"`
	}
	if err := utils.DecodeJSON(r, &req); err != nil {
		utils.WriteError(w, err)
		return
	}

	createReq := service.CreateProjectRequest{
		Name:     req.Name,
		Color:    req.Color,
		IsShared: req.IsShared,
		SortOrder: req.SortOrder,
	}
	if req.Deadline != nil {
		if t, err := utils.ParseTime(*req.Deadline); err == nil {
			createReq.Deadline = &t
		}
	}

	project, err := h.projectSvc.Create(r.Context(), userID, createReq)
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
}

func (h *ProjectHandler) Get(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())
	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	project, err := h.projectSvc.Get(r.Context(), userID, projectID)
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
}

func (h *ProjectHandler) Update(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())
	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	var req struct {
		Name     *string `json:"name"`
		Color    *string `json:"color"`
		IsShared *bool   `json:"is_shared"`
		Deadline *string `json:"deadline"`
		SortOrder *int   `json:"sort_order"`
	}
	if err := utils.DecodeJSON(r, &req); err != nil {
		utils.WriteError(w, err)
		return
	}

	updateReq := service.UpdateProjectRequest{
		Name:     req.Name,
		Color:    req.Color,
		IsShared: req.IsShared,
		SortOrder: req.SortOrder,
	}
	if req.Deadline != nil {
		if t, err := utils.ParseTime(*req.Deadline); err == nil {
			updateReq.Deadline = &t
		}
	}

	project, err := h.projectSvc.Update(r.Context(), userID, projectID, updateReq)
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"project": project})
}

func (h *ProjectHandler) Delete(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())
	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	if err := h.projectSvc.Delete(r.Context(), userID, projectID); err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteOK(w)
}

func (h *ProjectHandler) Share(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())
	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	var req struct {
		Target struct {
			Email string `json:"email"`
		} `json:"target"`
		Role string `json:"role"`
	}
	if err := utils.DecodeJSON(r, &req); err != nil {
		utils.WriteError(w, err)
		return
	}

	if err := h.projectSvc.Share(r.Context(), userID, projectID, req.Target.Email, req.Role); err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteOK(w)
}

func (h *ProjectHandler) ListMembers(w http.ResponseWriter, r *http.Request) {
	userID, _ := middleware.GetUserID(r.Context())
	projectID, err := utils.ValidateUUID(chi.URLParam(r, "id"))
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	members, err := h.projectSvc.ListMembers(r.Context(), userID, projectID)
	if err != nil {
		utils.WriteError(w, err)
		return
	}

	utils.WriteJSON(w, http.StatusOK, map[string]interface{}{"members": members})
}