geo/server/internal/tenant/transport/prompt_rule_handler.go

package transport

import (
	"strconv"

	"github.com/gin-gonic/gin"

	"github.com/geo-platform/tenant-api/internal/bootstrap"
	"github.com/geo-platform/tenant-api/internal/shared/response"
	"github.com/geo-platform/tenant-api/internal/tenant/app"
)

type PromptRuleHandler struct {
	svc *app.PromptRuleService
}

func NewPromptRuleHandler(a *bootstrap.App) *PromptRuleHandler {
	return &PromptRuleHandler{svc: app.NewPromptRuleService(a.DB, a.AuditLogs).WithCache(a.Cache)}
}

// --- Groups ---

func (h *PromptRuleHandler) ListGroups(c *gin.Context) {
	data, err := h.svc.ListGroups(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *PromptRuleHandler) CreateGroup(c *gin.Context) {
	var req app.PromptRuleGroupRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}
	data, err := h.svc.CreateGroup(c.Request.Context(), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.SuccessWithStatus(c, 201, data)
}

func (h *PromptRuleHandler) UpdateGroup(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("gid"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "group id must be a number"))
		return
	}
	var req app.PromptRuleGroupRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}
	if err := h.svc.UpdateGroup(c.Request.Context(), id, req); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, nil)
}

func (h *PromptRuleHandler) DeleteGroup(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("gid"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "group id must be a number"))
		return
	}
	if err := h.svc.DeleteGroup(c.Request.Context(), id); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, nil)
}

// --- Rules ---

func (h *PromptRuleHandler) List(c *gin.Context) {
	params := app.PromptRuleListParams{
		Page:     1,
		PageSize: 20,
	}
	if v := c.Query("page"); v != "" {
		if p, err := strconv.Atoi(v); err == nil {
			params.Page = p
		}
	}
	if v := c.Query("page_size"); v != "" {
		if ps, err := strconv.Atoi(v); err == nil {
			params.PageSize = ps
		}
	}
	if v := c.Query("group_id"); v != "" {
		if gid, err := strconv.ParseInt(v, 10, 64); err == nil {
			params.GroupID = &gid
		}
	}
	if v := c.Query("ungrouped"); v == "true" {
		params.Ungrouped = true
	}
	if v := c.Query("status"); v != "" {
		params.Status = &v
	}
	if v := c.Query("keyword"); v != "" {
		params.Keyword = &v
	}

	data, err := h.svc.List(c.Request.Context(), params)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *PromptRuleHandler) Detail(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
		return
	}
	data, err := h.svc.Detail(c.Request.Context(), id)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}

func (h *PromptRuleHandler) Create(c *gin.Context) {
	var req app.PromptRuleRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}
	data, err := h.svc.Create(c.Request.Context(), req)
	if err != nil {
		response.Error(c, err)
		return
	}
	response.SuccessWithStatus(c, 201, data)
}

func (h *PromptRuleHandler) Update(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
		return
	}
	var req app.PromptRuleRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}
	if err := h.svc.Update(c.Request.Context(), id, req); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, nil)
}

func (h *PromptRuleHandler) Delete(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
		return
	}
	if err := h.svc.Delete(c.Request.Context(), id); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, nil)
}

func (h *PromptRuleHandler) ToggleStatus(c *gin.Context) {
	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
	if err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_id", "rule id must be a number"))
		return
	}
	var req app.PromptRuleStatusRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, response.ErrBadRequest(40001, "invalid_params", err.Error()))
		return
	}
	if err := h.svc.ToggleStatus(c.Request.Context(), id, req); err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, nil)
}

func (h *PromptRuleHandler) ListSimple(c *gin.Context) {
	data, err := h.svc.ListSimple(c.Request.Context())
	if err != nil {
		response.Error(c, err)
		return
	}
	response.Success(c, data)
}