EnvelopeGenerator/EnvelopeGenerator.Infrastructure/Repositories/EnvelopeReceiverReadOnlyRepository.cs

using DigitalData.Core.Infrastructure;
using EnvelopeGenerator.Domain.Entities;
using EnvelopeGenerator.Application.Contracts.Repositories;
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;
    }
}