EnvelopeGenerator/EnvelopeGenerator.Application/Envelopes/Queries/ReadEnvelopeQuery.cs

using MediatR;
using EnvelopeGenerator.Domain.Constants;
using EnvelopeGenerator.Application.Common.Query;
using EnvelopeGenerator.Application.Common.Dto;
using EnvelopeGenerator.Application.Common.Dto.EnvelopeReceiver;
using EnvelopeGenerator.Application.Common.Dto.History;
using EnvelopeGenerator.Application.Common.Dto.Receiver;
using AutoMapper;
using DigitalData.Core.Abstraction.Application.Repository;
using EnvelopeGenerator.Domain.Entities;
using Microsoft.EntityFrameworkCore;

namespace EnvelopeGenerator.Application.Envelopes.Queries;

/// <summary>
/// Repräsentiert eine Abfrage für Umschläge.
/// </summary>
public record ReadEnvelopeQuery : EnvelopeQueryBase, IRequest<IEnumerable<EnvelopeDto>>
{
    /// <summary>
    /// 
    /// </summary>
    public bool IncludeDocAndDocRes { get; init; } = true;

    /// <summary>
    /// 
    /// </summary>
    public bool OnlyActive { get; init; } = false;

    /// <summary>
    /// 
    /// </summary>
    public bool OnlyCompleted { get; init; } = false;

    /// <summary>
    /// Abfrage des Include des Umschlags
    /// </summary>
    public EnvelopeStatusQuery? Status { get; init; }

    /// <summary>
    /// Optionaler Benutzerfilter; wenn gesetzt, werden nur Umschläge des Benutzers geladen.
    /// </summary>
    internal int? UserId { get; init; }

    /// <summary>
    /// Setzt den Benutzerkontext für die Abfrage.
    /// </summary>
    public ReadEnvelopeQuery Authorize(int userId) => this with { UserId = userId };
}

/// <summary>
/// Repräsentiert den Include eines Umschlags und dessen Beziehung zum Empfänger. (vgl. auch <see cref="EnvelopeStatusQuery"/>
/// 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>

public record EnvelopeStatusQuery
{
    /// <summary>
    /// Der minimale Statuswert, der berücksichtigt werden.
    /// </summary>
    public EnvelopeStatus? Min { get; init; }

    /// <summary>
    /// Der maximale Statuswert, der berücksichtigt werden.
    /// </summary>
    public EnvelopeStatus? Max { get; init; }

    /// <summary>
    /// Eine Liste von Statuswerten, die einbezogen werden.
    /// </summary>
    public EnvelopeStatus[]? Include { get; init; }

    /// <summary>
    /// Eine Liste von Statuswerten, die ignoriert werden werden.
    /// </summary>
    public EnvelopeStatus[]? Ignore { get; init; }
}

/// <summary>
/// Verarbeitet <see cref="ReadEnvelopeQuery"/> und liefert passende <see cref="EnvelopeDto"/>-Ergebnisse.
/// </summary>
public class ReadEnvelopeQueryHandler : IRequestHandler<ReadEnvelopeQuery, IEnumerable<EnvelopeDto>>
{
    private readonly IRepository<Envelope> _repository;
    private readonly IMapper _mapper;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="repository"></param>
    /// <param name="mapper"></param>
    public ReadEnvelopeQueryHandler(IRepository<Envelope> repository, IMapper mapper)
    {
        _repository = repository;
        _mapper = mapper;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="request"></param>
    /// <param name="cancel"></param>
    /// <returns></returns>
    public async Task<IEnumerable<EnvelopeDto>> Handle(ReadEnvelopeQuery request, CancellationToken cancel)
    {
        var query = _repository.Query;

        if (request.UserId is int userId)
            query = query.Where(e => e.UserId == userId);

        if (request.Id is int id)
            query = query.Where(e => e.Id == id);

        if (request.Uuid is string uuid)
            query = query.Where(e => e.Uuid == uuid);

        if (request.Status is { } status)
        {
            if (status.Min is not null)
                query = query.Where(e => e.Status >= status.Min);
            if (status.Max is not null)
                query = query.Where(e => e.Status <= status.Max);
            if (status.Include?.Length > 0)
                query = query.Where(e => status.Include.Contains(e.Status));
            if (status.Ignore?.Length > 0)
                query = query.Where(e => !status.Ignore.Contains(e.Status));
        }

        if(request is { OnlyActive: true })
            query = query.Where(e => Status.Active.Contains(e.Status));

        if (request is { OnlyCompleted: true })
            query = query.Where(e => Status.Completed.Contains(e.Status));

        if (!request.IncludeDocAndDocRes)
        {
            return await query
                .Select(e => new EnvelopeDto
                {
                    Id = e.Id,
                    UserId = e.UserId,
                    Status = e.Status,
                    StatusName = string.Empty,
                    Uuid = e.Uuid,
                    Message = e.Message,
                    AddedWhen = e.AddedWhen,
                    ChangedWhen = e.ChangedWhen,
                    Title = e.Title ?? string.Empty,
                    ContractType = e.ContractType,
                    Language = e.Language,
                    EnvelopeTypeId = e.EnvelopeTypeId,
                    CertificationType = e.CertificationType,
                    FinalEmailToCreator = e.FinalEmailToCreator,
                    FinalEmailToReceivers = e.FinalEmailToReceivers,
                    SendReminderEmails = e.SendReminderEmails,
                    FirstReminderDays = e.FirstReminderDays,
                    ReminderIntervalDays = e.ReminderIntervalDays,
                    ExpiresWhenDays = e.ExpiresWhenDays,
                    ExpiresWarningWhenDays = e.ExpiresWarningWhenDays,
                    UseAccessCode = e.UseAccessCode ?? true,
                    TFAEnabled = e.TfaEnabled ?? false,
                    EnvelopeTypeTitle = e.Type != null ? e.Type.Title : null,
                    IsAlreadySent = false,
                    DocResult = null,
                    Documents = null,
                    EnvelopeReceivers = e.EnvelopeReceivers.Select(er => new EnvelopeReceiverDto
                    {
                        EnvelopeId = er.EnvelopeId,
                        ReceiverId = er.ReceiverId,
                        Sequence = er.Sequence,
                        Name = er.Name,
                        JobTitle = er.JobTitle,
                        CompanyName = er.CompanyName,
                        PrivateMessage = er.PrivateMessage,
                        AccessCode = er.AccessCode,
                        AddedWhen = er.AddedWhen,
                        ChangedWhen = er.ChangedWhen,
                        HasPhoneNumber = er.HasPhoneNumber,
                        Receiver = er.Receiver == null
                            ? null
                            : new ReceiverDto
                            {
                                Id = er.Receiver.Id,
                                EmailAddress = er.Receiver.EmailAddress,
                                Signature = er.Receiver.Signature,
                                AddedWhen = er.Receiver.AddedWhen,
                                TfaRegDeadline = er.Receiver.TfaRegDeadline
                            }
                    }),
                    Histories = e.Histories.Select(h => new HistoryDto
                    {
                        Id = h.Id,
                        EnvelopeId = h.EnvelopeId,
                        UserReference = h.UserReference,
                        Status = h.Status,
                        StatusName = null,
                        AddedWhen = h.AddedWhen,
                        ActionDate = h.ActionDate,
                        Comment = h.Comment,
                        Receiver = h.Receiver == null
                            ? null
                            : new ReceiverDto
                            {
                                Id = h.Receiver.Id,
                                EmailAddress = h.Receiver.EmailAddress,
                                Signature = h.Receiver.Signature,
                                AddedWhen = h.Receiver.AddedWhen,
                                TfaRegDeadline = h.Receiver.TfaRegDeadline
                            }
                    })
                })
                .ToListAsync(cancel);
        }

        var envelopes = await query
            .Include(e => e.Type)
            .Include(e => e.EnvelopeReceivers).ThenInclude(er => er.Receiver)
            .Include(e => e.Histories)
            .ToListAsync(cancel);

        return _mapper.Map<IEnumerable<EnvelopeDto>>(envelopes);
    }
}