jinko.yikatong/Src/Dlhis.Sys/Identity/Services/Implements/RoleService.cs

using Dlhis.Entity.Sys.Entities;
using Dlhis.Sys.Identity.Request;
using Dlhis.Sys.Identity.Response;
using Kurisu.AspNetCore.Authentication.Abstractions;
using Kurisu.AspNetCore.Cache;
using Kurisu.AspNetCore.CustomClass;
using Kurisu.AspNetCore.DataAccess.Dto;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Extensions;
using Kurisu.AspNetCore.DataAccess.SqlSugar.Services;
using Kurisu.AspNetCore.Utils.Extensions;

namespace Dlhis.Sys.Identity.Services.Implements;

public class RoleService : IRoleService
{
    private readonly ICurrentUser _currentUser;
    private readonly RedisCache _redisCache;
    private readonly IDbContext _dbContext;

    public RoleService(ICurrentUser currentUser, IDbContext dbContext, RedisCache redisCache)
    {
        _currentUser = currentUser;
        _redisCache = redisCache;
        _dbContext = dbContext.ChangeDb("identity");
    }

    public async Task<Pagination<RoleResponse>> GetPageAsync(RolePageRequest request)
    {
        return await _dbContext.Queryable<RoleEntity>()
            .WhereIF(request.Search.IsPresent(), x => x.Name.Contains(request.Search) || x.NormalizedName.Contains(request.Search))
            .Where(x => x.Name != "admin")
            .Select<RoleResponse>()
            .ToPageListAsync(request);
    }

    public async Task<RoleResponse> GetMyRoleAsync(int? userId)
    {
        userId ??= _currentUser.GetIntSubjectId();

        return await _dbContext.Queryable<UserRoleEntity>()
            .LeftJoin<RoleEntity>((x, r) => x.RoleId == r.Id)
            .Where(x => x.UserId == userId)
            .Select<RoleResponse>()
            .FirstAsync();
    }

    public async Task SaveRoleAsync(RoleSaveRequest request)
    {
        await CheckDuplicateNameAsync(request);

        if (!request.Id.HasValue)
        {
            await _dbContext.InsertAsync(new RoleEntity
            {
                Name = request.Name,
                NormalizedName = request.Name.ToUpperInvariant(),
                Description = request.Description,
                ConcurrencyStamp = Guid.NewGuid(),
            });
        }
        else
        {
            var entity = await _dbContext.Queryable<RoleEntity>().Where(x => x.Id == request.Id).FirstAsync();
            entity.ThrowIfNull("角色不存在");

            entity.Name = request.Name;
            entity.NormalizedName = request.Name.ToUpperInvariant();
            entity.Description = request.Description;
            entity.ConcurrencyStamp = Guid.NewGuid();

            await _dbContext.UpdateAsync(entity);
        }
    }

    private static readonly List<string> _roles = new() { "admin", "tenant-admin" };

    public async Task AssignRoleAsync(RoleAssignRequest request)
    {
        if (request.UserId == 1)
            throw new UserFriendlyException("不允许分配给系统管理员");

        var user = await _dbContext.Queryable<UserEntity>().Where(x => x.Id == request.UserId).AnyAsync();
        user.ThrowIfFalse("分配的用户不存在");

        var userRole = await _dbContext.Queryable<UserRoleEntity>().Where(x => x.UserId == request.UserId).FirstAsync();

        //操作的用户存在角色
        if (userRole != null)
        {
            var role = await _dbContext.Queryable<RoleEntity>().Where(x => x.Id == userRole.RoleId).FirstAsync();
            if (role != null)
            {
                var myRole = _currentUser.GetRole();
                var myi = _roles.IndexOf(myRole);

                var ii = _roles.IndexOf(role.Name);
                if (ii != -1)
                {
                    if (ii <= myi)
                    {
                        throw new UserFriendlyException($"不可操作当前用户({role.Name})");
                    }
                }
            }
        }


        if (request.RoleId.HasValue)
        {
            var existsRole = await _dbContext.Queryable<RoleEntity>().Where(x => x.Id == request.RoleId).AnyAsync();
            existsRole.ThrowIfFalse("分配的角色不存在");

            if (userRole == null)
            {
                await _dbContext.InsertAsync(new UserRoleEntity
                {
                    UserId = request.UserId,
                    RoleId = request.RoleId.Value,
                });
            }
            else
            {
                await _dbContext.Updateable<UserRoleEntity>()
                    .SetColumns(x => x.RoleId == request.RoleId)
                    .Where(x => x.UserId == request.UserId)
                    .ExecuteCommandAsync();
            }
        }
        else
        {
            if (userRole != null)
            {
                await _dbContext.Deleteable<UserRoleEntity>()
                    .Where(x => x.UserId == request.UserId)
                    .ExecuteCommandAsync();
            }
        }
    }

    /// <inheritdoc />
    public async Task SaveRoleObfuscateAsync(RoleObfuscateRequest request)
    {
        var role = await _dbContext.Queryable<RoleEntity>().FirstAsync(x => x.Id == request.Id);
        role.ThrowIfNull("角色不存在");

        var key = "datapermission:role";
        if (request.IsShow)
        {
            await _redisCache.ListLeftPushAsync(key, role.Name);
        }
        else
        {
            await _redisCache.ListRemoveAsync(key, role.Name);
        }
    }

    /// <inheritdoc />
    public async Task<bool> GetRoleObfuscateAsync(int id)
    {
        var role = await _dbContext.Queryable<RoleEntity>().FirstAsync(x => x.Id == id);
        var key = "datapermission:role";
        var range = await _redisCache.ListRangeAsync(key);

        return range.Any(x => (string)x == role.Name);
    }

    public async Task RemoveRoleAsync(IdRequest request)
    {
        var role = await _dbContext.Queryable<RoleEntity>().FirstAsync(x => x.Id == request.Id);
        role.ThrowIfNull("角色不存在");

        //删除角色,自动删除UserRoles对应关系
        await _dbContext.DeleteReallyAsync(role);
    }

    public async Task<List<RoleResponse>> GetListAsync()
    {
        return await _dbContext.Queryable<RoleEntity>()
            .Where(x => x.Name != "admin")
            .Select<RoleResponse>()
            .ToListAsync();
    }


    //************************************************************* help method *********************************************************************


    private async Task CheckDuplicateNameAsync(RoleSaveRequest request)
    {
        var exists = await _dbContext.Queryable<RoleEntity>()
            .WhereIF(request.Id.HasValue, x => x.Id != request.Id)
            .Where(x => x.Name == request.Name)
            .AnyAsync();

        exists.ThrowIfTrue($"重复角色名称{request.Name}");
    }
}