dy-admin-temp/internal/pcmserver/sys/service/role.go

package service

import (
	"dy-admin/internal/pcmserver/common"
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/pkg/code"
	"dy-admin/internal/pcmserver/sys/model"
	"dy-admin/pkg/rescode"
	"fmt"
	"github.com/pkg/errors"
	"gorm.io/gorm"
	"strconv"
)

type RoleService struct {
}

func (rs *RoleService) CreateRole(role model.Role) (err error) {
	var menus []model.Menu

	err = global.DB.Where("role_name = ?", role.RoleName).First(&model.Role{}).Error
	if !errors.Is(err, gorm.ErrRecordNotFound) {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrRoleAlreadyExistCode])
	}

	err = global.DB.Preload("SysApi").Where("menu_id in ?", role.MenuIds).Find(&menus).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	role.SysMenu = menus

	// 默认角色数据权限。 只能查看本部门数据
	if role.DataScope == "" {
		role.DataScope = "4"
	}

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	err = tx.Create(&role).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	//排重map
	repetitionMap := make(map[string]struct{})
	polices := make([][]string, 0)
	for _, menu := range menus {
		for _, api := range menu.SysApi {
			key := role.RoleName + "-" + api.Path + "-" + api.Action
			if _, ok := repetitionMap[key]; !ok {
				repetitionMap[key] = struct{}{}
				polices = append(polices, []string{strconv.Itoa(role.RoleID), api.Path, api.Action})
			}
		}
	}

	// 每个角色的默认权限
	for _, defaultApi := range model.DefaultAPIs() {
		polices = append(polices, []string{strconv.Itoa(role.RoleID), defaultApi.Path, defaultApi.Action})
	}

	if len(polices) == 0 {
		return
	}

	_, err = CasbinServiceInstance.Casbin().AddPolicies(polices)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}

	err = CasbinServiceInstance.Casbin().InvalidateCache()
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}

	return
}

func (rs *RoleService) UpdateRole(role model.Role) (err error) {
	var oldRole model.Role
	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	// 关联查到角色对应的菜单
	tx.Preload("SysMenu").First(&oldRole, role.RoleID)
	var newMenuList []model.Menu
	// 查询新的的菜单数据，关联查询api
	tx.Preload("SysApi").Where("menu_id in ?", role.MenuIds).Find(&newMenuList)

	// 删除角色绑定的旧菜单
	err = tx.Model(&oldRole).Association("SysMenu").Delete(oldRole.SysMenu)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	role.SysMenu = newMenuList

	err = tx.Session(&gorm.Session{FullSaveAssociations: true}).Debug().Updates(&role).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 删除casbin规则
	_, err = CasbinServiceInstance.ClearCasbin(0, strconv.Itoa(role.RoleID))
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}

	repetitionMap := make(map[string]struct{})
	polices := make([][]string, 0)
	for _, menu := range newMenuList {
		for _, api := range menu.SysApi {
			key := role.RoleName + "-" + api.Path + "-" + api.Action
			if _, ok := repetitionMap[key]; !ok {
				repetitionMap[key] = struct{}{}
				polices = append(polices, []string{strconv.Itoa(role.RoleID), api.Path, api.Action})
			}
		}
	}

	// 每个角色的默认权限
	for _, defaultApi := range model.DefaultAPIs() {
		polices = append(polices, []string{strconv.Itoa(role.RoleID), defaultApi.Path, defaultApi.Action})
	}

	if len(polices) == 0 {
		return
	}

	_, err = CasbinServiceInstance.Casbin().AddPolicies(polices)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}

	err = CasbinServiceInstance.Casbin().InvalidateCache()
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}

	return
}

func (rs *RoleService) DeleteRole(roleId int) (err error) {

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	// 角色是否存在
	var role model.Role
	err = tx.Preload("SysMenu").Preload("SysDept").Preload("SysUser").Where("role_id = ?", roleId).First(&role).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 角色下如果存在用户,不允许删除
	if len(role.SysUser) != 0 {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrRoleHasUserCode])
	}

	// 删除角色关联菜单
	err = tx.Model(&role).Association("SysMenu").Delete(role.SysMenu)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	err = tx.Model(&role).Association("SysDept").Delete(role.SysDept)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 删除角色
	err = tx.Delete(&role, role.RoleID).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// casbin清除角色权限
	_, err = CasbinServiceInstance.ClearCasbin(0, strconv.Itoa(role.RoleID))
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCasbinInternalCode])
	}
	return
}

// GetRoleList 分页获取角色数据
func (rs *RoleService) GetRoleList(role model.Role, info common.PageInfo, order string, desc bool) (list []model.Role, total int64, err error) {
	var limit, offset int
	if info.Page == 0 || info.PageSize == 0 {
		limit = -1
		offset = -1
	} else {
		limit = info.PageSize
		offset = info.PageSize * (info.Page - 1)
	}

	db := global.DB.Model(&model.Role{}).Preload("SysMenu").Preload("SysDept").Where("role_id !=?", 2)
	if role.RoleName != "" {
		db.Where("role_name LIKE ?", "%"+role.RoleName+"%")
	}
	if role.Status != "" {
		db.Where("status = ?", role.Status)
	}
	err = db.Count(&total).Error
	if err != nil {
		return list, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	db.Limit(limit).Offset(offset)

	if order == "" {
		err = db.Order("role_sort asc").Find(&list).Error
		if err != nil {
			return list, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		}
		return
	}

	var OrderStr string
	allowOrderField := role.AllowOrderField()
	if _, ok := allowOrderField[order]; !ok {
		msg := fmt.Sprintf("params=>order:%s", order)
		return list, total,
			rescode.RegisterErrorWithMessage(errors.New("非法排序字段"), msg, code.ErrCodeMap[code.ErrIllegalOrderFieldCode])
	}
	if desc {
		OrderStr = order + " desc"
	} else {
		OrderStr = order
	}
	err = db.Order(OrderStr).Find(&list).Error

	return
}

func (rs *RoleService) GetRoleById(roleId int) (role model.Role, err error) {
	if err = global.DB.Where("role_id = ?", roleId).Preload("SysMenu").Preload("SysDept").First(&role).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return role, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrRoleNotFoundCode])
		}
	}
	role.MenuIds, err = rs.GetRoleMenuIDs(roleId)
	role.DeptIds, err = rs.GetRoleDeptIDs(roleId)
	return
}
func (rs *RoleService) GetRoleMenuIDs(roleId int) (menuIds []int, err error) {
	var role model.Role
	if err := global.DB.Preload("SysMenu").Where("role_id = ?", roleId).First(&role).Error; err != nil {
		return menuIds, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	for _, menu := range role.SysMenu {
		menuIds = append(menuIds, menu.MenuID)
	}

	return menuIds, nil
}

func (rs *RoleService) GetRoleDeptIDs(roleId int) (deptIds []int, err error) {
	var role model.Role
	if err := global.DB.Preload("SysDept").Where("role_id = ?", roleId).First(&role).Error; err != nil {
		return deptIds, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	for _, dept := range role.SysDept {
		deptIds = append(deptIds, dept.DeptID)
	}

	return deptIds, nil
}

func (rs *RoleService) UpdateDataScope(roleId int, dataScope string, deptIds []int) (err error) {
	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	var role model.Role
	tx.Preload("SysDept").First(&role, roleId)
	var deptList []model.Dept
	tx.Where("dept_id in ?", deptIds).Find(&deptList)

	// 删除旧的
	err = tx.Model(&role).Association("SysDept").Delete(role.SysDept)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	role.SysDept = deptList
	role.DataScope = dataScope
	err = tx.Model(&role).Session(&gorm.Session{FullSaveAssociations: true}).Debug().Updates(&role).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}