opms_backend/opms_admin/app/service/sys_role.go

package service

import (
	"context"
	"dashoo.cn/micro/app/common/global"
	"dashoo.cn/micro/app/common/service"
	"dashoo.cn/micro/app/dao"
	"dashoo.cn/micro/app/model"
	"dashoo.cn/opms_libary/utils"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
)

type roleService struct {
	*contextService
	Dao         *dao.SysRoleDao
	roleMenuDao *dao.SysRoleMenuDao
	roleDeptDao *dao.SysRoleDeptDao
}

func NewRoleService(ctx context.Context) (svc *roleService, err error) {
	svc = new(roleService)
	if svc.contextService, err = svc.Init(ctx); err != nil {
		return nil, err
	}
	svc.Dao = dao.NewSysRoleDao(svc.Tenant)
	svc.Table = svc.Dao.Table
	svc.roleMenuDao = dao.NewSysRoleMenuDao(svc.Tenant)
	svc.roleDeptDao = dao.NewSysRoleDeptDao(svc.Tenant)
	return svc, nil
}

// GetRoleList 获取角色列表
func (s *roleService) GetRoleList() (list []*model.SysRole, err error) {
	cache := service.Cache.New()
	//从缓存获取
	iList := cache.Get(global.SysRole)
	if iList != nil {
		err = gconv.Struct(iList, &list)
		return
	}
	//从数据库获取
	list, err = s.Dao.Order(s.Dao.Columns.Sort + " asc," + s.Dao.Columns.Id + " asc").All()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取角色数据失败")
	}
	//缓存数据
	cache.Set(global.SysRole, list, 0, global.SysAuthTag)
	iList = cache.Get(global.SysRole)
	return
}

func (s *roleService) GetRoleListSearch(req *model.SelectPageReq) (total int, list []*model.SysRole, err error) {
	db := dao.SysRole.M
	if req.RoleName != "" {
		db = db.Where("role_name like ?", "%"+req.RoleName+"%")
	}
	if req.Status != "" {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != "" {
		db = db.Where("created_time >= ? ", utils.StrToTimestamp(req.BeginTime))
	}
	if req.EndTime != "" {
		db = db.Where("created_time<=?", utils.StrToTimestamp(req.EndTime))
	}
	total, err = db.Count()
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取总行数失败")
		return
	}
	err = db.Page(req.GetPage()).Order("id asc").Scan(&list)
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("获取数据失败")
		return
	}
	return
}

func (s *roleService) GetRoleById(id int64) (roleInfo *model.UpdateSysRoleReq, err error) {
	roleInfo = new(model.UpdateSysRoleReq)
	role := new(model.SysRole)
	err = s.Dao.WherePri(id).Scan(&role)
	if err := gconv.Struct(role, roleInfo); err != nil {
		return nil, err
	}
	var menuList []model.SysRoleMenu
	err = s.roleMenuDao.Where("role_id", id).Scan(&menuList)
	if err != nil {
		return nil, err
	}
	roleInfo.MenuIds = []int{}
	for _, v := range menuList {
		roleInfo.MenuIds = append(roleInfo.MenuIds, v.MenuId)
	}
	return
}

func (s *roleService) GetRoleDeptTreeselect(id int64) (deptIds []int, err error) {
	count, err := s.Dao.WherePri(id).Count()
	if err != nil || count == 0 {
		return nil, gerror.New("角色不存在")
	}
	roleDeptList, err := s.roleDeptDao.Where("role_id", id).FindAll()
	if err != nil {
		return nil, err
	}
	deptIds = make([]int, len(roleDeptList))
	for _, v := range roleDeptList {
		deptIds = append(deptIds, v.DeptId)
	}
	return
}

func (s *roleService) CreateRole(req *model.SysRoleReq) error {
	data := new(model.SysRole)
	if err := gconv.Struct(req, data); err != nil {
		return err
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		roleId, err := s.Dao.TX(tx).Data(data).InsertAndGetId()
		if err != nil {
			return err
		}
		return s.createRoleMenu(tx, roleId, req.MenuIds)
	})
	return err
}

func (s *roleService) UpdateRole(req *model.UpdateSysRoleReq) error {
	//保存角色信息
	roleMap := gdb.Map{
		"id":        req.Id,
		"role_name": req.RoleName,
		"role_Key":  req.RoleKey,
		"status":    req.Status,
		"sort":      req.Sort,
		"remark":    req.Remark,
	}
	SetUpdatedInfo(roleMap, s.GetCxtUserId(), s.GetCxtUserName())
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err := tx.Model(model.SysRole{}).Data(roleMap).WherePri(req.Id).Update()
		if err != nil {
			return err
		}
		_, err = s.roleMenuDao.TX(tx).Where(dao.SysRoleMenu.Columns.RoleId, req.Id).Delete()
		if err != nil {
			return err
		}
		return s.createRoleMenu(tx, int64(req.Id), req.MenuIds)
	})
	return err
}

// 角色关联菜单
func (s *roleService) createRoleMenu(tx *gdb.TX, roleId int64, menuIds []int) error {
	list := g.Slice{}
	for _, v := range menuIds {
		list = append(list, g.Map{
			dao.SysRoleMenu.Columns.RoleId: roleId,
			dao.SysRoleMenu.Columns.MenuId: v,
		})
	}
	_, err := s.roleMenuDao.TX(tx).Insert(list)
	if err != nil {
		return err
	}
	return nil
}

func (s *roleService) DeleteByIds(ids []int64) (err error) {
	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err = s.Dao.TX(tx).Where("id in(?)", ids).Delete()
		if err != nil {
			return err
		}
		// 删除角色菜单权限
		_, err = s.roleMenuDao.TX(tx).WhereIn(dao.SysRoleMenu.Columns.RoleId, ids).Delete()
		if err != nil {
			return err
		}
		// 删除角色数据权限
		_, err = s.roleDeptDao.TX(tx).WhereIn(dao.SysRoleMenu.Columns.RoleId, ids).Delete()
		return err
	})

	return err
}

func (s *roleService) UpdateRoleStatus(req *model.StatusSetReq) error {
	_, err := s.Dao.Where(s.Dao.Columns.Id, req.RoleId).Data(s.Dao.Columns.Status, req.Status).Update()
	if err == nil {
		//清除TAG缓存
		service.Cache.New().RemoveByTag(global.SysAuthTag)
	}
	return err
}

// 设置角色数据权限
func (s *roleService) UpdateRoleDataScope(req *model.DataScopeReq) error {
	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
		_, err := s.Dao.TX(tx).Where("id", req.RoleId).Data(g.Map{"data_scope": req.DataScope}).Update()
		if err != nil {
			return err
		}
		if req.DataScope == 2 {
			_, err := s.roleDeptDao.Where(s.roleDeptDao.Columns.RoleId, req.RoleId).Delete()
			if err != nil {
				return err
			}
			data := g.List{}
			for _, deptId := range req.DeptIds {
				data = append(data, g.Map{"role_id": req.RoleId, "dept_id": deptId})
			}
			_, err = s.roleDeptDao.Data(data).Insert()
			if err != nil {
				return err
			}
		}
		return nil
	})
	return err
}