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

using Dlhis.Entity.Sys.Entities;
using Dlhis.Sys.Identity.Request;
using Dlhis.Sys.Identity.Response;
using Kurisu.AspNetCore.Utils.Extensions;
using Kurisu.Core.DataAccess.Dto;
using Kurisu.Core.User.Abstractions;
using Kurisu.SqlSugar.Extensions;
using Kurisu.SqlSugar.Services;
using Microsoft.AspNetCore.Identity;
using SqlSugar;

namespace Dlhis.Sys.Identity.Services.Implements;

public class UserService : IUserService
{
    private readonly ICurrentUser _currentUser;
    private readonly IDbContext _dbContext;

    public UserService(IDbContext dbContext, ICurrentUser currentUser)
    {
        _currentUser = currentUser;
        _dbContext = dbContext.ChangeDb("identity");
    }

    public async Task<Pagination<UserResponse>> GetPageAsync(UserPageRequest request)
    {
        var tenant = _currentUser.GetStringTenantId();

        var page = await _dbContext.Queryable<UserEntity>()
            .LeftJoin<UserRoleEntity>((x, ur) => x.Id == ur.UserId)
            .LeftJoin<RoleEntity>((x, ur, r) => ur.RoleId == r.Id)
            .LeftJoin<UserClaimEntity>((x, ur, r, c) => x.Id == c.UserId && c.ClaimType == "preferred_username")
            .LeftJoin<UserClaimEntity>((x, ur, r, c, cc) => x.Id == cc.UserId && cc.ClaimType == "tenant")
            .Where(x => x.UserName != "admin")
            .Where((x, ur, r, c, cc) => cc.ClaimValue == tenant)
            .WhereIF(request.IsOperator, (x, ur, r, c) => !SqlFunc.IsNullOrEmpty(r.Name))
            .WhereIF(!request.IsOperator, (x, ur, r, c) => SqlFunc.IsNullOrEmpty(r.Name))
            .WhereIF(request.Search.IsPresent(), (x, ur, r, c) => x.UserName == request.Search
                                                                  || x.Email == request.Search
                                                                  || x.PhoneNumber == request.Search
                                                                  || c.ClaimValue == request.Search
            )
            .Select((x, ur, r, c, cc) => new UserResponse
            {
                Id = x.Id,
                RoleId = ur.RoleId,
                Role = r.Name,
                OperatorName = c.ClaimValue,
            }, true)
            .ToPageListAsync(request);

        return page;
    }

    public async Task ResetAccessFailedCountAsync(int id)
    {
        var user = await _dbContext.Queryable<UserEntity>().Where(x => x.Id == id).FirstAsync();
        user.ThrowIfNull("用户不存在,无法重置");

        user.AccessFailedCount = 0;
        await _dbContext.UpdateAsync(user);
    }

    public async Task<List<UserResponse>> GetUsersAsync()
    {
        var users = await _dbContext.Queryable<UserEntity>()
            .Where(x => x.UserName != "admin")
            .Select<UserResponse>()
            .ToListAsync();
        return users;
    }

    public async Task<UserResponse> GetUserByIdAsync(int id)
    {
        var user = await _dbContext.Queryable<UserEntity>()
            .LeftJoin<UserRoleEntity>((x, ur) => x.Id == ur.UserId)
            .LeftJoin<RoleEntity>((x, ur, r) => ur.RoleId == r.Id)
            .LeftJoin<UserClaimEntity>((x, ur, r, c) => x.Id == c.UserId && c.ClaimType == "preferred_username")
            .Where(x => x.Id == id)
            .Select((x, ur, r, c) => new UserResponse
            {
                Id = x.Id,
                RoleId = ur.RoleId,
                Role = r.Name,
                OperatorName = c.ClaimValue,
            }, true)
            .FirstAsync();

        return user;
    }

    public async Task UploadUserAvatarAsync(UserAvatarUploadRequest request)
    {
        var user = await _dbContext.Queryable<UserEntity>().Where(x => x.Id == request.UserNo).Select<UserResponse>().FirstAsync();
    }

    public async Task<List<UserResponse>> GetUserByIdsAsync(List<int> ids)
    {
        var users = await _dbContext.Queryable<UserEntity>().Where(x => ids.Contains(x.Id)).Select<UserResponse>().ToListAsync();
        return users;
    }

    public async Task CreateUserAsync(UserCreateRequest request)
    {
        var hasher = new PasswordHasher<UserEntity>();

        var user = new UserEntity
        {
            UserName = request.Username,
            NormalizedUserName = request.Username.ToUpper(),
            ConcurrencyStamp = Guid.NewGuid().ToString(),
            SecurityStamp = Guid.NewGuid().ToString(),
        };
        request.Password = hasher.HashPassword(user, request.Password);
        user.PasswordHash = request.Password;

        var id = (int)await _dbContext.InsertReturnIdentityAsync(user);

        await _dbContext.InsertAsync(request.Tenants.Select(x => new UserTenantEntity
        {
            TenantCode = x,
            UserId = id
        }).ToList());

        if (request.Name.IsPresent())
        {
            await _dbContext.InsertAsync(new UserClaimEntity
            {
                ClaimType = "preferred_username",
                ClaimValue = request.Name,
                UserId = id
            });
        }
    }
}