Refactor envelope and user query structures

- Introduced a new `UserQuery` record to encapsulate user-related information, replacing individual fields in `EnvelopeQuery`.
- Added a `ReferenceType` property in `EnvelopeHistoryQuery` to enhance reference handling logic.
- Modified `EnvelopeQuery` to use the new `UserQuery` structure, simplifying the data model.
- Updated `HistoryController` with a new constructor and restructured the `GetReferenceTypes` method.
- Introduced `ReadEnvelopeHistoryQuery` to allow for more specific envelope history queries.
- Overall improvements enhance code structure, clarity, and querying capabilities.

EnvelopeGenerator.GeneratorAPI/Controllers/HistoryController.cs

@@ -1,73 +1,82 @@
 using EnvelopeGenerator.Application.Contracts.Services;
+using EnvelopeGenerator.Application.EnvelopeHistories.Queries.Read;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
-using System;
 using static EnvelopeGenerator.Common.Constants;
 
-namespace EnvelopeGenerator.GeneratorAPI.Controllers
+
+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
 {
-    [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)
     {
-        private readonly ILogger<HistoryController> _logger;
+        _logger = logger;
+        _service = service;
+    }
 
-        private readonly IEnvelopeHistoryService _service;
+    [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);
 
-        public HistoryController(ILogger<HistoryController> logger, IEnvelopeHistoryService service)
+        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)
         {
-            _logger = logger;
-            _service = service;
+            case ReferenceType.Receiver:
+                withReceiver = true;
+                break;
+            case ReferenceType.Sender:
+                withSender = true;
+                break;
         }
 
-        [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);
+        var histories = await _service.ReadAsync(
+            envelopeId: history.EnvelopeId,
+            //userReference: history.r,
+            referenceType: refTypEnum,
+            withSender: withSender,
+            withReceiver: withReceiver);
 
-            return Ok(referenceTypes);
-        }
-
-        [HttpGet]
-        [Authorize]
-        public async Task<IActionResult> GetAllAsync([FromQuery] int? envelopeId = null, [FromQuery] string? userReference = null, [FromQuery] int? referenceType = null, [FromQuery] bool withSender = false, [FromQuery] bool withReceiver = false)
-        {
-            ReferenceType? refTypEnum = null;
-
-            if (referenceType is int refTypInt)
-                if (Enum.IsDefined(typeof(ReferenceType), refTypInt))
-                    refTypEnum = (ReferenceType)refTypInt;
-                else
-                    throw new ArgumentException($"The provided referenceType '{referenceType}' is not valid. It must correspond to a valid value in the {nameof(ReferenceType)} enum.");
-
-            switch(referenceType)
-            {
-                case (int)ReferenceType.Receiver:
-                    withReceiver = true;
-                    break;
-                case (int)ReferenceType.Sender:
-                    withSender = true;
-                    break;
-            }
-
-            var histories = await _service.ReadAsync(
-                envelopeId: envelopeId,
-                userReference: userReference,
-                referenceType: refTypEnum,
-                withSender: withSender,
-                withReceiver: withReceiver);
-
-            return Ok(histories);
-        }
+        return Ok(histories);
     }
 }