monorepo/LCU.API.Collections.RepoApi-old/LCU.Shared.Collections.RepoApiLib/Repositories/ProcessingReceiptRepository.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using LCU.Shared.Collections.RepoApiLib.Models;
using LCU.Shared.Collections.RepoApiLib.Models.Producer;
using LCU.Shared.Collections.RepoApiLib.Persistence;
using Microsoft.EntityFrameworkCore;

namespace LCU.Shared.Collections.RepoApiLib.Repositories
{
    public class ProcessingReceiptRepository : BaseRepository, IProcessingReceiptRepository
    {
        private readonly IReadOnlyCollection<RepoProcessingResult> _retryOutcomes = new List<RepoProcessingResult>()
        {
            RepoProcessingResult.Error, RepoProcessingResult.MissingRequirement
        };

        public ProcessingReceiptRepository(AppDbContext context) : base(context)
        {
        }

        public async Task<IReadOnlyCollection<ProcessingReceipt>> FindReceiptsAsync(string accountNo,
            string accountId = "", string caseId = "")
        {
            return await _context.ProcessingReceipts.Where(receipt => receipt.AccountNo == accountNo
                                                                      && receipt.AccountId == accountId &&
                                                                      receipt.CaseId == caseId).AsNoTracking().ToListAsync();
        }

        public async Task<IReadOnlyCollection<ProcessingReceipt>> GetReceiptsByAccountNoAsync(string accountNo)
        {
            return await _context.ProcessingReceipts.Where(receipt => receipt.AccountNo == accountNo).AsNoTracking().ToListAsync();
        }

        public async Task<IReadOnlyCollection<ProcessingReceipt>> GetRetryListAsync()
        {
            return await _context.ProcessingReceipts.Where(receipt => _retryOutcomes.Contains(receipt.Outcome))
                .AsNoTracking().ToListAsync();
        }

        public async Task AddOrUpdateAsync(ProcessingReceipt receipt)
        {
            if (receipt.Message != null && receipt.Message.Length > 124)
            {
                receipt.Message = receipt.Message.Substring(0, 124);
            } 
            
            if (receipt.QueuedBy != null && receipt.QueuedBy.Length > 39)
            {
                receipt.QueuedBy = receipt.QueuedBy.Substring(0, 39);
            }

            if (!IsDuplicateReceipt(receipt))
            {
                await _context.ProcessingReceipts.AddAsync(receipt);
            }
            else
            {
                _context.Entry(receipt).State = EntityState.Modified;
                _context.ProcessingReceipts.Update(receipt);
            }
        }

        public async Task SaveAllAsync(IReadOnlyCollection<ProcessingReceipt> receipts)
        {
            var saveAllReceipts = receipts.Select(AddOrUpdateAsync).ToList();
            await Task.WhenAll(saveAllReceipts);
        }

        public bool IsDuplicateReceipt(ProcessingReceipt newReceipt)
        {
            var duplicateReceipts = (
                from existingReceipt in _context.ProcessingReceipts
                where existingReceipt.AccountNo == newReceipt.AccountNo
                      && existingReceipt.AccountId == newReceipt.AccountId
                      && existingReceipt.CaseId == newReceipt.CaseId
                select existingReceipt
            ).AsNoTracking().ToList();

            return (duplicateReceipts.Count() != 0);
        }
        
    }
}