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"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/database/gdb"
	"github.com/gogf/gf/errors/gerror"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gconv"
	"github.com/gogf/gf/util/gvalid"
)

type RoleService struct {
	*contextService
	Dao *dao.SysRoleDao
}

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)
	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 = dao.SysRole.Order(dao.SysRole.Columns.Sort + " asc," + dao.SysRole.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) CreateRolePost(req *model.SysRoleReq) error {
	tx, err := g.DB("default").Begin() //开启事务

	if err != nil {
		return err
	}
	//插入角色
	insertId, err := s.CreateRole(tx, req)
	if err != nil {
		tx.Rollback() //回滚
		return err
	}
	//添加角色权限
	fmt.Println(insertId)
	//err = s.CreateRoleRule(m["menuIds"], insertId)

	if err != nil {
		tx.Rollback() //回滚
		g.Log().Error(err.Error())
		return err
	}

	tx.Commit()
	//清除TAG缓存
	service.Cache.New().RemoveByTag(global.SysAuthTag)
	return nil
}

func (s *RoleService) CreateRole(tx *gdb.TX, req *model.SysRoleReq) (InsId int64, err error) {
	data := new(model.SysRole)
	if err = gconv.Struct(req, data); err != nil {
		return
	}
	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
	var res sql.Result
	res, err = tx.Model(model.SysRole{}).Data(data).Save()
	if err != nil {
		return
	}
	InsId, _ = res.LastInsertId()
	return
}

// AddRoleRule 添加角色权限
func (s *RoleService) CreateRoleRule(iRule interface{}, roleId int64) (err error) {
	enforcer, e := service.Casbin.GetEnforcer()
	if e != nil {
		err = e
		return
	}
	rule := gconv.Strings(iRule)
	for _, v := range rule {
		_, err = enforcer.AddPolicy(fmt.Sprintf("%d", roleId), fmt.Sprintf("%s", v), "All")
		if err != nil {
			break
		}
	}
	return
}

// 修改角色信息
func (s *RoleService) UpdateRolePost(req *model.SysRoleReq) error {
	tx, err := g.DB("default").Begin() //开启事务
	if err != nil {
		return err
	}
	err = s.UpdateRole(tx, req)
	if err != nil {
		tx.Rollback()
		return err
	}
	//err = s.UpdateRoleRule(m["menuIds"], id)
	if err != nil {
		tx.Rollback() //回滚
		return err
	}
	tx.Commit()
	//清除TAG缓存
	service.Cache.New().RemoveByTag(global.SysAuthTag)
	return nil
}

func (s *RoleService) UpdateRole(tx *gdb.TX, req *model.SysRoleReq) 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 := tx.Model(model.SysRole{}).Data(roleMap).WherePri(req.Id).Update()
	if err != nil {
		return err
	}
	return nil
}

// 修改角色的授权规则
func (s *RoleService) UpdateRoleRule(iRule interface{}, roleId int64) (err error) {
	enforcer, e := service.Casbin.GetEnforcer()
	if e != nil {
		return e
	}

	//删除旧权限
	_, err = enforcer.RemoveFilteredPolicy(0, fmt.Sprintf("%d", roleId))
	if err != nil {
		return
	}
	// 添加新权限
	rule := gconv.Strings(iRule)
	for _, v := range rule {
		_, err = enforcer.AddPolicy(fmt.Sprintf("%d", roleId), fmt.Sprintf("%s", v), "All")
		if err != nil {
			break
		}
	}

	return

}

func (s *RoleService) DeleteByIds(ids []int64) (err error) {
	tx, err := g.DB("default").Begin() //开启事务
	if err != nil {
		g.Log().Error(err)
		err = gerror.New("事务处理失败")
		return
	}

	_, err = tx.Model(model.SysRole{}).Where("id in(?)", ids).Delete()
	if err != nil {
		g.Log().Error(err)
		tx.Rollback()
		err = gerror.New("删除失败")
		return
	}
	//删除角色的权限和管理的部门数据权限
	//enforcer, e := service.Casbin.GetEnforcer()
	//if e != nil {
	//	tx.Rollback()
	//	return e
	//}
	//for _, v := range ids {
	//	_, err = enforcer.RemoveFilteredPolicy(0, fmt.Sprintf("%d", v))
	//	if err != nil {
	//		tx.Rollback()
	//		return err
	//	}
	//	_, err = tx.Model(model.SysRoleDept{}).Delete("role_id", v)
	//	if err != nil {
	//		tx.Rollback()
	//		return err
	//	}
	//}
	tx.Commit()
	//清除TAG缓存
	service.Cache.New().RemoveByTag(global.SysAuthTag)
	return nil
}

func (s *RoleService) checkRoleData(params map[string]interface{}) error {
	rules := []string{
		"roleName@required|length:1,20#请填写角色名称|名称应在:min到:max个字符之间",
	}

	e := gvalid.CheckMap(nil, params, rules)
	if e != nil {
		return e
	}
	return nil
}

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

// 设置角色数据权限
func (s *RoleService) RoleDataScope(req *model.DataScopeReq) error {
	tx, err := g.DB().Begin()
	if err != nil {
		g.Log().Error(err)
		return gerror.New("设置失败")
	}
	_, err = tx.Model(model.SysRole{}).Where("id", req.RoleId).Data(g.Map{"data_scope": req.DataScope}).Update()
	if err != nil {
		g.Log().Error(err)
		tx.Rollback()
		return gerror.New("设置失败")
	}
	if req.DataScope == 2 {
		_, err := tx.Model(model.SysRoleDept{}).Where("role_id", req.RoleId).Delete()
		if err != nil {
			g.Log().Error(err)
			tx.Rollback()
			return gerror.New("设置失败")
		}
		data := g.List{}
		for _, deptId := range req.DeptIds {
			data = append(data, g.Map{"role_id": req.RoleId, "dept_id": deptId})
		}
		_, err = tx.Model(model.SysRoleDept{}).Data(data).Insert()
		if err != nil {
			g.Log().Error(err)
			tx.Rollback()
			return gerror.New("设置失败")
		}
	}
	tx.Commit()
	return nil
}

// 获取角色关联的菜单规则
func (s *RoleService) GetFilteredNamedPolicy(id int) ([]int, error) {
	enforcer, err := service.Casbin.GetEnforcer()
	if err != nil {
		g.Log().Error(err)
		return nil, err
	}
	gp := enforcer.GetFilteredNamedPolicy("p", 0, fmt.Sprintf("%d", id))
	gpSlice := make([]int, len(gp))
	for k, v := range gp {
		gpSlice[k] = gconv.Int(v[1])
	}

	return gpSlice, nil
}