qiangdanxitong/backend/src/main/java/com/designhub/service/PermissionService.java

package com.designhub.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.designhub.entity.Permission;
import com.designhub.entity.RolePermission;
import com.designhub.exception.BusinessException;
import com.designhub.mapper.PermissionMapper;
import com.designhub.mapper.RolePermissionMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 权限管理Service
 */
@Service
@RequiredArgsConstructor
public class PermissionService {

    private final PermissionMapper permissionMapper;
    private final RolePermissionMapper rolePermissionMapper;

    /**
     * 获取所有权限列表
     */
    public List<Permission> getAllPermissions() {
        return permissionMapper.selectList(
            new LambdaQueryWrapper<Permission>()
                .eq(Permission::getStatus, 1)
                .orderByAsc(Permission::getSortOrder)
        );
    }

    /**
     * 获取权限树形结构
     */
    public List<Permission> getPermissionTree() {
        List<Permission> allPermissions = permissionMapper.selectList(
            new LambdaQueryWrapper<Permission>()
                .orderByAsc(Permission::getSortOrder)
        );
        return buildTree(allPermissions, 0L);
    }

    /**
     * 根据ID获取权限
     */
    public Permission getPermissionById(Long id) {
        return permissionMapper.selectById(id);
    }

    /**
     * 根据角色ID获取权限列表
     */
    public List<Permission> getPermissionsByRoleId(Long roleId) {
        return permissionMapper.selectPermissionsByRoleId(roleId);
    }

    /**
     * 根据用户ID获取权限列表
     */
    public List<Permission> getPermissionsByUserId(Long userId) {
        return permissionMapper.selectPermissionsByUserId(userId);
    }

    /**
     * 根据用户ID获取权限代码列表
     */
    public List<String> getPermissionCodesByUserId(Long userId) {
        List<Permission> permissions = getPermissionsByUserId(userId);
        return permissions.stream()
            .map(Permission::getPermissionCode)
            .collect(Collectors.toList());
    }

    /**
     * 创建权限
     */
    @Transactional(rollbackFor = Exception.class)
    public Permission createPermission(Permission permission) {
        // 验证权限编码唯一性
        long count = permissionMapper.selectCount(
            new LambdaQueryWrapper<Permission>()
                .eq(Permission::getPermissionCode, permission.getPermissionCode())
        );
        if (count > 0) {
            throw new BusinessException("权限编码已存在");
        }

        // 设置默认值
        if (permission.getStatus() == null) {
            permission.setStatus(1);
        }
        if (permission.getParentId() == null) {
            permission.setParentId(0L);
        }

        permissionMapper.insert(permission);
        return permission;
    }

    /**
     * 更新权限
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePermission(Permission permission) {
        Permission existPermission = getPermissionById(permission.getId());
        if (existPermission == null) {
            throw new BusinessException("权限不存在");
        }

        // 不允许将父ID设置为自己
        if (permission.getParentId() != null && permission.getParentId().equals(permission.getId())) {
            throw new BusinessException("不能将父权限设置为自己");
        }

        return permissionMapper.updateById(permission) > 0;
    }

    /**
     * 删除权限
     */
    @Transactional(rollbackFor = Exception.class)
    public boolean deletePermission(Long id) {
        Permission permission = getPermissionById(id);
        if (permission == null) {
            throw new BusinessException("权限不存在");
        }

        // 检查是否有子权限
        long childCount = permissionMapper.selectCount(
            new LambdaQueryWrapper<Permission>()
                .eq(Permission::getParentId, id)
        );
        if (childCount > 0) {
            throw new BusinessException("该权限下还有子权限，无法删除");
        }

        // 检查是否有角色使用此权限
        long roleCount = rolePermissionMapper.selectCount(
            new LambdaQueryWrapper<RolePermission>()
                .eq(RolePermission::getPermissionId, id)
        );
        if (roleCount > 0) {
            throw new BusinessException("该权限已分配给角色，无法删除");
        }

        return permissionMapper.deleteById(id) > 0;
    }

    /**
     * 构建树形结构
     */
    private List<Permission> buildTree(List<Permission> allPermissions, Long parentId) {
        List<Permission> children = allPermissions.stream()
            .filter(permission -> permission.getParentId().equals(parentId))
            .collect(Collectors.toList());

        for (Permission child : children) {
            List<Permission> subChildren = buildTree(allPermissions, child.getId());
            // 可以将子权限存储到一个临时字段中，或者返回VO对象
        }

        return children;
    }

    /**
     * 根据用户ID检查是否有指定权限
     */
    public boolean hasPermission(Long userId, String permissionCode) {
        List<String> permissionCodes = getPermissionCodesByUserId(userId);
        return permissionCodes.contains(permissionCode);
    }

    /**
     * 根据用户ID检查是否有访问接口的权限
     */
    public boolean hasApiPermission(Long userId, String path, String method) {
        List<Permission> permissions = getPermissionsByUserId(userId);
        return permissions.stream()
            .anyMatch(p -> "api".equals(p.getType()) &&
                          path.equals(p.getPath()) &&
                          (method == null || method.equals(p.getMethod())));
    }
}