Api/Brizco.Core/EntityServices/UserService.cs

using System.Security.Claims;
using System.Threading;
using Brizco.Domain.CommandQueries.Queries;
using Brizco.Domain.Mappers;
using Mapster;

namespace Brizco.Core.EntityServices;

public class UserService : IUserService
{
    private readonly ICurrentUserService _currentUserService;
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly RoleManager<ApplicationRole> _roleManager;
    private readonly ISender _sender;

    public UserService(ICurrentUserService currentUserService,
        UserManager<ApplicationUser> userManager,
        RoleManager<ApplicationRole> roleManager,
        ISender sender)
    {
        _currentUserService = currentUserService;
        _userManager = userManager;
        _roleManager = roleManager;
        _sender = sender;
    }

    public async Task<List<ComplexUserSDto>> GetUsersAsync(int page = 0, CancellationToken cancellationToken = default)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId needed");
        var complexUsers = await _sender.Send(new GetComplexUsersQuery(complexId.ToString(), page),cancellationToken);

        return complexUsers;
    }

    public async Task<ApplicationUserSDto> GetUserAsync(Guid userId)
        => (await _userManager.FindByIdAsync(userId.ToString())).AdaptToSDto();

    public async Task<ApplicationUser> CreateUserAsync(string phoneNumber)
    {
        var user = new ApplicationUser
        {
            UserName = phoneNumber,
            PhoneNumber = phoneNumber,
            SignUpStatus = SignUpStatus.StartSignUp
        };
        var result = await _userManager.CreateAsync(user);
        if (!result.Succeeded)
            throw new AppException(string.Join('|', result.Errors));
        return user;
    }

    public async Task<ApplicationUser> CreateUserAsync(UserActionRequestDto request, CancellationToken cancellationToken)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId needed");

        var user = new ApplicationUser
        {
            UserName = request.PhoneNumber,
            PhoneNumber = request.PhoneNumber,
            FirstName = request.FirstName,
            LastName = request.LastName,
            InternationalId = request.InternationalId,
            BirthDate = request.BirthDate,
            Gender = request.Gender,
            SignUpStatus = SignUpStatus.SignUpCompleted
        };
        if (!request.Password.IsNullOrEmpty())
        {
            var result = await _userManager.CreateAsync(user, request.Password);
            if (!result.Succeeded)
                throw new AppException(string.Join('|', result.Errors));
        }
        else
        {
            var result = await _userManager.CreateAsync(user);
            if (!result.Succeeded)
                throw new AppException(string.Join('|', result.Errors));
        }

        await _sender.Send(new CreateComplexUserCommand(complexId, user.Id, request.RoleIds), cancellationToken);
        return user;
    }

    public async Task<bool> EditUserAsync(UserActionRequestDto request, CancellationToken cancellationToken)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (_currentUserService.UserId == null)
            throw new AppException("Wrong authorize token , UserId needed");

        var user = await _userManager.FindByIdAsync(_currentUserService.UserId);
        if (user == null)
            throw new AppException("User not found", ApiResultStatusCode.NotFound);
        user.LastName = request.LastName;
        user.FirstName = request.FirstName;
        user.UserName = request.PhoneNumber;
        user.PhoneNumber = request.PhoneNumber;
        user.FirstName = request.FirstName;
        user.LastName = request.LastName;
        user.InternationalId = request.InternationalId;
        user.BirthDate = request.BirthDate;
        user.Gender = request.Gender;

        var result = await _userManager.UpdateAsync(user);
        if (!result.Succeeded)
            throw new AppException(string.Join('|', result.Errors));
        if (!request.Password.IsNullOrEmpty())
        {
            if (await _userManager.HasPasswordAsync(user))
                await _userManager.RemovePasswordAsync(user);

            var addPassResult = await _userManager.AddPasswordAsync(user, request.Password);
            if (!addPassResult.Succeeded)
                throw new AppException(string.Join('|', addPassResult.Errors));
        }

        await _sender.Send(new UpdateComplexUserCommand(user.Id, complexId, request.RoleIds), cancellationToken);
        return true;
    }

    public async Task<bool> EditUserProfileAsync(UserActionRequestDto request, CancellationToken cancellationToken)
    {
        if (_currentUserService.UserId == null)
            throw new AppException("Wrong authorize token , UserId needed");

        var user = await _userManager.FindByIdAsync(_currentUserService.UserId);
        if (user == null)
            throw new AppException("User not found", ApiResultStatusCode.NotFound);
        user.LastName = request.LastName;
        user.FirstName = request.FirstName;
        user.UserName = request.PhoneNumber;
        user.PhoneNumber = request.PhoneNumber;
        user.FirstName = request.FirstName;
        user.LastName = request.LastName;
        user.InternationalId = request.InternationalId;
        user.BirthDate = request.BirthDate;
        user.Gender = request.Gender;

        var result = await _userManager.UpdateAsync(user);
        if (!result.Succeeded)
            throw new AppException(string.Join('|', result.Errors));
        if (!request.Password.IsNullOrEmpty())
        {
            if (await _userManager.HasPasswordAsync(user))
                await _userManager.RemovePasswordAsync(user);

            var addPassResult = await _userManager.AddPasswordAsync(user, request.Password);
            if (!addPassResult.Succeeded)
                throw new AppException(string.Join('|', addPassResult.Errors));
        }

        return true;
    }

    public async Task<bool> RemoveUserAsync(Guid userId, CancellationToken cancellationToken)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId needed");
        var user = await _userManager.FindByIdAsync(userId.ToString());
        if (user == null)
            throw new AppException("User not found", ApiResultStatusCode.NotFound);
        var removeResult = await _userManager.DeleteAsync(user);
        if (!removeResult.Succeeded)
            throw new AppException(string.Join('|', removeResult.Errors));
        await _sender.Send(new DeleteComplexUserCommand(userId, complexId), cancellationToken);
        return true;
    }



    public async Task<List<ApplicationRole>> GetRolesAsync(int page = 0,CancellationToken cancellationToken = default)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId needed");

        var roles = await _roleManager.Roles
            .Where(r=>r.ComplexId==complexId)
            .Skip(page * 15)
            .Take(15)
            .ToListAsync(cancellationToken);
        return roles;
    }

    public async Task<RoleActionRequestDto> GetRoleAsync(Guid roleId)
    {
        var role = (await _roleManager.FindByIdAsync(roleId.ToString()));
        if (role == null)
            throw new AppException("نقش پیدا نشد",ApiResultStatusCode.NotFound);

        var roleDto = role.Adapt<RoleActionRequestDto>();
        roleDto.Permissions = (await _roleManager.GetClaimsAsync(role))
            .Where(c => c.Type == CustomClaimType.Permission)
            .Select(c => c.Value)
            .ToList();

        return roleDto;
    }

    public async Task<ApplicationRole> CreateRoleAsync(RoleActionRequestDto request)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId wrong");
        if (request.EnglishName.IsNullOrEmpty())
            throw new AppException("لطفا نام انگلیسی را وارد کنید");
        var applicationRole = new ApplicationRole
        {
            ComplexId = complexId,
            EnglishName = request.EnglishName,
            PersianName = request.PersianName,
            Description = request.Description,
            Name = $"{request.EnglishName}_{complexId.ToString()}"
        };
        var createRoleResult = await _roleManager.CreateAsync(applicationRole);
        if (!createRoleResult.Succeeded)
            throw new AppException(string.Join('|', createRoleResult.Errors));

        foreach (var claim in request.Permissions)
            await _roleManager.AddClaimAsync(applicationRole, new Claim(CustomClaimType.Permission, claim));
        return applicationRole;
    }

    public async Task<bool> EditRoleAsync(RoleActionRequestDto request)
    {
        if (_currentUserService.ComplexId.IsNullOrEmpty())
            throw new AppException("Wrong authorize token , ComplexId needed");
        if (!Guid.TryParse(_currentUserService.ComplexId, out Guid complexId))
            throw new AppException("Wrong authorize token , ComplexId wrong");
        if (request.EnglishName.IsNullOrEmpty())
            throw new AppException("لطفا نام انگلیسی را وارد کنید");
        var applicationRole = await _roleManager.FindByIdAsync(request.RoleId.ToString());
        if (applicationRole == null)
            throw new AppException("نقش پیدا نشد");

        applicationRole.ComplexId = complexId;
        applicationRole.EnglishName = request.EnglishName;
        applicationRole.PersianName = request.PersianName;
        applicationRole.Description = request.Description;
        applicationRole.Name = $"{request.EnglishName}_{complexId.ToString()}";

        var createRoleResult = await _roleManager.UpdateAsync(applicationRole);
        if (!createRoleResult.Succeeded)
            throw new AppException(string.Join('|', createRoleResult.Errors));
        var roleClaims = (await _roleManager.GetClaimsAsync(applicationRole)).Where(c => c.Type == CustomClaimType.Permission).ToList();
        foreach (var roleClaim in roleClaims.ToList())
        {
            if (request.Permissions.Contains(roleClaim.Value))
            {
                roleClaims.Remove(roleClaim);
                request.Permissions.Remove(roleClaim.Value);
            }
        }

        foreach (var claim in request.Permissions)
            await _roleManager.AddClaimAsync(applicationRole, new Claim(CustomClaimType.Permission, claim));

        foreach (var claim in roleClaims)
            await _roleManager.RemoveClaimAsync(applicationRole, claim);

        return true;
    }

    public async Task<bool> RemoveRoleAsync(Guid roleId)
    {
        var applicationRole = await _roleManager.FindByIdAsync(roleId.ToString());
        if (applicationRole == null)
            throw new AppException("User not found", ApiResultStatusCode.NotFound);
        var removeResult = await _roleManager.DeleteAsync(applicationRole);
        if (!removeResult.Succeeded)
            throw new AppException(string.Join('|', removeResult.Errors));
        return true;
    }

}