EnvelopeGenerator/EnvelopeGenerator.Application/EnvelopeReceivers/Queries/ReadEnvelopeReceiverQuery.cs

using AutoMapper;
using DigitalData.Core.Abstraction.Application.Repository;
using DigitalData.Core.Exceptions;
using EnvelopeGenerator.Application.Envelopes.Queries;
using EnvelopeGenerator.Application.Receivers.Queries;
using MediatR;
using EnvelopeGenerator.Domain.Entities;
using Microsoft.EntityFrameworkCore;
using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
using EnvelopeGenerator.Application.Common.Query;
using EnvelopeGenerator.Application.Common.Extensions;

namespace EnvelopeGenerator.Application.EnvelopeReceivers.Queries;

/// <summary>
/// Repräsentiert eine Abfrage zum Lesen eines Envelope-Empfängers.
/// Invalid (0): Ungültiger Include.
/// EnvelopeCreated (1001): Der Umschlag wurde erstellt.
/// EnvelopeSaved (1002): Der Umschlag wurde gespeichert.
/// EnvelopeQueued (1003): Der Umschlag wurde zur Verarbeitung eingeplant.
/// EnvelopeSent (1004): Der Umschlag wurde versendet. (Nicht verwendet)
/// EnvelopePartlySigned (1005): Der Umschlag wurde teilweise unterschrieben.
/// EnvelopeCompletelySigned (1006): Der Umschlag wurde vollständig unterschrieben.
/// EnvelopeReportCreated (1007): Ein Abschlussbericht wurde für den Umschlag erstellt.
/// EnvelopeArchived (1008): Der Umschlag wurde archiviert.
/// EnvelopeDeleted (1009): Der Umschlag wurde gelöscht.
/// AccessCodeRequested (2001): Der Zugriffscode wurde angefordert.
/// AccessCodeCorrect (2002): Der Zugriffscode war korrekt.
/// AccessCodeIncorrect (2003): Der Zugriffscode war falsch.
/// DocumentOpened (2004): Das Dokument wurde geöffnet.
/// DocumentSigned (2005): Ein Dokument wurde unterschrieben.
/// SignatureConfirmed (2006): Die Signatur wurde bestätigt.
/// DocumentRejected (2007): Ein Dokument wurde abgelehnt.
/// EnvelopeShared (2008): Der Umschlag wurde geteilt.
/// EnvelopeViewed (2009): Der Umschlag wurde angesehen.
/// DocumentForwarded (4001): Das Dokument wurde weitergeleitet.
/// MessageInvitationSent (3001): Einladung wurde gesendet (vom Trigger verwendet).
/// MessageAccessCodeSent (3002): Zugriffscode wurde gesendet.
/// MessageConfirmationSent (3003): Bestätigungsnachricht wurde gesendet.
/// MessageDeletionSent (3004): Löschbenachrichtigung wurde gesendet.
/// MessageCompletionSent (3005): Abschlussbenachrichtigung wurde gesendet.
/// </summary>
/// <remarks>
/// Diese Abfrage kombiniert Informationen über einen Umschlag (<see cref="ReadEnvelopeQuery"/>) 
/// und einen Empfänger (<see cref="ReadReceiverQuery"/>), um eine vollständige Antwort 
/// (<see cref="EnvelopeReceiverDto"/>) zu generieren. 
/// Die Antwort enthält Details wie den Include, die Zuordnung zwischen Umschlag und Empfänger 
/// sowie zusätzliche Metadaten.
/// </remarks>
public record ReadEnvelopeReceiverQuery : EnvelopeReceiverQueryBase<ReadEnvelopeQuery, ReadReceiverQuery>, IRequest<IEnumerable<EnvelopeReceiverDto>>
{
    /// <summary>
    /// Optionaler Benutzernamefilter, um Ergebnisse auf Umschläge eines bestimmten Besitzers einzuschränken.
    /// </summary>
    public string? Username { get; init; }
}

/// <summary>
/// 
/// </summary>
public static class Extensions
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="mediator"></param>
    /// <param name="key"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public static Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string key, CancellationToken cancel = default)
    {
        var q = new ReadEnvelopeReceiverQuery() { Key = key };
        return mediator.Send(q, cancel).Then(envRcvs => envRcvs.FirstOrDefault());
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="mediator"></param>
    /// <param name="uuid"></param>
    /// <param name="signature"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public static Task<EnvelopeReceiverDto?> ReadEnvelopeReceiverAsync(this IMediator mediator, string uuid, string signature, CancellationToken cancel = default)
    {
        var q = new ReadEnvelopeReceiverQuery();
        q.Envelope.Uuid = uuid;
        q.Receiver.Signature = signature;
        return mediator.Send(q, cancel).Then(envRcvs => envRcvs.FirstOrDefault());
    }
    /// <summary>
    /// Verarbeitet <see cref="ReadEnvelopeReceiverQuery"/> und liefert passende <see cref="EnvelopeReceiverDto"/>-Ergebnisse.
    /// </summary>
    public class ReadEnvelopeReceiverQueryHandler : IRequestHandler<ReadEnvelopeReceiverQuery, IEnumerable<EnvelopeReceiverDto>>
    {
        private readonly IRepository<EnvelopeReceiver> _repo;
        private readonly IRepository<Receiver> _rcvRepo;
        private readonly IMapper _mapper;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="envelopeReceiver"></param>
        /// <param name="rcvRepo"></param>
        /// <param name="mapper"></param>
        public ReadEnvelopeReceiverQueryHandler(IRepository<EnvelopeReceiver> envelopeReceiver, IRepository<Receiver> rcvRepo, IMapper mapper)
        {
            _repo = envelopeReceiver;
            _mapper = mapper;
            _rcvRepo = rcvRepo;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="request"></param>
        /// <param name="cancel"></param>
        /// <returns></returns>
        /// <exception cref="BadRequestException"></exception>
        public async Task<IEnumerable<EnvelopeReceiverDto>> Handle(ReadEnvelopeReceiverQuery request, CancellationToken cancel)
        {
            var q = _repo.Query.Where(request, notnull: false);

            if (request.Username is string username)
                q = q.Where(er => er.Envelope!.User.Username == username);

            if (request.Envelope.Status is not null)
            {
                var status = request.Envelope.Status;
                if (status.Min is not null)
                    q = q.Where(er => er.Envelope!.Status >= status.Min);

                if (status.Max is not null)
                    q = q.Where(er => er.Envelope!.Status <= status.Max);

                if (status.Include?.Length > 0)
                    q = q.Where(er => status.Include.Contains(er.Envelope!.Status));

                if (status.Ignore is not null)
                    q = q.Where(er => !status.Ignore.Contains(er.Envelope!.Status));
            }

            var envRcvs = await q
                            .Include(er => er.Envelope).ThenInclude(e => e!.Documents!).ThenInclude(d => d.Elements)
                            .Include(er => er.Envelope).ThenInclude(e => e!.Histories)
                            .Include(er => er.Envelope).ThenInclude(e => e!.User)
                            .Include(er => er.Receiver)
                            .ToListAsync(cancel);

            if (request.Receiver.HasAnyCriteria && envRcvs.Count != 0)
            {
                var receiver = await _rcvRepo.Query.Where(request.Receiver).FirstAsync(cancel);

                foreach (var envRcv in envRcvs)
                    envRcv.Envelope?.Documents?.FirstOrDefault()?.Elements?.RemoveAll(s => s.ReceiverId != receiver.Id);
            }

            return _mapper.Map<List<EnvelopeReceiverDto>>(envRcvs);
        }
    }
}