EnvelopeGenerator/EnvelopeGenerator.Infrastructure/Repositories/EnvelopeRepository.cs

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

namespace EnvelopeGenerator.Infrastructure.Repositories;

[Obsolete("Use IRepository")]
public class EnvelopeRepository : CRUDRepository<Envelope, int, EGDbContext>, IEnvelopeRepository
{
    public EnvelopeRepository(EGDbContext dbContext) : base(dbContext, dbContext.Envelopes)
    {
    }

    public async Task<IEnumerable<Envelope>> ReadAllWithAsync(bool documents = false, bool history = false, bool documentReceiverElement = false)
    {
        var query = _dbSet.AsNoTracking();

        if (documents)
            if (documentReceiverElement)
                query = query.Include(e => e.Documents!).ThenInclude(d => d.Elements);
            else
                query = query.Include(e => e.Documents);

        if (history)
            query = query.Include(e => e.History);

        return await query.ToListAsync();
    }

    public async Task<Envelope?> ReadByUuidAsync(string uuid, bool withDocuments = false, bool withHistory = false, bool withDocumentReceiverElement = false, bool withUser = false, bool withAll = false)
    {
        var query = _dbSet.AsNoTracking().Where(e => e.Uuid == uuid);

        if (withAll || withDocuments)
            if (withAll || withDocumentReceiverElement)
                query = query.Include(e => e.Documents!).ThenInclude(d => d.Elements);
            else
                query = query.Include(e => e.Documents);

        if (withAll || withUser)
            query = query.Include(e => e.User!);

        if (withAll || withHistory)
            query = query.Include(e => e.History);

        return await query.FirstOrDefaultAsync();
    }

    public async Task<IEnumerable<Envelope>> ReadByUserAsync(int userId, int? min_status = null, int? max_status = null, params int[] ignore_statuses)
    {
        var query = _dbSet.AsNoTracking().Where(e => e.UserId == userId);

        if (min_status is not null)
            query = query.Where(e => e.Status >= min_status);

        if (max_status is not null)
            query = query.Where(e => e.Status <= max_status);

        foreach (var ignore_status in ignore_statuses)
            query = query.Where(e => e.Status != ignore_status);

        return await query.ToListAsync();
    }
}