EnvelopeGenerator/EnvelopeGenerator.GeneratorAPI/Controllers/HistoryController.cs

using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.EnvelopeHistories.Queries.Read;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using static EnvelopeGenerator.Common.Constants;


namespace EnvelopeGenerator.GeneratorAPI.Controllers;

/// <summary>
/// Dieser Controller bietet Endpunkte für den Zugriff auf die Verlaufshistorie von Umschlägen.
/// </summary>
[Route("api/[controller]")]
[ApiController]
[Authorize]
public class HistoryController : ControllerBase
{
    private readonly ILogger<HistoryController> _logger;

    private readonly IEnvelopeHistoryService _service;

    /// <summary>
    /// Konstruktor für den HistoryController.
    /// </summary>
    /// <param name="logger">Der Logger, der für das Protokollieren von Informationen verwendet wird.</param>
    /// <param name="service">Der Dienst, der für die Verarbeitung der Verlaufshistorie verantwortlich ist.</param>
    public HistoryController(ILogger<HistoryController> logger, IEnvelopeHistoryService service)
    {
        _logger = logger;
        _service = service;
    }

    /// <summary>
    /// Ruft die verfügbaren Referenztypen ab und gibt sie als Schlüssel-Wert-Paare zurück.
    /// </summary>
    /// <returns>Ein Ok-Ergebnis mit einem Wörterbuch, das die Referenztypen als Schlüssel-Wert-Paare enthält.</returns>
    [HttpGet("reference-type")]
    [Authorize]
    public IActionResult GetReferenceTypes()
    {
        // Enum to Key-Value pair
        var referenceTypes = Enum.GetValues(typeof(ReferenceType))
                                 .Cast<ReferenceType>()
                                 .ToDictionary(rt =>
                                 {
                                     var key = rt.ToString();
                                     var keyAsCamelCase = char.ToLower(key[0]) + key[1..];
                                     return keyAsCamelCase;
                                 }, rt => (int)rt);

        return Ok(referenceTypes);
    }

    /// <summary>
    /// Ruft die gesamte Verlaufshistorie von Umschlägen basierend auf den angegebenen Abfrageparametern ab.
    /// </summary>
    /// <param name="history">Die Abfrageparameter, die die Filterkriterien für die Verlaufshistorie definieren.</param>
    /// <returns>Eine Liste von Verlaufseinträgen, die den angegebenen Kriterien entsprechen.</returns>
    [HttpGet]
    [Authorize]
    public async Task<IActionResult> GetAllAsync([FromQuery] ReadEnvelopeHistoryQuery history)
    {
        ReferenceType? refTypEnum = history.ReferenceType;
        bool withReceiver = false;
        bool withSender = false;

        switch (refTypEnum)
        {
            case ReferenceType.Receiver:
                withReceiver = true;
                break;
            case ReferenceType.Sender:
                withSender = true;
                break;
        }

        var histories = await _service.ReadAsync(
            envelopeId: history.EnvelopeId,
            //userReference: history.r,
            referenceType: refTypEnum,
            withSender: withSender,
            withReceiver: withReceiver);

        return Ok(histories);
    }
}