shop/modules/system/service/role_service.go

package service

import (
	"bytes"
	"github.com/druidcaesa/gotool"
	"ulink-admin/frame"
	dao2 "ulink-admin/modules/system/dao"
	"ulink-admin/modules/system/models/model"
	req2 "ulink-admin/modules/system/models/req"
	"ulink-admin/pkg/base"
	"xorm.io/xorm"
)

type RoleService struct {
	RoleDao     *dao2.RoleDao     `inject:""`
	RoleMenuDao *dao2.RoleMenuDao `inject:""`
	UserRoleDao *dao2.UserRoleDao `inject:""`
}

// SelectRoleAll 查询所有角色
func (s RoleService) List(query *req2.RoleQuery, list interface{}) {
	s.RoleDao.List(query, list)
}

// SelectRoleListByUserId 根据用户id查询角色id集合
func (s RoleService) SelectRoleListByUserId(parseInt int64) *[]int64 {
	return s.RoleDao.SelectRoleListByUserId(parseInt)
}

// GetRoleListByUserId 根据用户ID查询角色
func (s RoleService) GetRoleListByUserId(id int64) *[]model.SysRole {
	return s.RoleDao.GetRoleListByUserId(id)
}

// FindList 分页查询角色数据
func (s RoleService) Page(query *req2.RoleQuery, list interface{}) int64 {
	return s.RoleDao.Page(query, list)
}

// SelectRoleByRoleId 根据角色id查询角色数据
func (s RoleService) GetById(id int64, model interface{}) {
	s.RoleDao.GetById(id, model)
}

// Add 添加角色数据
func (s RoleService) Add(role *model.SysRole) {
	if s.RoleDao.Exist(role.TableName(), "role_name=?", role.RoleName) {
		frame.Throw(frame.BUSINESS_CODE, "新增角色'"+role.RoleName+"'失败，角色名称已存在")
	}
	if s.RoleDao.Exist(role.TableName(), "role_key=?", role.RoleKey) {
		frame.Throw(frame.BUSINESS_CODE, "新增角色'"+role.RoleName+"'失败，角色权限标识已存在")
	}
	base.Transaction(func(session *xorm.Session) {
		s.RoleDao.Insert(role)
		s.insertRoleMenu(role)
	})
}

// 添加角色菜单关系
func (s RoleService) insertRoleMenu(role *model.SysRole) {
	list := make([]model.SysRoleMenu, 0)
	for _, id := range role.MenuIds {
		menu := model.SysRoleMenu{
			RoleId: role.Id,
			MenuId: id,
		}
		list = append(list, menu)
	}
	s.RoleMenuDao.Add(list)
}

// Update 修改角色数据
func (s RoleService) Update(role *model.SysRole) {
	if s.RoleDao.Exist(role.TableName(), "role_name=? and id!=?", role.RoleKey, role.Id) {
		frame.Throw(frame.BUSINESS_CODE, "新增角色'"+role.RoleName+"'失败，角色名称已存在")
	}
	if s.RoleDao.Exist(role.TableName(), "role_key=? and   id!=?", role.RoleKey, role.Id) {
		frame.Throw(frame.BUSINESS_CODE, "新增角色'"+role.RoleName+"'失败，角色权限标识已存在")
	}
	base.Transaction(func(session *xorm.Session) {
		//删除菜单关联关系
		s.RoleMenuDao.Delete(role)
		s.insertRoleMenu(role)
		//修改数据
		s.RoleDao.Update(role)
	})
}

// Delete 删除角色
func (s RoleService) Delete(id int64) {
	//删除角色相关表
	base.Transaction(func(session *xorm.Session) {
		s.RoleDao.Delete(&model.SysRole{}, id)
		s.RoleMenuDao.Delete(&model.SysRole{
			BaseModel: base.BaseModel{Id: id},
		})
	})
}

// CheckRoleAllowed 校验是否可以操作
func (s RoleService) CheckRoleAllowed(id int64) (bool, string) {
	if id == 1 {
		return false, "超级管理员不允许操作"
	}
	return true, ""
}

// UpdateRoleStatus 角色状态修改
func (s RoleService) UpdateStatus(role *model.SysRole) {
	s.RoleDao.Update(role, "status")
}

// DeleteAuthUser 取消授权用户
func (s RoleService) DeleteAuthUser(userRole *model.SysUserRole) {
	s.UserRoleDao.DeleteAuthUser(userRole)
}

// BatchCancelAuthUsers 批量取消用户授权
func (s RoleService) BatchCancelAuthUsers(body *req2.UserRoleBody) {
	s.UserRoleDao.BatchCancelAuthUsers(body)
}

// InsertAuthUsers 批量选择用户授权
func (s RoleService) InsertAuthUsers(body *req2.UserRoleBody) {
	s.UserRoleDao.InsertAuthUsers(body)
}

// SelectRolesByUserName 查询所属角色组
func (s RoleService) SelectRolesByUserName(name string) string {
	list := s.RoleDao.SelectRolesByUserName(name)
	var buffer bytes.Buffer
	var roleName string
	for _, role := range *list {
		buffer.WriteString(role.RoleName)
		buffer.WriteString(",")
	}
	s2 := buffer.String()
	if gotool.StrUtils.HasNotEmpty(s2) {
		roleName = s2[0:(len(s2) - 1)]
	}
	return roleName
}