manta/gofaster/backend/internal/auth/controller/menu_group_controller.go

package controller

import (
	"net/http"
	"strconv"
	"gofaster/internal/auth/model"
	"gofaster/internal/auth/service"
	"gofaster/internal/shared/response"

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

// MenuGroupController 菜单分组控制器
type MenuGroupController struct {
	menuGroupService *service.MenuGroupService
	logger           *zap.Logger
}

// NewMenuGroupController 创建菜单分组控制器实例
func NewMenuGroupController(menuGroupService *service.MenuGroupService, logger *zap.Logger) *MenuGroupController {
	return &MenuGroupController{
		menuGroupService: menuGroupService,
		logger:           logger,
	}
}

// CreateMenuGroup 创建菜单分组
// @Summary 创建菜单分组
// @Description 创建新的菜单分组
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param menuGroup body model.MenuGroup true "菜单分组信息"
// @Success 200 {object} response.Response{data=model.MenuGroup}
// @Failure 400 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups [post]
func (c *MenuGroupController) CreateMenuGroup(ctx *gin.Context) {
	var menuGroup model.MenuGroup
	if err := ctx.ShouldBindJSON(&menuGroup); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	// 验证必填字段
	if menuGroup.Name == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "分组名称不能为空")
		return
	}

	if err := c.menuGroupService.CreateMenuGroup(&menuGroup); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "创建菜单分组失败", err.Error())
		return
	}

	response.Success(ctx, "创建菜单分组成功", menuGroup)
}

// GetMenuGroup 获取菜单分组详情
// @Summary 获取菜单分组详情
// @Description 根据ID获取菜单分组详情
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param id path int true "菜单分组ID"
// @Success 200 {object} response.Response{data=model.MenuGroup}
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/{id} [get]
func (c *MenuGroupController) GetMenuGroup(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID格式错误")
		return
	}

	menuGroup, err := c.menuGroupService.GetMenuGroupByID(uint(id))
	if err != nil {
		response.Error(ctx, http.StatusNotFound, "菜单分组不存在", err.Error())
		return
	}

	response.Success(ctx, "获取菜单分组成功", menuGroup)
}

// ListMenuGroups 获取菜单分组列表
// @Summary 获取菜单分组列表
// @Description 获取所有菜单分组列表
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param status query int false "状态筛选" Enums(0,1)
// @Success 200 {object} response.Response{data=[]model.MenuGroup}
// @Failure 500 {object} response.Response
// @Router /api/menu-groups [get]
func (c *MenuGroupController) ListMenuGroups(ctx *gin.Context) {
	statusStr := ctx.Query("status")
	
	var menuGroups []*model.MenuGroup
	var err error

	if statusStr != "" {
		status, parseErr := strconv.Atoi(statusStr)
		if parseErr != nil {
			response.Error(ctx, http.StatusBadRequest, "请求参数错误", "状态参数格式错误")
			return
		}
		menuGroups, err = c.menuGroupService.ListMenuGroupsByStatus(status)
	} else {
		menuGroups, err = c.menuGroupService.ListMenuGroups()
	}

	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取菜单分组列表失败", err.Error())
		return
	}

	response.Success(ctx, "获取菜单分组列表成功", menuGroups)
}

// UpdateMenuGroup 更新菜单分组
// @Summary 更新菜单分组
// @Description 更新菜单分组信息
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param id path int true "菜单分组ID"
// @Param menuGroup body model.MenuGroup true "菜单分组信息"
// @Success 200 {object} response.Response{data=model.MenuGroup}
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/{id} [put]
func (c *MenuGroupController) UpdateMenuGroup(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID格式错误")
		return
	}

	var menuGroup model.MenuGroup
	if err := ctx.ShouldBindJSON(&menuGroup); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	// 验证必填字段
	if menuGroup.Name == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "分组名称不能为空")
		return
	}

	menuGroup.ID = uint(id)

	if err := c.menuGroupService.UpdateMenuGroup(&menuGroup); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "更新菜单分组失败", err.Error())
		return
	}

	response.Success(ctx, "更新菜单分组成功", menuGroup)
}

// DeleteMenuGroup 删除菜单分组
// @Summary 删除菜单分组
// @Description 根据ID删除菜单分组
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param id path int true "菜单分组ID"
// @Success 200 {object} response.Response
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/{id} [delete]
func (c *MenuGroupController) DeleteMenuGroup(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID格式错误")
		return
	}

	if err := c.menuGroupService.DeleteMenuGroup(uint(id)); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "删除菜单分组失败", err.Error())
		return
	}

	response.Success(ctx, "删除菜单分组成功", nil)
}

// BatchDeleteMenuGroups 批量删除菜单分组
// @Summary 批量删除菜单分组
// @Description 批量删除菜单分组
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param ids body []uint true "菜单分组ID列表"
// @Success 200 {object} response.Response
// @Failure 400 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/batch-delete [post]
func (c *MenuGroupController) BatchDeleteMenuGroups(ctx *gin.Context) {
	var request struct {
		IDs []uint `json:"ids" binding:"required"`
	}

	if err := ctx.ShouldBindJSON(&request); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if len(request.IDs) == 0 {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID列表不能为空")
		return
	}

	if err := c.menuGroupService.BatchDeleteMenuGroups(request.IDs); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "批量删除菜单分组失败", err.Error())
		return
	}

	response.Success(ctx, "批量删除菜单分组成功", nil)
}

// UpdateMenuGroupStatus 更新菜单分组状态
// @Summary 更新菜单分组状态
// @Description 更新菜单分组状态
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param id path int true "菜单分组ID"
// @Param request body map[string]int true "状态信息" SchemaExample({"status": 1})
// @Success 200 {object} response.Response
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/{id}/status [put]
func (c *MenuGroupController) UpdateMenuGroupStatus(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID格式错误")
		return
	}

	var request struct {
		Status int `json:"status" binding:"required"`
	}

	if err := ctx.ShouldBindJSON(&request); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if err := c.menuGroupService.UpdateMenuGroupStatus(uint(id), request.Status); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "更新菜单分组状态失败", err.Error())
		return
	}

	response.Success(ctx, "更新菜单分组状态成功", nil)
}

// UpdateMenuGroupSort 更新菜单分组排序
// @Summary 更新菜单分组排序
// @Description 更新菜单分组排序
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param id path int true "菜单分组ID"
// @Param request body map[string]int true "排序信息" SchemaExample({"sort": 1})
// @Success 200 {object} response.Response
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/{id}/sort [put]
func (c *MenuGroupController) UpdateMenuGroupSort(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "ID格式错误")
		return
	}

	var request struct {
		Sort int `json:"sort" binding:"required"`
	}

	if err := ctx.ShouldBindJSON(&request); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if err := c.menuGroupService.UpdateMenuGroupSort(uint(id), request.Sort); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "更新菜单分组排序失败", err.Error())
		return
	}

	response.Success(ctx, "更新菜单分组排序成功", nil)
}

// BatchUpdateMenuGroupSort 批量更新菜单分组排序
// @Summary 批量更新菜单分组排序
// @Description 批量更新菜单分组排序
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Param request body map[uint]int true "排序信息" SchemaExample({"1": 1, "2": 2})
// @Success 200 {object} response.Response
// @Failure 400 {object} response.Response
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/batch-sort [put]
func (c *MenuGroupController) BatchUpdateMenuGroupSort(ctx *gin.Context) {
	var request map[uint]int

	if err := ctx.ShouldBindJSON(&request); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if len(request) == 0 {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "排序数据不能为空")
		return
	}

	if err := c.menuGroupService.BatchUpdateMenuGroupSort(request); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "批量更新菜单分组排序失败", err.Error())
		return
	}

	response.Success(ctx, "批量更新菜单分组排序成功", nil)
}

// GetMenuGroupStats 获取菜单分组统计信息
// @Summary 获取菜单分组统计信息
// @Description 获取菜单分组统计信息
// @Tags 菜单分组管理
// @Accept json
// @Produce json
// @Success 200 {object} response.Response{data=map[string]interface{}}
// @Failure 500 {object} response.Response
// @Router /api/menu-groups/stats [get]
func (c *MenuGroupController) GetMenuGroupStats(ctx *gin.Context) {
	stats, err := c.menuGroupService.GetMenuGroupStats()
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取菜单分组统计信息失败", err.Error())
		return
	}

	response.Success(ctx, "获取菜单分组统计信息成功", stats)
}