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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using LCU.Api.Internal.DocumentIngestorLib.Extensions.Queryables;
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;

namespace LCU.API.Internal.DocumentIngestorLib.Repositories;

public class MemberNotificationInfoRepository : BaseRepository, IMemberNotificationInfoRepository
{
    public MemberNotificationInfoRepository(AppDbContext context) : base(context) { }

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

    public async Task<MemberNotificationInfo> FindByIdAsync(int id)
    {
        return await _context.MemberNotificationInfos
                                .FirstOrDefaultAsync(memberNotificationInfo => memberNotificationInfo.MemberNotificationInfoId == id);
    }

    public async Task<IEnumerable<MemberNotificationInfo>> FindListByIdAsync(List<int> ids)
    {
        return await _context.MemberNotificationInfos
                                .Where(memberNotificationInfo => ids.Contains(memberNotificationInfo.MemberNotificationInfoId))
                                    .ToListAsync();
    }

    public async Task<IEnumerable<MemberNotificationInfo>> FindByDocumentProcessingInfoIdAsync(int documentProcessingInfoId)
    {
        return await _context.MemberNotificationInfos
                                .Where(memberNotificationInfo => documentProcessingInfoId == memberNotificationInfo.DocumentProcessingInfoId)
                                    .ToListAsync();
    }

    public async Task<IEnumerable<MemberNotificationInfo>> FindByNotificationStatusAsync(NotificationStatusTypes status)
    {
        return await _context.MemberNotificationInfos
                                .Where(memberNotificationInfo => status == memberNotificationInfo.NotificationStatusType)
                                    .ToListAsync();
    }

    public async Task<IEnumerable<MemberNotificationInfo>> FindSendableMemberNotificationsAsync(DateTime minimumUploadDate, int maxAttempts)
    {
        return await _context.MemberNotificationInfos
                                .Where(memberNotificationInfo =>
                                            memberNotificationInfo.UploadDate <= minimumUploadDate &&
                                            memberNotificationInfo.Attempts <= maxAttempts &&
                                            memberNotificationInfo.DeliveryMethod != DeliveryMethod.Paper &&
                                            memberNotificationInfo.NotificationStatusType == NotificationStatusTypes.Pending ||
                                            memberNotificationInfo.NotificationStatusType == NotificationStatusTypes.Failure)
                                    .AsNoTracking()
                                    .ToListAsync();
    }

    public async Task<MemberNotificationInfo> AddAsync(MemberNotificationInfo memberNotificationInfo)
    {
        var result = await _context.MemberNotificationInfos.AddAsync(memberNotificationInfo);
        return result.Entity;
    }

    public async Task AddListAsync(List<MemberNotificationInfo> memberNotificationInfos)
    {
        await _context.MemberNotificationInfos.AddRangeAsync(memberNotificationInfos);
    }

    public void Update(MemberNotificationInfo memberNotificationInfo)
    {
        _context.MemberNotificationInfos.Update(memberNotificationInfo);
    }

    public void UpdateRange(IEnumerable<MemberNotificationInfo> memberNotificationInfos)
    {
        _context.MemberNotificationInfos.UpdateRange(memberNotificationInfos);
    }

    public void Remove(MemberNotificationInfo memberNotificationInfo)
    {
        _context.MemberNotificationInfos.Remove(memberNotificationInfo);
    }

    public async Task<IEnumerable<MemberNotificationInfo>> GetMemberNotificationInfosByFilter(Filter filter)
    {
        var query = _context.DocumentProcessingInfos
            .IncludeFilters(filter)
            .Include(documentProcessingInfo => documentProcessingInfo.MemberNotificationInfos)
            .Where(x => x.MemberNotificationInfos.Any())
            .SelectMany(x => x.MemberNotificationInfos);
        
        if (filter.NotificationStatusFilters != null)
        {
            if (filter.NotificationStatusFilters.Any())
            {
                query = query.Where(memberNotificationInfo => 
                    filter.NotificationStatusFilters.Contains(memberNotificationInfo.NotificationStatusType));
            }
        }
            
        return await query.AsNoTracking()
                          .ToListAsync();
    }
}