DD.WellWorkover.Cloud/AsbCloudInfrastructure/Repository/UserRepository.cs

using AsbCloudApp.Data;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Caching.Memory;
using AsbCloudApp.Data.User;

namespace AsbCloudInfrastructure.Repository;


public class UserRepository : IUserRepository
{
    private readonly IAsbCloudDbContext dbContext;
    private readonly IUserRoleRepository userRoleRepository;
    private const string userCacheTag = "User";
    private const string relationUserUserRoleCacheTag = "RelationUserUserRole";
    private static readonly TimeSpan cacheObsolence = TimeSpan.FromMinutes(15);
    private static readonly TypeAdapterConfig userTypeAdapterConfig = TypeAdapterConfig<UserExtendedDto, User>
        .NewConfig()
        .Ignore(dst => dst.Company,
            dst => dst.FileMarks,
            dst => dst.Files,
            dst => dst.RelationUsersUserRoles)
        .Config;
    private readonly IMemoryCache memoryCache;
    public UserRepository(IAsbCloudDbContext dbContext, IUserRoleRepository userRoleRepository, IMemoryCache memoryCache)
    {
        this.dbContext = dbContext;
        this.userRoleRepository = userRoleRepository;
        this.memoryCache = memoryCache;
    }

    public async Task<int> InsertAsync(UserExtendedDto dto, CancellationToken token)
    {
        dto.Id = default;
        var entity = Convert(dto);
        await AssertLoginIsBusyAsync(dto.Login, token);
        var userRoles = await userRoleRepository.GetByNamesAsync(dto.RoleNames, token).ConfigureAwait(false);
        var updatedEntity = await dbContext.Users.AddAsync(entity, token).ConfigureAwait(false);
        await dbContext.SaveChangesAsync(token);

        if (userRoles?.Any() == true)
            await UpdateRolesCacheForUserAsync(updatedEntity.Entity.Id, userRoles, token);

        DropCacheUsers();
        return updatedEntity.Entity.Id;
    }

    public Task<int> InsertRangeAsync(IEnumerable<UserExtendedDto> newItems, CancellationToken token)
    {
        throw new NotImplementedException();
    }

    public async Task<IEnumerable<UserExtendedDto>> GetAllAsync(CancellationToken token)
    {
        var users = await GetCacheUserAsync(token);
        if (users is null)
            return Enumerable.Empty<UserExtendedDto>();
        var dtos = new List<UserExtendedDto>();
        foreach(var user in users)
        {
            var dto = Convert(user);
            dto.RoleNames = GetRolesNamesByIdUser(user.Id);
            dtos.Add(dto);
        };            
        return dtos;
    }
    

    public UserExtendedDto? GetOrDefault(int id)
    {
        var user = GetCacheUser().FirstOrDefault(u => u.Id == id);
        if (user is null)
            return null;
        var dto = Convert(user);
        dto.RoleNames = GetRolesNamesByIdUser(dto.Id);
        return dto;
    }

    public async Task<UserExtendedDto?> GetOrDefaultAsync(int id, CancellationToken token)
    {            
        var user = (await GetCacheUserAsync(token)).FirstOrDefault(u => u.Id == id);
        if (user is null)
            return null;
        var dto = Convert(user);
        dto.RoleNames = GetRolesNamesByIdUser(dto.Id);
        return dto;
    }

    public async Task<int> UpdateAsync(UserExtendedDto dto, CancellationToken token)
    {
        if (dto.Id <= 1)
            throw new ArgumentInvalidException(nameof(dto), $"Invalid id {dto.Id}. You can't edit this user.");

        var oldUser = (await GetCacheUserAsync(token)).FirstOrDefault(u => u.Id == dto.Id)
            ?? throw new ArgumentInvalidException(nameof(dto), $"Invalid id {dto.Id}. You can't edit this user.");

        if (oldUser.Login != dto.Login)
            await AssertLoginIsBusyAsync(dto.Login, token);

        var userRoles = await userRoleRepository.GetByNamesAsync(dto.RoleNames, token).ConfigureAwait(false);
        await UpdateRolesCacheForUserAsync(dto.Id, userRoles, token);

        var entity = dbContext.Users.FirstOrDefault(u => u.Id == dto.Id)
            ?? throw new ArgumentInvalidException(nameof(dto), $"Invalid id {dto.Id}. You can't edit this user.");
        
        entity.Id = dto.Id;
        entity.Login = dto.Login;
        entity.Name = dto.Name;
        entity.Email = dto.Email;
        entity.Phone = dto.Phone;
        entity.Surname = dto.Surname;
        entity.Patronymic = dto.Patronymic;
        entity.Position = dto.Position;
        entity.IdCompany = dto.IdCompany;
        entity.IdState = dto.IdState;
        await dbContext.SaveChangesAsync(token);
        DropCacheUsers();
        return entity.Id;            
    }

    public async Task<int> DeleteAsync(int id, CancellationToken token)
    {
        var user = (await GetCacheUserAsync(token)).FirstOrDefault(u => u.Id == id)
            ?? throw new ArgumentInvalidException(nameof(id), $"Invalid id {id}. You can't edit this user.");
        
        var query = dbContext
            .Users
            .Where(u => u.Id == id);
        if (query.Any())
        {
            var result = dbContext.Users.Remove(query.First());
            await dbContext.SaveChangesAsync(token);
            DropCacheUsers();
            return result.Entity.Id;
        }
        throw new ArgumentInvalidException
                (nameof(id), $"Invalid id {id}. You can't edit this user.");
    }

    public IEnumerable<UserRoleDto> GetRolesByIdUser(int idUser, int nestedLevel = 0)
    {
        var roles = GetCachRelationUserUserRoleCacheTag().Where(r => r.IdUser == idUser);
        return roles.SelectMany(r => userRoleRepository.GetNestedById(r.IdUserRole, nestedLevel));
    }

    public IEnumerable<PermissionDto> GetNestedPermissions(int idUser)
    {
        var roles = GetRolesByIdUser(idUser, 7);
        if (roles is null)
            return Enumerable.Empty<PermissionDto>();

        var permissions = roles
            .Where(r => r.Permissions is not null)
            .SelectMany(r => r.Permissions);

        return permissions;
    }

    public bool HasPermission(int idUser, string permissionName)
    {
        if (idUser == 1)
            return true;

        var relationsToRoles = GetCachRelationUserUserRoleCacheTag()
            .Where(r => r.IdUser == idUser);
        if (relationsToRoles is null)
            return false;

        return userRoleRepository.HasPermission(relationsToRoles
            .Select(r => r.IdUserRole), permissionName);
    }

    private IEnumerable<string> GetRolesNamesByIdUser(int idUser)
    { 
        var userRoles = GetRolesByIdUser(idUser, 7)
            .Select(r => r.Caption)
            .Distinct();
        if (userRoles.Any())
            return userRoles;
        return Enumerable.Empty<string>();
    }

    private async Task AssertLoginIsBusyAsync(string login, CancellationToken token)
    {
        var existingUserDto = (await GetCacheUserAsync(token))
            .FirstOrDefault(u => u.Login.ToLower() == login.ToLower());

        if (existingUserDto is not null)
            throw new ArgumentInvalidException(nameof(login), $"Login {login} is busy by {existingUserDto.MakeDisplayName()}, id{existingUserDto.Id}");
    }
    
    private IEnumerable<RelationUserUserRole> GetCachRelationUserUserRoleCacheTag()
    {
        var cache = memoryCache.GetOrCreate(relationUserUserRoleCacheTag, cacheEntry =>
        {
            cacheEntry.AbsoluteExpirationRelativeToNow = cacheObsolence;
            cacheEntry.SlidingExpiration = cacheObsolence;
            var query = dbContext.RelationUserUserRoles
                    .Include(r => r.UserRole)
                    .Include(r => r.User);
            var entities = query.ToArray();
            return entities;
        });
        return cache!;
    }

    private void DropCacheRelationUserUserRoleCacheTag()
    { 
        memoryCache.Remove(relationUserUserRoleCacheTag);
    }

    private async Task UpdateRolesCacheForUserAsync(int idUser, IEnumerable<UserRoleDto> roleDtos, CancellationToken token)
    {
        var relations = dbContext.RelationUserUserRoles.Where(r => r.IdUser == idUser);
        dbContext.RelationUserUserRoles.RemoveRange(relations);
        var entityRoles = roleDtos.Select(role => new RelationUserUserRole
        {
            IdUser = idUser,
            IdUserRole = role.Id
        });
        dbContext.RelationUserUserRoles.AddRange(entityRoles);
        await dbContext.SaveChangesAsync(token);
        DropCacheRelationUserUserRoleCacheTag();
    }

    private void DropCacheUsers()
        => memoryCache.Remove(userCacheTag);

    private IEnumerable<User> GetCacheUser()
    {
        var cache = memoryCache.GetOrCreate(userCacheTag, cacheEntry =>
        {
            cacheEntry.AbsoluteExpirationRelativeToNow = cacheObsolence;
            cacheEntry.SlidingExpiration = cacheObsolence;
            var query = dbContext.Users
                    .Include(r => r.Company)
                    .Include(r => r.RelationUsersUserRoles);
            var entities = query.ToArray();
            return entities;
        });
        return cache!;
    }

    private Task<IEnumerable<User>> GetCacheUserAsync(CancellationToken token)
    {
        var cache = memoryCache.GetOrCreateAsync(userCacheTag, async (cacheEntry) =>
        {
            cacheEntry.AbsoluteExpirationRelativeToNow = cacheObsolence;
            cacheEntry.SlidingExpiration = cacheObsolence;
            var query = dbContext.Users
                    .Include(r => r.Company)
                    .Include(r => r.RelationUsersUserRoles);
            var entities = await query.ToArrayAsync(token);
            return entities.AsEnumerable();
        });
        return cache!;
    }

    protected User Convert(UserExtendedDto dto)
    {
        var entity = dto.Adapt<User>(userTypeAdapterConfig);
        if (string.IsNullOrEmpty(entity.PasswordHash))
        {
            var hash = dbContext.Users.FirstOrDefault(u => u.Id == dto.Id)?.PasswordHash;
            entity.PasswordHash = hash ?? string.Empty;
        }
            
        return entity;
    }
    protected virtual UserExtendedDto Convert(User entity)
    {
        var dto = entity.Adapt<UserExtendedDto>();
        return dto;
    }        
}