Quincy_admin/services/pms_service.go

// Package services/pms_service.go
package services

import (
	"Quincy_admin/repositories"
	"Quincy_admin/schemas"
)

type PermissionService struct {
	pmsRepo *repositories.PermissionRepository
}

func NewPermissionService(repo *repositories.PermissionRepository) *PermissionService {
	return &PermissionService{pmsRepo: repo}
}

// GetRoutesByID 获取侧边栏菜单权限
func (s *PermissionService) GetRoutesByID(roleID int) (*schemas.Routes, error) {
	// 从仓库获取菜单数据
	var menuItems []*schemas.MenuItems
	var err error
	// 超级管理员ID为1(超管)，获取所有菜单数据
	if roleID == 1 {
		menuItems, err = s.pmsRepo.GetRoutes()
	} else {
		// 从仓库获取菜单数据
		menuItems, err = s.pmsRepo.GetRoutesByID(roleID)
	}

	if err != nil {
		return nil, err
	}

	// 构建树形结构
	var rootNodes []*schemas.Routes
	// 存储所有节点的映射，便于查找子节点
	nodeMap := make(map[int]*schemas.Routes)

	for _, item := range menuItems {
		node := &schemas.Routes{
			ID:        item.ID,
			ParentID:  item.ParentID,
			Title:     item.Title,
			Path:      item.Path,
			Component: item.Component,
			Icon:      item.Icon,
			Sort:      item.Sort,
			Visible:   item.Visible,
			Status:    item.Status,
		}

		nodeMap[item.ID] = node

		// 如果是根节点（parent_id = 0）
		if item.ParentID == 0 {
			rootNodes = append(rootNodes, node)
		}
	}

	// 为每个节点添加子节点
	for _, node := range nodeMap {
		if node.ParentID != 0 {
			parentNode, exists := nodeMap[node.ParentID]
			if exists {
				if parentNode.Children == nil {
					parentNode.Children = []*schemas.Routes{}
				}
				parentNode.Children = append(parentNode.Children, node)
			}
		}
	}

	// 返回根节点数组
	return &schemas.Routes{Children: rootNodes}, nil
}

// GetMenuList 获取菜单列表
func (s *PermissionService) GetMenuList(page, pageSize int) ([]*schemas.MenuItems, int64, error) {
	return s.pmsRepo.GetMenuList(page, pageSize)
}

// UpdateMenuStatus 启用/停用菜单
func (s *PermissionService) UpdateMenuStatus(id int, status int) error {
	return s.pmsRepo.UpdateMenuStatus(id, status)
}

// GetPermission 获取权限信息
func (s *PermissionService) GetPermission(roleID int, typeStr string) (*[]string, error) {
	// 超级管理员ID为1(超管)，获取所有菜单数据
	if roleID == 1 {
		return s.pmsRepo.GetAllPermission(typeStr)
	} else {
		return s.pmsRepo.GetPermission(roleID, typeStr)
	}
}

// GetAllPermission 获取系统所有权限信息
func (s *PermissionService) GetAllPermission() (*schemas.PermissionItems, error) {
	// 获取所有权限数据
	items, err := s.pmsRepo.GetAllNewPermission()
	if err != nil {
		return nil, err
	}

	// 构建树形结构
	root := &schemas.PermissionItems{
		ID:       0,
		Name:     "root",
		Title:    "根节点",
		Children: make([]*schemas.PermissionItems, 0), // 使用指针切片
	}
	nodeMap := make(map[int64]*schemas.PermissionItems)

	// 先建立映射
	for i := range items {
		nodeMap[items[i].ID] = items[i] // 直接使用指针
	}

	// 遍历所有节点，挂载到父节点下
	for _, item := range items {
		if item.ParentID == 0 {
			root.Children = append(root.Children, item) // 使用指针
		} else {
			if parent, exists := nodeMap[item.ParentID]; exists {
				parent.Children = append(parent.Children, item) // 使用指针
			}
		}
	}

	return root, nil
}

// GetRolePermission 获取角色权限信息
func (s *PermissionService) GetRolePermission(roleID int, typeStr string) (*[]int, error) {
	return s.pmsRepo.GetRolePermission(roleID, typeStr)
}

// AssignPermission 为角色分配权限
func (s *PermissionService) AssignPermission(roleID int, permissionIDs []int) error {
	// 获取角色现有的权限ID列表
	existingPermIDs, err := s.GetRolePermissionIDs(roleID)
	if err != nil {
		return err
	}

	// 构建现有权限ID映射
	existingPermMap := make(map[int]bool)
	for _, pid := range existingPermIDs {
		existingPermMap[pid] = true
	}

	// 构建请求权限ID映射
	requestPermMap := make(map[int]bool)
	for _, pid := range permissionIDs {
		requestPermMap[pid] = true
	}

	// 分离需要新增和需要删除的权限ID
	var toInsert []int
	var toDelete []int

	// 找出需要新增的权限（存在于请求中但不存在于现有权限中）
	for _, pid := range permissionIDs {
		if !existingPermMap[pid] {
			toInsert = append(toInsert, pid)
		}
	}

	// 找出需要删除的权限（存在于现有权限中但不存在于请求中）
	for _, pid := range existingPermIDs {
		if !requestPermMap[pid] {
			toDelete = append(toDelete, pid)
		}
	}

	// 执行插入操作
	if len(toInsert) > 0 {
		if err := s.pmsRepo.InsertRolePermissions(roleID, toInsert); err != nil {
			return err
		}
	}

	// 执行删除操作
	if len(toDelete) > 0 {
		if err := s.pmsRepo.DeleteRolePermissions(roleID, toDelete); err != nil {
			return err
		}
	}

	return nil
}

// GetRolePermissionIDs 获取角色已有的权限ID列表
func (s *PermissionService) GetRolePermissionIDs(roleID int) ([]int, error) {
	return s.pmsRepo.GetRolePermissionIDs(roleID)
}