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

package controller

import (
	"net/http"
	"strconv"

	"gofaster/internal/auth/model"
	"gofaster/internal/auth/repository"
	"gofaster/internal/auth/service"
	"gofaster/internal/shared/response"

	"github.com/gin-gonic/gin"
)

type ResourceController struct {
	resourceService  *service.ResourceService
	routeMappingRepo *repository.RouteMappingRepository
}

func NewResourceController(resourceService *service.ResourceService, routeMappingRepo *repository.RouteMappingRepository) *ResourceController {
	return &ResourceController{
		resourceService:  resourceService,
		routeMappingRepo: routeMappingRepo,
	}
}

// CreateResource 创建资源
func (c *ResourceController) CreateResource(ctx *gin.Context) {
	var resource model.Resource
	if err := ctx.ShouldBindJSON(&resource); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	if err := c.resourceService.CreateResource(ctx.Request.Context(), &resource); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "创建资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源创建成功", resource)
}

// UpdateResource 更新资源
func (c *ResourceController) UpdateResource(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 resource model.Resource
	if err := ctx.ShouldBindJSON(&resource); err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", err.Error())
		return
	}

	resource.ID = uint(id)

	if err := c.resourceService.UpdateResource(ctx.Request.Context(), &resource); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "更新资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源更新成功", resource)
}

// DeleteResource 删除资源
func (c *ResourceController) DeleteResource(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.resourceService.DeleteResource(ctx.Request.Context(), uint(id)); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "删除资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源删除成功", nil)
}

// GetResource 获取资源详情
func (c *ResourceController) GetResource(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "无效的资源ID")
		return
	}

	resource, err := c.resourceService.GetResource(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusNotFound, "资源不存在", err.Error())
		return
	}

	response.Success(ctx, "获取资源成功", resource)
}

// ListResources 获取资源列表
func (c *ResourceController) ListResources(ctx *gin.Context) {
	pageStr := ctx.DefaultQuery("page", "1")
	pageSizeStr := ctx.DefaultQuery("pageSize", "10")

	page, err := strconv.Atoi(pageStr)
	if err != nil || page < 1 {
		page = 1
	}

	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize < 1 || pageSize > 100 {
		pageSize = 10
	}

	resources, total, err := c.resourceService.ListResources(ctx.Request.Context(), page, pageSize)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取资源列表失败", err.Error())
		return
	}

	response.Success(ctx, "获取资源列表成功", gin.H{
		"data":  resources,
		"page":  page,
		"size":  pageSize,
		"total": total,
	})
}

// GetResourceTree 获取资源树
func (c *ResourceController) GetResourceTree(ctx *gin.Context) {
	resources, err := c.resourceService.GetResourceTree(ctx.Request.Context())
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取资源树失败", err.Error())
		return
	}

	response.Success(ctx, "获取资源树成功", resources)
}

// SyncResources 同步资源
func (c *ResourceController) SyncResources(ctx *gin.Context) {
	if err := c.resourceService.SyncResourcesFromRoutes(ctx.Request.Context()); err != nil {
		response.Error(ctx, http.StatusInternalServerError, "同步资源失败", err.Error())
		return
	}

	response.Success(ctx, "资源同步成功", nil)
}

// ListResourcesByModule 根据模块获取资源列表
func (c *ResourceController) ListResourcesByModule(ctx *gin.Context) {
	module := ctx.Param("module")
	if module == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "模块名称不能为空")
		return
	}

	resources, err := c.resourceService.ListResourcesByModule(ctx.Request.Context(), module)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取模块资源失败", err.Error())
		return
	}

	response.Success(ctx, "获取模块资源成功", resources)
}

// ListResourcesByType 根据类型获取资源列表
func (c *ResourceController) ListResourcesByType(ctx *gin.Context) {
	resourceType := ctx.Param("type")
	if resourceType == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "资源类型不能为空")
		return
	}

	resources, err := c.resourceService.ListResourcesByType(ctx.Request.Context(), resourceType)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取类型资源失败", err.Error())
		return
	}

	response.Success(ctx, "获取类型资源成功", resources)
}

// GetAuthGroupStats 获取权限分组统计
// @Summary 获取权限分组统计
// @Description 获取路由映射的权限分组统计信息
// @Tags 资源管理
// @Accept json
// @Produce json
// @Success 200 {object} response.Response{data=map[string]int}
// @Failure 400 {object} response.Response
// @Router /api/resources/auth-group-stats [get]
func (c *ResourceController) GetAuthGroupStats(ctx *gin.Context) {
	stats, err := c.routeMappingRepo.GetAuthGroupStats()
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限分组统计失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限分组统计成功", stats)
}

// ListRoutesByAuthGroup 根据权限分组获取路由列表
// @Summary 根据权限分组获取路由列表
// @Description 根据权限分组获取路由映射列表
// @Tags 资源管理
// @Accept json
// @Produce json
// @Param authGroup path string true "权限分组" Enums(Read, Edit)
// @Success 200 {object} response.Response{data=[]model.RouteMapping}
// @Failure 400 {object} response.Response
// @Router /api/resources/auth-group/{authGroup}/routes [get]
func (c *ResourceController) ListRoutesByAuthGroup(ctx *gin.Context) {
	authGroup := ctx.Param("authGroup")
	if authGroup == "" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "权限分组不能为空")
		return
	}

	// 验证权限分组值
	if authGroup != "Read" && authGroup != "Edit" {
		response.Error(ctx, http.StatusBadRequest, "请求参数错误", "权限分组只能是Read或Edit")
		return
	}

	routes, err := c.routeMappingRepo.FindByAuthGroup(authGroup)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限分组路由失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限分组路由成功", routes)
}