hospital-admin-api/api/controller/adminRole.go

package controller

import (
	"github.com/gin-gonic/gin"
	"hospital-admin-api/api/dao"
	"hospital-admin-api/api/requests"
	"hospital-admin-api/api/responses"
	"hospital-admin-api/api/responses/roleResponse"
	"hospital-admin-api/api/service"
	"hospital-admin-api/global"
	"hospital-admin-api/utils"
	"strconv"
)

type Role struct{}

// GetRolePage 获取角色列表-分页
func (r *Role) GetRolePage(c *gin.Context) {
	RoleRequest := requests.RoleRequest{}
	if err := c.ShouldBind(&RoleRequest.GetRolePage); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(RoleRequest.GetRolePage); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	if RoleRequest.GetRolePage.Page == 0 {
		RoleRequest.GetRolePage.Page = 1
	}

	if RoleRequest.GetRolePage.PageSize == 0 {
		RoleRequest.GetRolePage.PageSize = 20
	}

	AdminRoleDao := dao.AdminRoleDao{}
	adminRole, total, err := AdminRoleDao.GetAdminRolePageSearch(RoleRequest.GetRolePage.RoleName, RoleRequest.GetRolePage.Page, RoleRequest.GetRolePage.PageSize)

	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	getRolePageResponses := make([]roleResponse.GetRolePage, len(adminRole))

	if len(adminRole) > 0 {
		for i, v := range adminRole {
			// 将原始结构体转换为新结构体
			getRolePageResponse := roleResponse.GetRolePage{
				RoleId:     strconv.Itoa(int(v.RoleId)),
				RoleName:   v.RoleName,
				RoleStatus: v.RoleStatus,
				IsAdmin:    v.IsAdmin,
				CreatedAt:  v.CreatedAt,
				UpdatedAt:  v.UpdatedAt,
			}

			// 将转换后的结构体添加到新切片中
			getRolePageResponses[i] = getRolePageResponse
		}
	}

	result := make(map[string]interface{})
	result["page"] = RoleRequest.GetRolePage.Page
	result["page_size"] = RoleRequest.GetRolePage.PageSize
	result["total"] = total
	result["data"] = getRolePageResponses
	responses.OkWithData(result, c)
}

// PutRoleStatus 角色禁用/启用
// 此处应该允许修改下级角色
func (r *Role) PutRoleStatus(c *gin.Context) {
	RoleRequest := requests.RoleRequest{}
	if err := c.ShouldBind(&RoleRequest.PutRoleStatus); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(RoleRequest.PutRoleStatus); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	roleId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 不可修改自己
	if roleId == c.GetInt64("RoleId") {
		responses.FailWithMessage("无法操作当前账号所属角色", c)
		return
	}

	// 获取角色身份
	roleService := service.RoleService{}
	isAdmin, err := roleService.GetRoleIden(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if !isAdmin {
		responses.FailWithMessage("非管理员，无法修改", c)
		return
	}

	RoleService := service.RoleService{}
	_, err = RoleService.PutRoleStatus(roleId, RoleRequest.PutRoleStatus.RoleStatus)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	responses.Ok(c)
}

// AddRole 新增角色
func (r *Role) AddRole(c *gin.Context) {
	RoleRequest := requests.RoleRequest{}
	if err := c.ShouldBindJSON(&RoleRequest.AddRole); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(RoleRequest.AddRole); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 判断菜单数据是否为空
	if len(RoleRequest.AddRole.MenuIds) == 0 {
		responses.FailWithMessage("请为角色添加菜单", c)
		return
	}

	// 获取角色身份
	roleService := service.RoleService{}
	isAdmin, err := roleService.GetRoleIden(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if !isAdmin {
		responses.FailWithMessage("非管理员，无法操作", c)
		return
	}

	// 业务处理
	RoleService := service.RoleService{}
	_, err = RoleService.AddRole(c, RoleRequest.AddRole)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}
	responses.Ok(c)
}

// GetRole 角色详情
func (r *Role) GetRole(c *gin.Context) {
	id := c.Param("role_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	roleId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 获取角色数据
	adminRoleDao := dao.AdminRoleDao{}
	adminRole, err := adminRoleDao.GetAdminRoleFirstById(roleId)
	if err != nil || adminRole == nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	isAdmin := false
	if adminRole.IsAdmin == 1 {
		isAdmin = true
	}

	RoleService := service.RoleService{}
	adminRole, menuIds, err := RoleService.GetRole(roleId, isAdmin)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理返回值
	// 转换int64为string
	var menuIdsString []string
	for _, menuId := range menuIds {
		menuId := strconv.FormatInt(menuId, 10)
		menuIdsString = append(menuIdsString, menuId)
	}

	// 转换int64为string
	RoleId := strconv.FormatInt(adminRole.RoleId, 10)
	if err != nil {
		responses.Fail(c)
		return
	}

	GetRoleResponse := &roleResponse.GetRole{
		MenuIds:    menuIdsString,
		RoleId:     RoleId,
		RoleName:   adminRole.RoleName,
		RoleStatus: adminRole.RoleStatus,
		IsAdmin:    adminRole.IsAdmin,
	}

	responses.OkWithData(GetRoleResponse, c)
}

// PutRole 修改角色
func (r *Role) PutRole(c *gin.Context) {
	roleRequest := requests.RoleRequest{}
	if err := c.ShouldBindJSON(&roleRequest.PutRole); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(roleRequest.PutRole); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	id := c.Param("role_id")
	if id == "" {
		responses.FailWithMessage("缺少参数", c)
		return
	}

	// 将 id 转换为 int64 类型
	roleId, err := strconv.ParseInt(id, 10, 64)
	if err != nil {
		responses.Fail(c)
		return
	}

	// 判断菜单数据是否为空
	if len(roleRequest.PutRole.MenuIds) == 0 {
		responses.FailWithMessage("请为角色添加菜单", c)
		return
	}

	// 获取角色身份
	roleService := service.RoleService{}
	isAdmin, err := roleService.GetRoleIden(c)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if !isAdmin {
		responses.FailWithMessage("非管理员，无法操作", c)
		return
	}

	// 业务处理
	_, err = roleService.PutRole(roleId, roleRequest.PutRole)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}
	responses.Ok(c)
}

// DeleteRole 删除角色-批量
func (r *Role) DeleteRole(c *gin.Context) {
	roleRequest := requests.RoleRequest{}
	if err := c.ShouldBindJSON(&roleRequest.DeleteRole); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(roleRequest.DeleteRole); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 业务处理
	roleService := service.RoleService{}
	_, err := roleService.DeleteRole(c, roleRequest.DeleteRole)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}
	responses.Ok(c)
}

// GetRoleList 获取角色列表
func (r *Role) GetRoleList(c *gin.Context) {
	roleRequest := requests.RoleRequest{}
	if err := c.ShouldBind(&roleRequest.GetRoleList); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(roleRequest.GetRoleList); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	adminRoleDao := dao.AdminRoleDao{}

	maps := make(map[string]interface{})
	if roleRequest.GetRoleList.RoleName != "" {
		maps["role_name"] = roleRequest.GetRoleList.RoleName
	}
	adminRoles, err := adminRoleDao.GetAdminRoleList(maps)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	if len(adminRoles) == 0 {
		responses.Ok(c)
		return
	}

	// 处理返回值
	getRoleListResponses := roleResponse.GetRoleListResponse(adminRoles)

	responses.OkWithData(getRoleListResponses, c)
}