EnvelopeGenerator/EnvelopeGenerator.GeneratorAPI/Controllers/EnvelopeController.cs

using DigitalData.Core.DTO;
using EnvelopeGenerator.Application.Contracts.Services;
using EnvelopeGenerator.Application.Envelopes.Commands;
using EnvelopeGenerator.Application.Envelopes.Queries.Read;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations.Schema;

namespace EnvelopeGenerator.GeneratorAPI.Controllers;

/// <summary>
/// Dieser Controller stellt Endpunkte für die Verwaltung von Umschlägen bereit.
/// </summary>
/// <remarks>
/// Die API ermöglicht das Abrufen und Verwalten von Umschlägen basierend auf Benutzerinformationen und Statusfiltern.
/// 
/// Mögliche Antworten:
/// - 200 OK: Die Anfrage war erfolgreich, und die angeforderten Daten werden zurückgegeben.
/// - 400 Bad Request: Die Anfrage war fehlerhaft oder unvollständig.
/// - 401 Unauthorized: Der Benutzer ist nicht authentifiziert.
/// - 403 Forbidden: Der Benutzer hat keine Berechtigung, auf die Ressource zuzugreifen.
/// - 404 Not Found: Die angeforderte Ressource wurde nicht gefunden.
/// - 500 Internal Server Error: Ein unerwarteter Fehler ist aufgetreten.
/// </remarks>
[Route("api/[controller]")]
[ApiController]
[Authorize]
public class EnvelopeController : ControllerBase
{
    private readonly ILogger<EnvelopeController> _logger;
    private readonly IEnvelopeService _envelopeService;
    private readonly IMediator _mediator;

    /// <summary>
    /// Erstellt eine neue Instanz des EnvelopeControllers.
    /// </summary>
    /// <param name="logger">Der Logger, der für das Protokollieren von Informationen verwendet wird.</param>
    /// <param name="envelopeService">Der Dienst, der für die Verarbeitung von Umschlägen zuständig ist.</param>
    /// <param name="mediator"></param>
    public EnvelopeController(ILogger<EnvelopeController> logger, IEnvelopeService envelopeService, IMediator mediator)
    {
        _logger = logger;
        _envelopeService = envelopeService;
        _mediator = mediator;
    }

    /// <summary>
    /// Ruft eine Liste von Umschlägen basierend auf dem Benutzer und den angegebenen Statusfiltern ab.
    /// </summary>
    /// <param name="envelope"></param>
    /// <returns>Eine IActionResult-Instanz, die die abgerufenen Umschläge oder einen Fehlerstatus enthält.</returns>
    /// <response code="200">Die Anfrage war erfolgreich, und die Umschläge werden zurückgegeben.</response>
    /// <response code="400">Die Anfrage war fehlerhaft oder unvollständig.</response>
    /// <response code="401">Der Benutzer ist nicht authentifiziert.</response>
    /// <response code="403">Der Benutzer hat keine Berechtigung, auf die Ressource zuzugreifen.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [Authorize]
    [HttpGet]
    public async Task<IActionResult> GetAsync([FromQuery] ReadEnvelopeQuery envelope)
    {
        try
        {
            if (User.GetId() is int intId)
                return await _envelopeService.ReadByUserAsync(intId, min_status: envelope.Status, max_status: envelope.Status).ThenAsync(
                    Success: envelopes =>
                    {
                        if(envelope.Id is int id)
                            envelopes = envelopes.Where(e => e.Id == id);

                        if(envelope.Status is int status)
                            envelopes = envelopes.Where(e => e.Status == status);

                        if (envelope.Uuid is string uuid)
                            envelopes = envelopes.Where(e => e.Uuid == uuid);

                        return Ok(envelopes);
                    },
                    Fail: IActionResult (msg, ntc) =>
                    {
                        _logger.LogNotice(ntc);
                        return StatusCode(StatusCodes.Status500InternalServerError);
                    });
            else
            {
                _logger.LogError("Trotz erfolgreicher Autorisierung wurde die Benutzer-ID nicht als Ganzzahl erkannt. Dies könnte auf eine fehlerhafte Erstellung der Anspruchsliste zurückzuführen sein.");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{Message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    /// <summary>
    /// Ruft das Ergebnis eines Dokuments basierend auf der ID ab.
    /// </summary>
    /// <param name="id">Die eindeutige ID des Umschlags.</param>
    /// <param name="view">Gibt an, ob das Dokument inline angezeigt werden soll (true) oder als Download bereitgestellt wird (false).</param>
    /// <returns>Eine IActionResult-Instanz, die das Dokument oder einen Fehlerstatus enthält.</returns>
    /// <response code="200">Das Dokument wurde erfolgreich abgerufen.</response>
    /// <response code="404">Das Dokument wurde nicht gefunden oder ist nicht verfügbar.</response>
    /// <response code="500">Ein unerwarteter Fehler ist aufgetreten.</response>
    [HttpGet("doc-result")]
    public async Task<IActionResult> GetDocResultAsync([FromQuery] int id, [FromQuery] bool view = false)
    {
        try
        {
            if (User.GetId() is int intId)
                return await _envelopeService.ReadByUserAsync(intId).ThenAsync(
                    Success: envelopes =>
                    {
                        var envelope = envelopes.Where(e => e.Id == id).FirstOrDefault();

                        if (envelope is null)
                            return NotFound("Envelope not available.");
                        else if (envelope?.DocResult is null)
                            return NotFound("The document has not been fully signed or the result has not yet been released.");
                        else
                        {
                            if (view)
                            {
                                Response.Headers.Append("Content-Disposition", "inline; filename=\"" + envelope.Uuid + ".pdf\"");
                                return File(envelope.DocResult, "application/pdf");
                            }
                            else
                                return File(envelope.DocResult, "application/pdf", $"{envelope.Uuid}.pdf");
                        }
                    },
                    Fail: IActionResult (msg, ntc) =>
                    {
                        _logger.LogNotice(ntc);
                        return StatusCode(StatusCodes.Status500InternalServerError);
                    });
            else
            {
                _logger.LogError("Trotz erfolgreicher Autorisierung wurde die Benutzer-ID nicht als Ganzzahl erkannt. Dies könnte auf eine fehlerhafte Erstellung der Anspruchsliste zurückzuführen sein.");
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{Message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="envelope"></param>
    /// <returns></returns>
    [NonAction]
    [Authorize]
    [HttpPost]
    public async Task<IActionResult> CreateAsync([FromQuery] CreateEnvelopeCommand envelope)
    {
        try
        {
            envelope.UserId = User.GetId();
            var res = await _mediator.Send(envelope);
            
            if (res is null)
            {
                _logger.LogError("Failed to create envelope. Envelope details: {EnvelopeDetails}", JsonConvert.SerializeObject(envelope));
                return StatusCode(StatusCodes.Status500InternalServerError);
            }
            else
                return Ok(res);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{Message}", ex.Message);
            return StatusCode(StatusCodes.Status500InternalServerError);
        }
    }
}