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

package controller

import (
	"net/http"
	"strconv"

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

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

type PermissionController struct {
	permissionService *service.PermissionService
}

func NewPermissionController(permissionService *service.PermissionService) *PermissionController {
	return &PermissionController{
		permissionService: permissionService,
	}
}

// GetPermission 获取权限详情
// @Summary 获取权限详情
// @Description 根据ID获取权限详情
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param id path int true "权限ID"
// @Success 200 {object} response.Response{data=model.Permission}
// @Failure 400 {object} response.Response
// @Failure 404 {object} response.Response
// @Router /api/auth/permissions/{id} [get]
func (c *PermissionController) GetPermission(ctx *gin.Context) {
	idStr := ctx.Param("id")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "无效的权限ID", err.Error())
		return
	}

	permission, err := c.permissionService.GetPermissionByID(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusNotFound, "权限不存在", err.Error())
		return
	}

	response.Success(ctx, "获取权限成功", permission)
}

// ListPermissions 获取权限列表
// @Summary 获取权限列表
// @Description 分页获取权限列表
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param page query int false "页码" default(1)
// @Param pageSize query int false "每页数量" default(10)
// @Success 200 {object} response.Response{data=map[string]interface{}}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions [get]
func (c *PermissionController) ListPermissions(ctx *gin.Context) {
	page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
	pageSize, _ := strconv.Atoi(ctx.DefaultQuery("pageSize", "10"))

	if page < 1 {
		page = 1
	}
	if pageSize < 1 || pageSize > 100 {
		pageSize = 10
	}

	offset := (page - 1) * pageSize

	permissions, total, err := c.permissionService.ListPermissions(ctx.Request.Context(), offset, pageSize)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限列表失败", err.Error())
		return
	}

	result := map[string]interface{}{
		"list":     permissions,
		"total":    total,
		"page":     page,
		"pageSize": pageSize,
	}

	response.Success(ctx, "获取权限列表成功", result)
}

// GetPermissionsByBackendRoute 根据后端路由获取权限
// @Summary 根据后端路由获取权限
// @Description 根据后端路由获取相关权限
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param backendRoute query string true "后端路由"
// @Success 200 {object} response.Response{data=[]model.Permission}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions/backend-route [get]
func (c *PermissionController) GetPermissionsByBackendRoute(ctx *gin.Context) {
	backendRoute := ctx.Query("backendRoute")
	if backendRoute == "" {
		response.Error(ctx, http.StatusBadRequest, "后端路由不能为空", "")
		return
	}

	permissions, err := c.permissionService.GetPermissionsByBackendRoute(ctx.Request.Context(), backendRoute)
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限成功", permissions)
}

// GetPermissionsByMenuID 根据菜单ID获取权限
// @Summary 根据菜单ID获取权限
// @Description 根据菜单ID获取相关权限
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param menuId path int true "菜单ID"
// @Success 200 {object} response.Response{data=[]model.Permission}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions/menu/{menuId} [get]
func (c *PermissionController) GetPermissionsByMenuID(ctx *gin.Context) {
	idStr := ctx.Param("menuId")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "无效的菜单ID", err.Error())
		return
	}

	permissions, err := c.permissionService.GetPermissionsByMenuID(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限成功", permissions)
}

// GetPermissionsByMenuGroupID 根据菜单分组ID获取权限
// @Summary 根据菜单分组ID获取权限
// @Description 根据菜单分组ID获取相关权限
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param menuGroupId path int true "菜单分组ID"
// @Success 200 {object} response.Response{data=[]model.Permission}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions/menu-group/{menuGroupId} [get]
func (c *PermissionController) GetPermissionsByMenuGroupID(ctx *gin.Context) {
	idStr := ctx.Param("menuGroupId")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "无效的菜单分组ID", err.Error())
		return
	}

	permissions, err := c.permissionService.GetPermissionsByMenuGroupID(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限成功", permissions)
}

// GetPermissionsByAuthResourceID 根据认证资源ID获取权限
// @Summary 根据认证资源ID获取权限
// @Description 根据认证资源ID获取相关权限
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param authResourceId path int true "认证资源ID"
// @Success 200 {object} response.Response{data=[]model.Permission}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions/auth-resource/{authResourceId} [get]
func (c *PermissionController) GetPermissionsByAuthResourceID(ctx *gin.Context) {
	idStr := ctx.Param("authResourceId")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "无效的认证资源ID", err.Error())
		return
	}

	permissions, err := c.permissionService.GetPermissionsByAuthResourceID(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取权限失败", err.Error())
		return
	}

	response.Success(ctx, "获取权限成功", permissions)
}

// GetUserPermissions 获取用户权限
// @Summary 获取用户权限
// @Description 根据用户ID获取用户的所有权限
// @Tags 权限管理
// @Accept json
// @Produce json
// @Param userId path int true "用户ID"
// @Success 200 {object} response.Response{data=[]model.Permission}
// @Failure 400 {object} response.Response
// @Router /api/auth/permissions/user/{userId} [get]
func (c *PermissionController) GetUserPermissions(ctx *gin.Context) {
	idStr := ctx.Param("userId")
	id, err := strconv.ParseUint(idStr, 10, 32)
	if err != nil {
		response.Error(ctx, http.StatusBadRequest, "无效的用户ID", err.Error())
		return
	}

	permissions, err := c.permissionService.GetUserPermissions(ctx.Request.Context(), uint(id))
	if err != nil {
		response.Error(ctx, http.StatusInternalServerError, "获取用户权限失败", err.Error())
		return
	}

	response.Success(ctx, "获取用户权限成功", permissions)
}