hpc/internal/handler/template.go

package handler

import (
	"errors"
	"strconv"

	"gcy_hpc_server/internal/model"
	"gcy_hpc_server/internal/server"
	"gcy_hpc_server/internal/store"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

type TemplateHandler struct {
	store  *store.TemplateStore
	logger *zap.Logger
}

func NewTemplateHandler(s *store.TemplateStore, logger *zap.Logger) *TemplateHandler {
	return &TemplateHandler{store: s, logger: logger}
}

func (h *TemplateHandler) ListTemplates(c *gin.Context) {
	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "20"))

	if page < 1 {
		page = 1
	}
	if pageSize < 1 {
		pageSize = 20
	}

	templates, total, err := h.store.List(c.Request.Context(), page, pageSize)
	if err != nil {
		h.logger.Error("failed to list templates", zap.Error(err))
		server.InternalError(c, err.Error())
		return
	}

	server.OK(c, gin.H{
		"templates": templates,
		"total":     total,
		"page":      page,
		"page_size": pageSize,
	})
}

func (h *TemplateHandler) CreateTemplate(c *gin.Context) {
	var req model.CreateTemplateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("invalid request body for create template", zap.Error(err))
		server.BadRequest(c, "invalid request body")
		return
	}

	if req.Name == "" || req.Script == "" {
		h.logger.Warn("missing required fields for create template")
		server.BadRequest(c, "name and script are required")
		return
	}

	id, err := h.store.Create(c.Request.Context(), &req)
	if err != nil {
		h.logger.Error("failed to create template", zap.Error(err))
		server.InternalError(c, err.Error())
		return
	}

	h.logger.Info("template created", zap.Int64("id", id))
	server.Created(c, gin.H{"id": id})
}

func (h *TemplateHandler) GetTemplate(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		h.logger.Warn("invalid template id", zap.String("id", c.Param("id")))
		server.BadRequest(c, "invalid id")
		return
	}

	tmpl, err := h.store.GetByID(c.Request.Context(), id)
	if err != nil {
		h.logger.Error("failed to get template", zap.Int64("id", id), zap.Error(err))
		server.InternalError(c, err.Error())
		return
	}

	if tmpl == nil {
		h.logger.Warn("template not found", zap.Int64("id", id))
		server.NotFound(c, "template not found")
		return
	}

	server.OK(c, tmpl)
}

func (h *TemplateHandler) UpdateTemplate(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		h.logger.Warn("invalid template id for update", zap.String("id", c.Param("id")))
		server.BadRequest(c, "invalid id")
		return
	}

	var req model.UpdateTemplateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		h.logger.Warn("invalid request body for update template", zap.Int64("id", id), zap.Error(err))
		server.BadRequest(c, "invalid request body")
		return
	}

	if err := h.store.Update(c.Request.Context(), id, &req); err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			h.logger.Warn("template not found for update", zap.Int64("id", id))
			server.NotFound(c, "template not found")
			return
		}
		h.logger.Error("failed to update template", zap.Int64("id", id), zap.Error(err))
		server.InternalError(c, "failed to update template")
		return
	}

	h.logger.Info("template updated", zap.Int64("id", id))
	server.OK(c, gin.H{"message": "template updated"})
}

func (h *TemplateHandler) DeleteTemplate(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		h.logger.Warn("invalid template id for delete", zap.String("id", c.Param("id")))
		server.BadRequest(c, "invalid id")
		return
	}

	if err := h.store.Delete(c.Request.Context(), id); err != nil {
		h.logger.Error("failed to delete template", zap.Int64("id", id), zap.Error(err))
		server.InternalError(c, err.Error())
		return
	}

	h.logger.Info("template deleted", zap.Int64("id", id))
	server.OK(c, gin.H{"message": "template deleted"})
}