EnvelopeGenerator/EnvelopeGenerator.Infrastructure/Repositories/EnvelopeReceiverReadOnlyRepository.cs

using DigitalData.Core.Infrastructure;
using EnvelopeGenerator.Domain.Entities;
using EnvelopeGenerator.Infrastructure.Contracts;
using Microsoft.EntityFrameworkCore;

namespace EnvelopeGenerator.Infrastructure.Repositories
{
    public class EnvelopeReceiverReadOnlyRepository : CRUDRepository<EnvelopeReceiverReadOnly, long, EGDbContext>, IEnvelopeReceiverReadOnlyRepository
    {
        private readonly IEnvelopeRepository _envRepo;

        public EnvelopeReceiverReadOnlyRepository(EGDbContext dbContext, IEnvelopeRepository envelopeRepository) : base(dbContext, dbContext.EnvelopeReceiverReadOnlys)
        {
            _envRepo = envelopeRepository;
        }

        protected override IQueryable<EnvelopeReceiverReadOnly> ReadOnly()
        {
            return base.ReadOnly()
                //TODO: add again when EnvelopeId data type is standardized
                //.Include(erro => erro.Envelope)
                .Include(erro => erro.Receiver);
        }

        public async override Task<IEnumerable<EnvelopeReceiverReadOnly>> ReadAllAsync()
        {
            var erros = await base.ReadAllAsync();
            return await IncludeEnvelope(erros);
        }

        public override async Task<EnvelopeReceiverReadOnly?> ReadByIdAsync(long id)
        {
            var erro = await _dbSet.AsNoTracking()
                .Include(erro => erro.Receiver)
                .Where(erro => erro.Id == id)
                .FirstOrDefaultAsync();

            return await IncludeEnvelope(erro);
        }

        //TODO: Use IQueryable.Include instead of this when ID type is clarified.
        [Obsolete("Use IQueryable.Include instead of this when ID type is clarified.")]
        private async Task<EnvelopeReceiverReadOnly> IncludeEnvelope(EnvelopeReceiverReadOnly erro)
        {
            erro.Envelope = await _envRepo.ReadByIdAsync((int)erro.EnvelopeId);
            return erro;
        }

        //TODO: Use IQueryable.Include instead of this when ID type is clarified.
        [Obsolete("Use IQueryable.Include instead of this when ID type is clarified.")]
        private async Task<IEnumerable<EnvelopeReceiverReadOnly>> IncludeEnvelope(params EnvelopeReceiverReadOnly[] erros)
        {
            foreach (var erro in erros)
                erro.Envelope = await _envRepo.ReadByIdAsync((int) erro.EnvelopeId);

            return erros;
        }

        //TODO: Use IQueryable.Include instead of this when ID type is clarified.
        [Obsolete("Use IQueryable.Include instead of this when ID type is clarified.")]
        private async Task<T> IncludeEnvelope<T>(T erros)
            where T : IEnumerable<EnvelopeReceiverReadOnly>
        {
            foreach (var erro in erros)
                erro.Envelope = await _envRepo.ReadByIdAsync((int)erro.EnvelopeId);

            return erros;
        }
    }
}