GO/app/logic/manage/setting/role.go

package setting

import (
	"base/app/constant"
	"base/app/lib/bean"
	"base/app/model"
	"errors"
	"fmt"
	"git.oa00.com/go/acs"
	"git.oa00.com/go/mysql"
	"gorm.io/gorm"
)

var RoleLogic = &roleLogic{}

type roleLogic struct {
}

type roleItem struct {
	Id        uint   `json:"id"`
	Name      string `json:"name"`
	Remark    string `json:"remark"`
	CreatedAt int64  `json:"createdAt"`
	UpdatedAt int64  `json:"updatedAt"`
}
type RoleListsSearch struct {
	Id   uint
	Name string
}

// Lists @Title 角色列表
func (r *roleLogic) Lists(search RoleListsSearch, page bean.Page) (lists []roleItem, total int64) {
	lists = []roleItem{}
	var roles []model.SettingRole
	where := mysql.Db
	if search.Id > 0 {
		where = where.Where("id = ?", search.Id)
	}
	if search.Name != "" {
		where = where.Where("name like ?", fmt.Sprintf("%%%s%%", search.Name))
	}
	mysql.Db.Model(&roles).Where(where).Count(&total)
	if page.HasPage(total) {
		mysql.Db.Where(where).Offset(page.GetStart()).Limit(page.GetLimit()).Find(&roles)
		for _, role := range roles {
			lists = append(lists, roleItem{
				Id:        role.Id,
				Name:      role.Name,
				Remark:    role.Remark,
				CreatedAt: role.CreatedAt.Unix(),
				UpdatedAt: role.UpdatedAt.Unix(),
			})
		}
	}
	return
}

type RoleAdd struct {
	Name   string `binding:"required" label:"角色名"`
	Remark string
	Auth   auth
}
type auth struct {
	Manage manage
	Sale   sale
}
type manage struct {
	HasManage uint   `binding:"oneof=0 1" label:"后台权限"`
	MenuIds   []uint `binding:"required" label:"菜单id数组"`
}
type sale struct {
	HasSale uint `binding:"oneof=0 1" label:"业务员"`
}

// Add @Title 添加角色
func (r *roleLogic) Add(data RoleAdd) error {
	roleData := model.SettingRole{
		Name:   data.Name,
		Remark: data.Remark,
	}
	return mysql.Db.Transaction(func(tx *gorm.DB) error {
		if tx.Create(&roleData).Error != nil {
			return errors.New("添加失败")
		}
		groupingName := fmt.Sprintf("role_%d", roleData.Id)
		// 后台权限
		var policies [][]string
		if data.Auth.Manage.HasManage > 0 {
			roleManage := model.SettingRoleManage{RoleId: roleData.Id}
			if len(data.Auth.Manage.MenuIds) > 0 {
				var menus []model.SettingMenu
				tx.Where("id in ?", data.Auth.Manage.MenuIds).Find(&menus)
				if len(menus) > 0 {
					for _, menu := range menus {
						roleManage.ManageMenus = append(roleManage.ManageMenus, model.SettingRoleMenu{
							RoleId: roleData.Id,
							MenuId: menu.Id,
						})
						policies = append(policies, []string{groupingName, fmt.Sprintf("menu_%d", menu.Id)})
					}
				}
			}
			if tx.Create(&roleManage).Error != nil {
				return errors.New("添加失败")
			}
			policies = append(policies, []string{groupingName, fmt.Sprintf("terminal_%d", constant.SystemTerminalAdmin)})
		}
		// 业务员
		if data.Auth.Sale.HasSale > 0 {
			roleSale := model.SettingRoleSale{RoleId: roleData.Id}
			if tx.Create(&roleSale).Error != nil {
				return errors.New("添加失败")
			}
			policies = append(policies, []string{groupingName, fmt.Sprintf("terminal_%d", constant.SystemTerminalSale)})
		}
		// 权限添加
		if len(policies) > 0 {
			if _, err := acs.Enforcer.AddGroupingPolicies(policies); err != nil {
				return errors.New("添加失败")
			}
		}
		return nil
	})
}

type roleInfo struct {
	Id     uint   `json:"id"`
	Name   string `json:"name"`
	Remark string `json:"remark"`
	Auth   auth   `json:"auth"`
}

// Info @Title 角色详情
func (r *roleLogic) Info(roleId uint) (result roleInfo, err error) {
	role := model.SettingRole{Id: roleId}
	if mysql.Db.Preload("Manage.ManageMenus").First(&role).Error != nil {
		return result, errors.New("角色错误")
	}
	result = roleInfo{
		Id:     role.Id,
		Name:   role.Name,
		Remark: role.Remark,
		Auth: auth{
			Manage: manage{
				HasManage: 0,
				MenuIds:   []uint{},
			},
			Sale: sale{
				HasSale: 0,
			},
		},
	}
	if role.Manage.Id > 0 {
		result.Auth.Manage.HasManage = 1
		for _, menu := range role.Manage.ManageMenus {
			result.Auth.Manage.MenuIds = append(result.Auth.Manage.MenuIds, menu.MenuId)
		}
	}
	if role.Sale.Id > 0 {
		result.Auth.Sale.HasSale = 1
	}
	return
}

type RoleEdit struct {
	RoleId uint `binding:"required" label:"角色id"`
	RoleAdd
}

// Edit @Title 编辑角色
func (r *roleLogic) Edit(data RoleEdit) error {
	roleData := model.SettingRole{Id: data.RoleId}
	if mysql.Db.First(&roleData).Error != nil {
		return errors.New("角色错误")
	}
	roleData.Name = data.Name
	roleData.Remark = data.Remark
	groupingName := fmt.Sprintf("role_%d", data.RoleId)
	return mysql.Db.Transaction(func(tx *gorm.DB) error {
		if tx.Save(&roleData).Error != nil {
			return errors.New("编辑失败")
		}
		var policies [][]string
		// 后台权限
		roleManage := model.SettingRoleManage{RoleId: roleData.Id}
		if tx.Where(&roleManage).Delete(&roleManage).Error != nil {
			return errors.New("编辑失败")
		}
		if tx.Where("role_id = ?", roleData.Id).Delete(&model.SettingRoleMenu{}).Error != nil {
			return errors.New("编辑失败")
		}
		if data.Auth.Manage.HasManage > 0 {
			if len(data.Auth.Manage.MenuIds) > 0 {
				var menus []model.SettingMenu
				tx.Where("id in ?", data.Auth.Manage.MenuIds).Find(&menus)
				if len(menus) > 0 {
					for _, menu := range menus {
						roleManage.ManageMenus = append(roleManage.ManageMenus, model.SettingRoleMenu{
							RoleId: roleData.Id,
							MenuId: menu.Id,
						})
						policies = append(policies, []string{groupingName, fmt.Sprintf("menu_%d", menu.Id)})
					}
				}
			}
			if tx.Create(&roleManage).Error != nil {
				return errors.New("编辑失败")
			}
			policies = append(policies, []string{groupingName, fmt.Sprintf("terminal_%d", constant.SystemTerminalAdmin)})
		}
		// 业务员
		roleSale := model.SettingRoleSale{RoleId: roleData.Id}
		if tx.Where(&roleSale).Delete(&roleSale).Error != nil {
			return errors.New("编辑失败")
		}
		if data.Auth.Sale.HasSale > 0 {
			roleSale := model.SettingRoleSale{RoleId: roleData.Id}
			if tx.Create(&roleSale).Error != nil {
				return errors.New("编辑失败")
			}
			policies = append(policies, []string{groupingName, fmt.Sprintf("terminal_%d", constant.SystemTerminalSale)})
		}
		// 权限删除
		if _, err := acs.Enforcer.RemoveGroupingPolicies(acs.Enforcer.GetFilteredGroupingPolicy(0, groupingName)); err != nil {
			return errors.New("编辑失败")
		}
		// 权限添加
		if len(policies) > 0 {
			if _, err := acs.Enforcer.AddGroupingPolicies(policies); err != nil {
				return errors.New("编辑失败")
			}
		}
		return nil
	})
}

// Delete @Title 删除角色
func (r *roleLogic) Delete(roleId uint) error {
	roleData := model.SettingRole{Id: roleId}
	if mysql.Db.First(&roleData).Error != nil {
		return errors.New("角色错误")
	}
	manage := model.Manage{RoleId: roleId}
	mysql.Db.Where(&manage).First(&manage)
	if manage.Id > 0 {
		return errors.New("该角色下存在用户")
	}
	return mysql.Db.Transaction(func(tx *gorm.DB) error {
		if tx.Delete(&roleData).Error != nil {
			return errors.New("删除失败")
		}
		// 后台权限
		roleManage := model.SettingRoleManage{RoleId: roleData.Id}
		if tx.Where(&roleManage).Delete(&roleManage).Error != nil {
			return errors.New("编辑失败")
		}
		if tx.Where("role_id = ?", roleId).Delete(&model.SettingRoleMenu{}).Error != nil {
			return errors.New("删除失败")
		}
		// 业务员
		roleSale := model.SettingRoleSale{RoleId: roleData.Id}
		if tx.Where(&roleSale).Delete(&roleSale).Error != nil {
			return errors.New("编辑失败")
		}
		groupingName := fmt.Sprintf("role_%d", roleId)
		if _, err := acs.Enforcer.RemoveGroupingPolicies(acs.Enforcer.GetFilteredGroupingPolicy(0, groupingName)); err != nil {
			return errors.New("删除失败")
		}
		return nil
	})
}

// Select @Title 角色筛选
func (r *roleLogic) Select() (result []bean.SelectItem) {
	result = []bean.SelectItem{}
	var roles []model.SettingRole
	mysql.Db.Order("id desc").Find(&roles)
	for _, role := range roles {
		result = append(result, bean.SelectItem{
			Id:   role.Id,
			Name: role.Name,
		})
	}
	return
}