cadmin/server/internal/admin/service/admin_role.go

package service

import (
	"encoding/json"
	"errors"
	"gadmin/config"
	"gadmin/internal/admin/consts"
	"gadmin/internal/admin/forms"
	"gadmin/internal/gorm/model"
	"gadmin/internal/gorm/query"
	"gadmin/utility/serializer"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
	"github.com/spf13/cast"
	"gorm.io/gorm"
	"time"
)

// AdminRole 后台角色
var AdminRole = new(sAdminRole)

type sAdminRole struct{}

func (s *sAdminRole) List(ctx *gin.Context, req forms.AdminRoleListReq) serializer.Response {
	var (
		q            = query.Use(config.AdminDB).AdminRole
		m            = q.WithContext(ctx)
		mq           = query.Use(config.AdminDB).AdminRoleMenu
		pq           = query.Use(config.AdminDB).AdminRolePermission
		offset int64 = 0
		models forms.UserAccountListRes
		lists  []*forms.AdminRoleListModel
	)

	m = m.Order(q.Sort).Order(q.ID.Desc())

	req.Page, req.PerPage, offset = forms.CalculatePage(req.Page, req.PerPage)

	count, err := m.Count()
	if err != nil {
		return serializer.Err(consts.CodeParamErr, "查询出错 count", err)
	}

	if count > 0 {
		if err = m.Limit(int(req.PerPage)).Offset(int(offset)).Scan(&lists); err != nil {
			return serializer.Err(consts.CodeParamErr, "查询出错 lists", err)
		}
	}

	for _, v := range lists {
		if err := json.Unmarshal([]byte(cast.ToString(v.Systems)), &v.Systems); err != nil {
			return serializer.Err(consts.CodeParamErr, "格式化出错 Systems", err)
		}

		permissionsModels, err := pq.Where(pq.RoleID.Eq(int32(v.ID))).Find()
		if err != nil {
			return serializer.Err(consts.CodeParamErr, "查询出错 permissionsModels", err)
		}
		permissionsMap := make(map[int32][]int32)
		for _, item := range permissionsModels {
			if _, ok := permissionsMap[item.SystemID]; ok {
				permissionsMap[item.SystemID] = append(permissionsMap[item.SystemID], item.PermissionID)
			} else {
				permissionsMap[item.SystemID] = []int32{item.PermissionID}
			}
		}
		v.Permissions = permissionsMap

		pagesModels, err := mq.Where(mq.RoleID.Eq(int32(v.ID))).Find()
		if err != nil {
			return serializer.Err(consts.CodeParamErr, "查询出错 pagesModels", err)
		}
		pagesMap := make(map[int32][]int32)
		for _, item := range pagesModels {
			if _, ok := pagesMap[item.SystemID]; ok {
				pagesMap[item.SystemID] = append(pagesMap[item.SystemID], item.PageID)
			} else {
				pagesMap[item.SystemID] = []int32{item.PageID}
			}
		}
		v.Pages = pagesMap
	}

	models.List = lists
	models.Page = req.Page
	models.PerPage = req.PerPage
	models.PageCount = (count + req.PerPage - 1) / req.PerPage

	return serializer.Suc(models)
}

func (s *sAdminRole) Edit(ctx *gin.Context, req forms.AdminRoleEditReq) serializer.Response {

	q := query.Use(config.AdminDB).AdminRole
	mq := query.Use(config.AdminDB).AdminRoleMenu
	pq := query.Use(config.AdminDB).AdminRolePermission
	uq := query.Use(config.AdminDB).AdminUser

	logrus.Warnf("req:%+v", req)

	menusModel := make([]*model.AdminRoleMenu, 0)
	for sysId, menus := range req.Pages {
		for _, menu := range menus {
			menusModel = append(menusModel, &model.AdminRoleMenu{
				SystemID: sysId,
				RoleID:   int32(req.ID),
				PageID:   menu,
			})
		}
	}
	permissionsModel := make([]*model.AdminRolePermission, 0)
	for sysId, permissions := range req.Permissions {
		for _, id := range permissions {
			permissionsModel = append(permissionsModel, &model.AdminRolePermission{
				SystemID:     sysId,
				RoleID:       int32(req.ID),
				PermissionID: id,
			})
		}
	}

	systems, err := json.Marshal(req.Systems)
	if err != nil {
		return serializer.Err(consts.CodeParamErr, "格式化出错 Systems:", err)
	}
	// 修改
	if req.ID > 0 {
		update := &model.AdminRole{
			Name:      req.Name,
			Key:       req.Key,
			Sort:      req.Sort,
			Remark:    req.Remark,
			Status:    req.Status,
			Systems:   string(systems),
			UpdatedAt: time.Now(),
		}
		queryTx := query.Use(config.AdminDB).Begin()
		_, err := queryTx.AdminRole.Where(q.ID.Eq(req.ID)).Updates(update)
		if err != nil {
			queryTx.Rollback()
			return serializer.Err(consts.CodeDBError, "更新出错", err)
		}
		// 删除旧的菜单权限
		if _, err := queryTx.AdminRoleMenu.Where(mq.RoleID.Eq(int32(req.ID))).Delete(); err != nil {
			queryTx.Rollback()
			return serializer.Err(consts.CodeDBError, "更新出错", err)
		}
		// 插入新的菜单权限
		if err := queryTx.AdminRoleMenu.Create(menusModel...); err != nil {
			queryTx.Rollback()
			return serializer.Err(consts.CodeDBError, "更新出错", err)
		}
		// 删除旧的操作权限
		if _, err := queryTx.AdminRolePermission.Where(pq.RoleID.Eq(int32(req.ID))).Delete(); err != nil {
			queryTx.Rollback()
			return serializer.Err(consts.CodeDBError, "更新出错", err)
		}
		// 插入新的操作权限
		if err := queryTx.AdminRolePermission.Create(permissionsModel...); err != nil {
			queryTx.Rollback()
			return serializer.Err(consts.CodeDBError, "更新出错", err)
		}
		queryTx.Commit()
		// 查询该角色下的用户，清空token
		users, _ := query.Use(config.AdminDB).AdminUser.Where(uq.RoleID.Eq(int32(req.ID))).Find()
		for _, user := range users {
			config.TokenRedis.Del(config.GetUserTokenKey(user.ID))
		}
		return serializer.Suc(nil)
	}

	// 新增
	create := &model.AdminRole{
		Name:      req.Name,
		Key:       req.Key,
		Sort:      req.Sort,
		Systems:   string(systems),
		Remark:    req.Remark,
		Status:    req.Status,
		UpdatedAt: time.Now(),
		CreatedAt: time.Now(),
	}
	queryTx := query.Use(config.AdminDB).Begin()
	if err := queryTx.AdminRole.WithContext(ctx).Create(create); err != nil {
		logrus.Error(err)
		queryTx.Rollback()
		return serializer.Err(consts.CodeDBError, "更新出错", err)
	}
	// 插入新的菜单权限
	for _, item := range menusModel {
		item.RoleID = int32(create.ID)
	}
	if err := queryTx.AdminRoleMenu.Create(menusModel...); err != nil {
		logrus.Error(err)
		queryTx.Rollback()
		return serializer.Err(consts.CodeDBError, "更新出错", err)
	}

	// 插入新的操作权限
	for _, item := range permissionsModel {
		item.RoleID = int32(create.ID)
	}
	if err := queryTx.AdminRolePermission.Create(permissionsModel...); err != nil {
		logrus.Error(err)
		queryTx.Rollback()
		return serializer.Err(consts.CodeDBError, "更新出错", err)
	}
	queryTx.Commit()
	return serializer.Suc(nil)
}

func (s *sAdminRole) GetRole(ctx *gin.Context, req forms.AdminRoleReq) (*model.AdminRole, error) {
	var (
		q = query.Use(config.AdminDB).AdminRole
		m = q.WithContext(ctx)
	)
	result, err := m.Where(q.ID.Eq(req.ID)).First()
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		return nil, err
	}
	return result, nil
}

func (s *sAdminRole) GetAllSystem() ([]*model.AdminSystem, error) {
	var (
		q = query.Use(config.AdminDB).AdminSystem
	)
	systems, err := q.Find()
	if err != nil {
		logrus.Error(err)
	}
	return systems, nil
}