SeeyonFileSystem/server/service/permission_service.go

package service

import (
	"errors"

	"seeyon-filesystem/model"
	"seeyon-filesystem/repository"
)

// PermissionService RBAC权限服务
// 管理角色、权限的CRUD以及权限检查
type PermissionService struct {
	roleRepo       *repository.RoleRepository
	permissionRepo *repository.PermissionRepository
	userRoleRepo   *repository.UserRoleRepository
	userRepo       *repository.UserRepository
}

// NewPermissionService 创建权限服务实例
func NewPermissionService() *PermissionService {
	return &PermissionService{
		roleRepo:       repository.NewRoleRepository(),
		permissionRepo: repository.NewPermissionRepository(),
		userRoleRepo:   repository.NewUserRoleRepository(),
		userRepo:       repository.NewUserRepository(),
	}
}

// ========== 角色管理 ==========

// CreateRole 创建角色
func (s *PermissionService) CreateRole(role *model.Role) error {
	existing, _ := s.roleRepo.FindByName(role.Name)
	if existing != nil {
		return errors.New("角色标识已存在")
	}
	return s.roleRepo.Create(role)
}

// GetRole 获取角色详情
func (s *PermissionService) GetRole(id uint64) (*model.Role, error) {
	return s.roleRepo.FindByID(id)
}

// ListRoles 获取所有角色列表
func (s *PermissionService) ListRoles() ([]model.Role, error) {
	return s.roleRepo.List()
}

// UpdateRole 更新角色
func (s *PermissionService) UpdateRole(role *model.Role) error {
	existing, err := s.roleRepo.FindByID(role.ID)
	if err != nil {
		return errors.New("角色不存在")
	}
	// 系统内置角色不允许修改标识
	if existing.IsSystem == 1 && existing.Name != role.Name {
		return errors.New("系统内置角色不允许修改标识")
	}
	role.IsSystem = existing.IsSystem
	return s.roleRepo.Update(role)
}

// DeleteRole 删除角色
func (s *PermissionService) DeleteRole(id uint64) error {
	role, err := s.roleRepo.FindByID(id)
	if err != nil {
		return errors.New("角色不存在")
	}
	if role.IsSystem == 1 {
		return errors.New("系统内置角色不允许删除")
	}
	return s.roleRepo.Delete(id)
}

// SetRolePermissions 设置角色权限
func (s *PermissionService) SetRolePermissions(roleID uint64, permissionIDs []uint64) error {
	_, err := s.roleRepo.FindByID(roleID)
	if err != nil {
		return errors.New("角色不存在")
	}
	return s.roleRepo.SetPermissions(roleID, permissionIDs)
}

// ========== 权限管理 ==========

// CreatePermission 创建权限
func (s *PermissionService) CreatePermission(perm *model.Permission) error {
	existing, _ := s.permissionRepo.FindByCode(perm.Code)
	if existing != nil {
		return errors.New("权限标识已存在")
	}
	return s.permissionRepo.Create(perm)
}

// ListPermissions 获取所有权限列表
func (s *PermissionService) ListPermissions() ([]model.Permission, error) {
	return s.permissionRepo.List()
}

// UpdatePermission 更新权限
func (s *PermissionService) UpdatePermission(perm *model.Permission) error {
	return s.permissionRepo.Update(perm)
}

// DeletePermission 删除权限
func (s *PermissionService) DeletePermission(id uint64) error {
	return s.permissionRepo.Delete(id)
}

// ========== 用户角色管理 ==========

// SetUserRoles 设置用户角色
func (s *PermissionService) SetUserRoles(userID uint64, roleIDs []uint64) error {
	_, err := s.userRepo.FindByID(userID)
	if err != nil {
		return errors.New("用户不存在")
	}
	return s.userRoleRepo.SetUserRoles(userID, roleIDs)
}

// GetUserRoles 获取用户的角色列表
func (s *PermissionService) GetUserRoles(userID uint64) ([]model.Role, error) {
	return s.userRoleRepo.GetUserRoles(userID)
}

// GetUserPermissions 获取用户的权限列表(通过角色计算)
func (s *PermissionService) GetUserPermissions(userID uint64) ([]string, error) {
	return s.permissionRepo.GetUserPermissionCodes(userID)
}

// HasPermission 检查用户是否拥有指定权限
func (s *PermissionService) HasPermission(userID uint64, permissionCode string) (bool, error) {
	codes, err := s.permissionRepo.GetUserPermissionCodes(userID)
	if err != nil {
		return false, err
	}
	for _, code := range codes {
		if code == permissionCode {
			return true, nil
		}
	}
	return false, nil
}