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

using AsbCloudApp.Data;
using AsbCloudApp.Data.User;
using AsbCloudApp.Exceptions;
using AsbCloudApp.Repositories;
using AsbCloudApp.Requests;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Repository
{

    public class WellFinalDocumentsRepository : IWellFinalDocumentsRepository
    {
        private readonly IAsbCloudDbContext context;
        private readonly FileService fileService;
        private readonly IUserRepository userRepository;

        public WellFinalDocumentsRepository(IAsbCloudDbContext context, 
            FileService fileService,
            IUserRepository userRepository)
        {
            this.context = context;
            this.fileService = fileService;
            this.userRepository = userRepository;
        }

        ///<inheritdoc/>
        public async Task<IEnumerable<WellFinalDocumentDBDto>> UpdateRangeAsync(int idWell, IEnumerable<WellFinalDocumentInputDto> dtos, CancellationToken token)
        {
            if (!dtos.Any())
                throw new ArgumentInvalidException(nameof(dtos), "Данные по категориям отсутствуют.");

            var entities = dtos
                .Where(dto => dto.IdsPublishers?.Any() == true)
                .SelectMany(dto => dto.IdsPublishers
                    .Select(idUser => new WellFinalDocument
                    {
                        IdCategory = dto.IdCategory,
                        IdWell = idWell,
                        IdUser = idUser
                    }));

            var itemsToDelete = context.WellFinalDocuments.Where(d => d.IdWell == idWell);
            context.WellFinalDocuments.RemoveRange(itemsToDelete);

            context.WellFinalDocuments.AddRange(entities);
            await context.SaveChangesAsync(token).ConfigureAwait(false);

            return entities.Adapt<IEnumerable<WellFinalDocumentDBDto>>();
        }

        ///<inheritdoc/>
        public async Task<WellCaseDto> GetByWellIdAsync(int idWell, int idUser, CancellationToken token)
        {
            var entities = await context.WellFinalDocuments
                .Include(d => d.Category)
                .Include(d => d.User)
                .Where(d => d.IdWell == idWell)
                .AsNoTracking()
                .ToArrayAsync(token)
                .ConfigureAwait(false);

            var entitiesGroups = entities
                .GroupBy(d => d.IdCategory);

            var categoriesIds = entitiesGroups
                .Select(g => g.Key);

            var files = (await fileService
                .GetInfosAsync(new FileRequest { IdWell = idWell }, token)
                .ConfigureAwait(false))
                .Where(f => categoriesIds.Contains(f.IdCategory))
                .ToArray();

            var docs = entitiesGroups.Select((g) => new WellFinalDocumentDto
            {
                IdCategory = g.Key,
                FilesCount = files
                    .Where(f => f.IdCategory == g.Key)
                    .Count(),
                File = files
                    .Where(f => f.IdCategory == g.Key)
                    .OrderBy(f => f.UploadDate)
                    .LastOrDefault(),
                NameCategory = g.First().Category.Name,
                Publishers = g.Select(i => i.User.Adapt<UserDto>()),
                PermissionToUpload = g.Any(i => i.IdUser == idUser),
            });

            var result = new WellCaseDto
            {
                IdWell = idWell,
                PermissionToSetPubliher = userRepository.HasPermission(idUser, "WellFinalDocuments.editPublisher"),
                WellFinalDocuments = docs,
            };

            return result;
        }

        ///<inheritdoc/>
        public async Task<IEnumerable<UserDto>> GetAvailableUsersAsync(int idWell, CancellationToken token)
        {
            var companyIds = await context.RelationCompaniesWells
                .AsNoTracking()
                .Where(x => x.IdWell == idWell).Select(x => x.IdCompany)
                .ToListAsync(token)
                .ConfigureAwait(false);

            var allUsers = await userRepository
                .GetAllAsync(token)
                .ConfigureAwait(false);

            return allUsers.Where(x => companyIds.Contains(x.IdCompany))
                .OrderBy(x => x.Surname)
                .Select(u => u as UserDto)
                .ToArray();
        }

        ///<inheritdoc/>
        public async Task<WellFinalDocumentDBDto> GetCategoryAsync(int idWell, int idCategory, int idUser, CancellationToken token)
        {
            var entity = await context.WellFinalDocuments
                .AsNoTracking()
                .FirstOrDefaultAsync(x => x.IdWell == idWell && x.IdCategory == idCategory && x.IdUser == idUser, token) 
                ?? throw new ArgumentInvalidException(nameof(idUser), "Пользователь не является ответственным за загрузку файла для данной категории.");
            var dto = Convert(entity);
            return dto;
        }

        private static WellFinalDocumentDBDto Convert(WellFinalDocument entity)
            => entity.Adapt<WellFinalDocumentDBDto>();
    }

}