monorepo/LCU.API.Internal.DocumentIngestor/LCU.API.Internal.DocumentIngestorLib/Repositories/DocumentProcessingInfoRepository.cs

using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using LCU.API.Internal.DocumentIngestorLib.Persistence;
using LCU.Library.Internal.DocumentIngestorModels.Entities;
using LCU.Library.Internal.DocumentIngestorModels.Enums;
using LCU.Library.Internal.DocumentIngestorModels.Models.Pagination;
using LCU.Api.Internal.DocumentIngestorLib.Extensions.Queryables;

namespace LCU.API.Internal.DocumentIngestorLib.Repositories
{
    public class DocumentProcessingInfoRepository : BaseRepository, IDocumentProcessingInfoRepository
    {
        public DocumentProcessingInfoRepository(AppDbContext context) : base(context) { }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindAsync()
        {
            return await _context.DocumentProcessingInfos.ToListAsync();
        }

        public async Task<DocumentProcessingInfo> FindByIdAsync(int id)
        {
            return await _context.DocumentProcessingInfos
                                    .FirstOrDefaultAsync(documentProcessingInfo => documentProcessingInfo.DocumentProcessingInfoId == id);
        }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindListByIdAsync(List<int> ids)
        {
            return await _context.DocumentProcessingInfos
                                    .Where(documentProcessingInfo => ids.Contains(documentProcessingInfo.DocumentProcessingInfoId))
                                        .ToListAsync();
        }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindByIngestorRunInfoIdAsync(Guid ingestorRunInfoId)
        {
            return await _context.DocumentProcessingInfos
                                    .Where(documentProcessingInfo => documentProcessingInfo.IngestorRunInfoId == ingestorRunInfoId)
                                        .ToListAsync();
        }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindByProcessStatusTypeAsync(ProcessStatusTypes statusType, bool? isUnknown)
        {
            return await _context.DocumentProcessingInfos
                                    .Where(documentProcessingInfo => documentProcessingInfo.StatusType.Equals(statusType)
                                                                     && (isUnknown == null || documentProcessingInfo.EntityUnknown.Equals(isUnknown)))
                                        .ToListAsync();
        }


        public async Task<IEnumerable<DocumentProcessingInfo>> FindByProcessStatusTypeListAsync(List<ProcessStatusTypes> statusTypes, bool? isUnknown)
        {
            return await _context.DocumentProcessingInfos
                                    .Where(documentProcessingInfo => statusTypes.Contains(documentProcessingInfo.StatusType) &&
                                            (isUnknown == null || documentProcessingInfo.EntityUnknown == isUnknown))
                                    .ToListAsync();
        }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindCompletedFirstPassByIngestorRunInfoIdAsync(Guid ingestorRunInfoId)
        {
            return await _context.DocumentProcessingInfos.Where(documentProcessingInfo =>
                documentProcessingInfo.IngestorRunInfoId.Equals(ingestorRunInfoId) &&
                documentProcessingInfo.ProcessCount >= 1
            ).ToListAsync();
        }

        public async Task<DocumentProcessingInfo> AddAsync(DocumentProcessingInfo documentProcessingInfo)
        {
            var result = await _context.DocumentProcessingInfos.AddAsync(documentProcessingInfo);
            return result.Entity;
        }

        public async Task AddRangeAsync(DocumentProcessingInfo[] documentProcessingInfos)
        {
            await _context.DocumentProcessingInfos.AddRangeAsync(documentProcessingInfos);
        }

        public void Update(DocumentProcessingInfo documentProcessingInfo)
        {
            _context.DocumentProcessingInfos.Update(documentProcessingInfo);
        }

        public void UpdateRange(List<DocumentProcessingInfo> documentProcessingInfos)
        {
            _context.DocumentProcessingInfos.UpdateRange(documentProcessingInfos);
        }

        public void Remove(DocumentProcessingInfo documentProcessingInfo)
        {
            _context.DocumentProcessingInfos.Remove(documentProcessingInfo);
        }

        public async Task<PagedResult<DocumentProcessingInfo>> FilteredListAsync(Filter filter)
        {
            var results = new PagedResult<DocumentProcessingInfo>();
            var skip = (filter.Page - 1) * filter.Limit;

            results.Total = await _context.DocumentProcessingInfos
                .IncludeAll()
                .IncludeFilters(filter)
                .CountAsync();

            results.Items = await _context.DocumentProcessingInfos
                .IncludeAll()
                .IncludeFilters(filter)
                .OrderBySortableFields(filter)
                .Skip(skip)
                .Take(filter.Limit)
                .ToArrayAsync();

            return results;
        }

        public async Task<int> CountCompletedFirstPassByIngestorRunInfoIdAsync(Guid ingestorRunInfoId)
        {
            return await _context.DocumentProcessingInfos.CountAsync(documentProcessingInfo =>
                documentProcessingInfo.IngestorRunInfoId.Equals(ingestorRunInfoId) &&
                documentProcessingInfo.ProcessCount >= 1
            );
        }

        public async Task<int> CountCompletedByIngestorRunInfoIdAsync(Guid ingestorRunInfoId)
        {
            return await _context.DocumentProcessingInfos.CountAsync(documentProcessingInfo =>
                documentProcessingInfo.IngestorRunInfoId.Equals(ingestorRunInfoId) &&
                documentProcessingInfo.StatusType == ProcessStatusTypes.Completed                
            );
        }

        public async Task<IEnumerable<DocumentProcessingInfo>> FindByDocumentIdsAsync(Guid[] ids)
            => await _context.DocumentProcessingInfos.Where(i => i.DocumentId != null && ids.Contains(i.DocumentId.Value)).ToArrayAsync();
    }
}