Mark callback-based variant as [Obsolete]

Add an informational note to clarify the usage of the callback-based variant of `StaticBuildConfiguration`. Highlight that it is marked as `[Obsolete]` with the message: "Use a local service collection instead of the static provider."

Emphasize that while the `StaticBuildConfiguration` variant is recommended within the static path, the static path itself remains a convenience API. Reference Chapter 6 for additional context.

ReC.sln

@@ -18,6 +18,7 @@ EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
 	ProjectSection(SolutionItems) = preProject
 		assets\icon.png = assets\icon.png
+		docs\ReC.Client.xwiki = docs\ReC.Client.xwiki
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "infrastructure", "infrastructure", "{3F88DACC-CEC0-4D9A-8BAA-37F67B02DC04}"
@@ -52,8 +53,8 @@ Global
 		{109645F5-441D-476B-B7D2-FBEAA8EBAE14}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{109645F5-441D-476B-B7D2-FBEAA8EBAE14}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{109645F5-441D-476B-B7D2-FBEAA8EBAE14}.Release|Any CPU.Build.0 = Release|Any CPU
-		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Debug|Any CPU.ActiveCfg = Release|Any CPU
+		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Debug|Any CPU.Build.0 = Release|Any CPU
 		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Release|Any CPU.Build.0 = Release|Any CPU
 		{457ED5AC-F4A0-41C3-9758-4A3C272EDC11}.Debug|Any CPU.ActiveCfg = Debug|Any CPU

docs/ReC.Client.xwiki

@@ -0,0 +1,556 @@
+== 1. Einleitung ==
+
+**ReC.Client** ist eine .NET-Client-Bibliothek für den typisierten und bequemen Zugriff auf die **ReC.API**. Anstatt direkt mit `HttpClient` zu arbeiten, bietet die Bibliothek thematisch geordnete API-Klassen (z. B. `RecActionApi`, `ResultApi`, `ProfileApi`, `EndpointAuthApi`, `EndpointParamsApi`, `EndpointsApi`, `CommonApi`) und integriert sich nahtlos in **Microsoft.Extensions.DependencyInjection**.
+
+Die Bibliothek unterstützt sowohl **.NET 8** als auch **.NET Framework 4.6.2** (Multi-Targeting).
+
+=== 1.1 Kernmerkmale ===
+
+* **DI-orientiert**: Registrierung über `services.AddRecClient(...)`.
+* **Typisierte API-Klassen**: jede Domäne hat eine eigene API-Klasse als Eigenschaft auf `ReCClient`.
+* **Konsistente Fehlerbehandlung**: Bei HTTP-Fehlerstatus wird einheitlich eine `ReCApiException` geworfen, inklusive Statuscode, Methode, URI, Body usw.
+* **Flexibles Lesen**: GET-Endpunkte unterstützen sowohl typisierte (`GetAsync<T>(...)`) als auch dynamische (`GetAsync(...)` ohne Typparameter, liefert `dynamic` / `JsonElement`) Abfragen.
+* **Optionen**: Logging und Verhalten lassen sich über `ReCClientOptions` steuern.
+
+== 2. Installation und Setup ==
+
+=== 2.1 Konfiguration mit Dependency Injection (empfohlen) ===
+
+Registrieren Sie den Client in `Program.cs` / `Startup.cs` über `AddRecClient`. Sie können entweder eine Basis-URL als String oder einen Konfigurations-Delegate für den zugrunde liegenden `HttpClient` übergeben.
+
+{{code language="vb.net"}}
+Imports Microsoft.Extensions.Hosting
+Imports Microsoft.Extensions.DependencyInjection
+Imports ReC.Client
+
+Module Program
+    Sub Main(args As String())
+        Dim builder = Host.CreateDefaultBuilder(args)
+
+        builder.ConfigureServices(
+            Sub(services)
+                ' Variante A: Basis-URL als String
+                services.AddRecClient("https://ihre-rec-api-adresse.com/")
+
+                ' Variante B: HttpClient feinkonfigurieren
+                ' services.AddRecClient(Sub(client)
+                '     client.BaseAddress = New Uri("https://ihre-rec-api-adresse.com/")
+                '     client.Timeout = TimeSpan.FromSeconds(30)
+                ' End Sub)
+            End Sub)
+
+        Dim app = builder.Build()
+        app.Run()
+    End Sub
+End Module
+{{/code}}
+
+{{code language="csharp"}}
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using ReC.Client;
+
+var builder = Host.CreateDefaultBuilder(args);
+builder.ConfigureServices(services =>
+{
+    // Variant A: base URL as string
+    services.AddRecClient("https://ihre-rec-api-adresse.com/");
+
+    // Variant B: configure HttpClient explicitly
+    // services.AddRecClient(client =>
+    // {
+    //     client.BaseAddress = new Uri("https://ihre-rec-api-adresse.com/");
+    //     client.Timeout = TimeSpan.FromSeconds(30);
+    // });
+});
+
+var app = builder.Build();
+app.Run();
+{{/code}}
+
+=== 2.2 Konstruktor-Injektion ===
+
+Sobald registriert, kann `ReCClient` per Konstruktor in jeden Dienst injiziert werden.
+
+{{code language="vb.net"}}
+Imports ReC.Client
+
+Public Class MeinDienst
+    Private ReadOnly _recClient As ReCClient
+
+    Public Sub New(recClient As ReCClient)
+        _recClient = recClient
+    End Sub
+End Class
+{{/code}}
+
+{{code language="csharp"}}
+using ReC.Client;
+
+public class MeinDienst
+{
+    private readonly ReCClient _recClient;
+
+    public MeinDienst(ReCClient recClient)
+    {
+        _recClient = recClient;
+    }
+}
+{{/code}}
+
+=== 2.3 Optionen über ReCClientOptions ===
+
+Über `ReCClientOptions` lässt sich das Verhalten des Clients steuern, z. B. ob erfolgreiche Anfragen geloggt werden sollen.
+
+{{code language="vb.net"}}
+services.AddRecClient("https://ihre-rec-api-adresse.com/")
+services.Configure(Of ReCClientOptions)(
+    Sub(opt)
+        opt.LogSuccessfulRequests = True
+    End Sub)
+{{/code}}
+
+{{code language="csharp"}}
+services.AddRecClient("https://ihre-rec-api-adresse.com/");
+services.Configure<ReCClientOptions>(opt =>
+{
+    opt.LogSuccessfulRequests = true;
+});
+{{/code}}
+
+{{warning}}
+Wenn `LogSuccessfulRequests = true` gesetzt, aber **kein** `ILogger` über DI registriert ist, wirft der `ReCClient`-Konstruktor eine `InvalidOperationException`. Stellen Sie sicher, dass ein Logging-Provider (z. B. `services.AddLogging(...)`) registriert ist, oder lassen Sie die Option auf `false`.
+{{/warning}}
+
+== 3. Überblick über die API-Klassen ==
+
+`ReCClient` bündelt mehrere thematische API-Klassen als Eigenschaften:
+
+* `RecActions` (`RecActionApi`) – Verwaltung und Auslösen von RecActions (CRUD + Invoke)
+* `Results` (`ResultApi`) – Lesen, Anlegen, Aktualisieren und Löschen von Result-Datensätzen
+* `Profiles` (`ProfileApi`) – Verwaltung der Profile
+* `EndpointAuth` (`EndpointAuthApi`) – Verwaltung der Endpoint-Authentifizierungsdaten
+* `EndpointParams` (`EndpointParamsApi`) – Verwaltung der Endpoint-Parameter
+* `Endpoints` (`EndpointsApi`) – Verwaltung der Endpoints
+* `Common` (`CommonApi`) – Gemeinsame Operationen, die nicht entitätsspezifisch sind
+
+Alle entitätsspezifischen Klassen erben von `BaseCrudApi` und bieten ein konsistentes CRUD-Schema.
+
+== 4. Verwendung ==
+
+=== 4.1 GET-Endpunkte: typisiert oder dynamisch ===
+
+Die GET-Methoden in `RecActionApi`, `ProfileApi` und `ResultApi` existieren jeweils als **zwei Overloads**:
+
+* **Generisch**: `GetAsync<T>(...)` – führt die Anfrage aus, liest den Response-Body **einmal** und deserialisiert ihn in den Typ `T`.
+* **Nicht-generisch**: `GetAsync(...)` – identische Parameterliste, gibt aber ein `dynamic` (in der Praxis `System.Text.Json.JsonElement`) zurück. Intern wird `GetAsync<object>(...)` aufgerufen.
+
+Beide Overloads teilen sich Implementierung und Fehlerbehandlung: bei HTTP-Fehlerstatus wird **`ReCApiException`** geworfen.
+
+{{info}}
+Da der nicht-generische Overload eine andere Signatur als der generische besitzt (kein Typparameter), gibt es **keinen Konflikt**. Welcher Overload aufgerufen wird, hängt davon ab, ob Sie einen Typparameter angeben oder nicht.
+{{/info}}
+
+==== 4.1.1 Typisiertes Lesen ====
+
+{{code language="vb.net"}}
+Imports ReC.Application.Common.Dto
+
+' Alle Actions für ein Profil als typisiertes Array
+Dim actions As RecActionViewDto() =
+    Await recClient.RecActions.GetAsync(Of RecActionViewDto())(profileId:=42)
+
+For Each a In actions
+    Console.WriteLine($"Action {a.Id} -> Endpoint {a.EndpointUri}")
+Next
+{{/code}}
+
+{{code language="csharp"}}
+using ReC.Application.Common.Dto;
+
+// All actions for a profile as a typed array
+var actions = await recClient.RecActions.GetAsync<RecActionViewDto[]>(profileId: 42);
+
+foreach (var a in actions!)
+{
+    Console.WriteLine($"Action {a.Id} -> Endpoint {a.EndpointUri}");
+}
+{{/code}}
+
+==== 4.1.2 Dynamisches Lesen ====
+
+Wenn das Schema flexibel ist oder Sie das Ergebnis nur weiterleiten möchten, können Sie den nicht-generischen Overload verwenden:
+
+{{code language="vb.net"}}
+Imports System.Text.Json
+
+Dim payload As Object = Await recClient.RecActions.GetAsync(profileId:=42)
+Dim element As JsonElement = CType(payload, JsonElement)
+
+If element.ValueKind = JsonValueKind.Array Then
+    For Each item In element.EnumerateArray()
+        Console.WriteLine(item.GetProperty("id").GetInt64())
+    Next
+End If
+{{/code}}
+
+{{code language="csharp"}}
+using System.Text.Json;
+
+dynamic? payload = await recClient.RecActions.GetAsync(profileId: 42);
+var element = (JsonElement)payload!;
+
+if (element.ValueKind == JsonValueKind.Array)
+{
+    foreach (var item in element.EnumerateArray())
+    {
+        Console.WriteLine(item.GetProperty("id").GetInt64());
+    }
+}
+{{/code}}
+
+=== 4.2 Eine RecAction auslösen (Invoke) ===
+
+`RecActionApi.InvokeAsync` startet die Stapelverarbeitung der Actions eines Profils. Es gibt zwei Overloads: einen mit `InvokeReferences`-Objekt und einen Komfort-Overload mit nur einer Batch-ID.
+
+{{code language="vb.net"}}
+Imports ReC.Client.Api
+
+Public Async Function FuehreProfilAktionenAus(recClient As ReCClient, profilId As Long) As Task
+    Try
+        Await recClient.RecActions.InvokeAsync(
+            profilId,
+            New InvokeReferences With {.BatchId = "batch-" & Guid.NewGuid().ToString("N")})
+    Catch ex As ReC.Client.ReCApiException
+        ' Auswertung von ex.StatusCode, ex.Method, ex.RequestUri, ex.ResponseBody
+        Throw
+    End Try
+End Function
+{{/code}}
+
+{{code language="csharp"}}
+using ReC.Client;
+using ReC.Client.Api;
+
+public async Task ExecuteProfileActionsAsync(ReCClient recClient, long profileId)
+{
+    try
+    {
+        await recClient.RecActions.InvokeAsync(
+            profileId,
+            new InvokeReferences { BatchId = $"batch-{Guid.NewGuid():N}" });
+    }
+    catch (ReCApiException ex)
+    {
+        // Inspect ex.StatusCode, ex.Method, ex.RequestUri, ex.ResponseBody
+        throw;
+    }
+}
+{{/code}}
+
+Komfort-Overload nur mit Batch-ID:
+
+{{code language="vb.net"}}
+Await recClient.RecActions.InvokeAsync(profilId, "batch-001")
+{{/code}}
+
+{{code language="csharp"}}
+await recClient.RecActions.InvokeAsync(profileId, "batch-001");
+{{/code}}
+
+=== 4.3 Anlegen, Aktualisieren, Löschen (CRUD) ===
+
+Alle CRUD-Operationen sind asynchron und werfen bei Fehlern eine `ReCApiException`.
+
+* `CreateAsync(payload)` – HTTP POST mit JSON-Body.
+* `UpdateAsync(id, payload)` – HTTP PUT auf `/{ResourcePath}/{id}` mit JSON-Body.
+* `DeleteAsync(payload)` – HTTP DELETE; das Payload wird in den **Query-String** serialisiert (die API bindet Delete-Parameter aus der URL).
+
+{{code language="vb.net"}}
+Imports ReC.Application.RecActions.Commands
+Imports ReC.Application.Common.Procedures.UpdateProcedure.Dto
+
+' POST
+Await recClient.RecActions.CreateAsync(New InsertActionCommand With {
+    .ProfileId = 1,
+    .EndpointId = 1,
+    .Active = True,
+    .Sequence = 1
+})
+
+' PUT
+Await recClient.RecActions.UpdateAsync(123, New UpdateActionDto With {
+    .Active = False,
+    .Sequence = 2
+})
+
+' DELETE (Payload wird zu Query-String)
+Await recClient.RecActions.DeleteAsync(New DeleteActionCommand With {
+    .Start = 100,
+    .End = 110,
+    .Force = False
+})
+{{/code}}
+
+{{code language="csharp"}}
+using ReC.Application.RecActions.Commands;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+// POST
+await recClient.RecActions.CreateAsync(new InsertActionCommand
+{
+    ProfileId = 1,
+    EndpointId = 1,
+    Active = true,
+    Sequence = 1
+});
+
+// PUT
+await recClient.RecActions.UpdateAsync(123, new UpdateActionDto
+{
+    Active = false,
+    Sequence = 2
+});
+
+// DELETE (payload becomes query string)
+await recClient.RecActions.DeleteAsync(new DeleteActionCommand
+{
+    Start = 100,
+    End = 110,
+    Force = false
+});
+{{/code}}
+
+=== 4.4 Fehlerbehandlung mit ReCApiException ===
+
+Sobald die API einen Statuscode außerhalb von 2xx zurückgibt, wirft die Bibliothek eine `ReCApiException`. Diese enthält folgende Informationen:
+
+* `StatusCode` – `HttpStatusCode` der Antwort (z. B. 404, 400, 500)
+* `ReasonPhrase` – Optionaler HTTP-Reason-Phrase
+* `ResponseBody` – Roher Response-Body als String (sofern lesbar)
+* `Method` – HTTP-Methode der ursprünglichen Anfrage (z. B. `GET`, `POST`)
+* `RequestUri` – Aufgerufene URI mit Pfad und Query
+
+{{code language="vb.net"}}
+Try
+    Dim profile = Await recClient.Profiles.GetAsync(Of ProfileViewDto)(id:=42)
+Catch ex As ReCApiException
+    If ex.StatusCode = Net.HttpStatusCode.NotFound Then
+        ' Profil existiert nicht
+    Else
+        ' Allgemeiner Fehler
+        Console.WriteLine($"{ex.Method} {ex.RequestUri} -> {ex.StatusCode}: {ex.ResponseBody}")
+        Throw
+    End If
+End Try
+{{/code}}
+
+{{code language="csharp"}}
+try
+{
+    var profile = await recClient.Profiles.GetAsync<ProfileViewDto>(id: 42);
+}
+catch (ReCApiException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+{
+    // Profile does not exist
+}
+catch (ReCApiException ex)
+{
+    Console.WriteLine($"{ex.Method} {ex.RequestUri} -> {ex.StatusCode}: {ex.ResponseBody}");
+    throw;
+}
+{{/code}}
+
+== 5. Testen ==
+
+Das Testprojekt verwendet `Microsoft.AspNetCore.Mvc.Testing`, um die `ReC.API` mit `WebApplicationFactory<Program>` **in-process** zu starten. Der `ReCClient` wird über DI konfiguriert und auf den in-process HTTP-Handler verdrahtet. So müssen Tests die API nicht extern starten.
+
+Empfehlungen:
+
+* Schreiben Sie Tests als `async Task` und verwenden Sie `await` – **vermeiden** Sie `GetAwaiter().GetResult()` oder `TaskSyncExtensions.Sync(...)`.
+* Verwenden Sie `Assert.ThrowsAsync<ReCApiException>(...)`, um Fehlerpfade zu prüfen, und werten Sie `StatusCode`, `Method` und `RequestUri` aus.
+* Für GET-Tests reicht eine einzelne Methode pro Verhalten (typisiert vs. dynamisch) statt redundanter Setups.
+
+== 6. Komfort-APIs: statischer Provider und synchrone Wrapper ==
+
+Neben dem empfohlenen DI-basierten Ansatz bietet **ReC.Client** absichtlich auch einen **statischen Komfort-Pfad** sowie **synchrone Wrapper** an. Diese Bestandteile sind nicht „veraltet im Sinne von eingefroren" – sie werden weiterhin gepflegt und bei Bedarf um neue Funktionen erweitert. Sie sind jedoch bewusst mit `[Obsolete]` markiert, damit Aufrufer sie nicht „aus Versehen" auswählen, sondern eine bewusste Entscheidung treffen.
+
+Hintergrund
+
+* In Projekten, die noch auf **.NET Framework 4.6.2** basieren, ist `Microsoft.Extensions.DependencyInjection` häufig nicht etabliert und die Einführung einer DI-Infrastruktur kostet Zeit. Damit Entwickler dort nicht ins Stocken geraten, gibt es einen statischen Einstieg, der **sofort einsatzbereit** ist.
+* Synchroner Code in älteren Codebasen kann nicht überall sofort auf `async/await` umgestellt werden. Für solche Stellen existieren die `Sync()`-Erweiterungen als pragmatische Brücke.
+
+Status
+
+* **Aktiv gepflegt**: Beide Pfade erhalten weiterhin Funktionalitäts- und Komfort-Updates.
+* **`[Obsolete]`-Markierung als Erinnerung**: Die Compiler-Warnung soll bewusst sichtbar bleiben, damit Teams die Übergangslösung nicht vergessen und mittelfristig zu DI + `async/await` migrieren.
+* **Kein Breaking-Change-Risiko**: Aufrufe bleiben kompilierbar und ausführbar.
+
+Wann der statische Pfad sinnvoll ist
+
+* Bestehender VB.NET-/C#-Code auf .NET Framework 4.6.2 ohne eigene DI-Infrastruktur.
+* Kleine Werkzeuge, Skripte oder Konsolenanwendungen, bei denen ein vollständiges Host-Setup übertrieben wäre.
+* Schneller Einstieg in die Bibliothek, um ein erstes Ergebnis zu sehen, bevor die endgültige Architektur entschieden wird.
+
+Wann besser DI verwenden
+
+* Lang laufende Prozesse, Serveranwendungen, Tests.
+* Sobald in der Anwendung ohnehin `IServiceCollection` / `IHostBuilder` vorhanden ist.
+* Wenn `HttpClient`-Lebenszyklen, Logging-Scopes oder Optionen sauber verwaltet werden sollen.
+
+=== 6.1 Statischer Client mit BuildStaticClient / Create ===
+
+`ReCClient.BuildStaticClient(...)` baut intern eine `IServiceCollection` auf, ruft `AddRecClient(...)` auf und legt einen **statischen, thread-safen `Lazy<IServiceProvider>`** an. Der eigentliche `IServiceProvider` wird **erst beim ersten Aufruf von `ReCClient.Create()`** und genau einmal gebaut.
+
+Wichtig:
+
+* `BuildStaticClient` darf **nur einmal** beim Anwendungsstart aufgerufen werden. Ein zweiter Aufruf – egal welcher Overload – wirft `InvalidOperationException("Static Provider is already built.")`.
+* Die Konstruktion des `IServiceProvider` ist **threadsicher** (`Lazy<T>` mit `LazyThreadSafetyMode.ExecutionAndPublication`).
+
+==== 6.1.1 Empfohlene Form: BuildStaticClient mit StaticBuildConfiguration ====
+
+Da der statische Pfad mehrere optionale Bestandteile hat (Basis-URL **oder** `HttpClient`-Konfiguration, `ReCClientOptions`, eigener `ILogger`, zusätzliche Service-Registrierungen), gibt es einen Callback-basierten Overload, der alle Optionen in einem `StaticBuildConfiguration`-Objekt bündelt:
+
+{{code language="vb.net"}}
+Imports Microsoft.Extensions.DependencyInjection
+Imports Microsoft.Extensions.Logging
+
+ReCClient.BuildStaticClient(
+    Sub(cfg)
+        cfg.BaseAddress = "https://ihre-rec-api-adresse.com/"
+
+        cfg.ConfigureOptions = Sub(opt)
+                                   opt.LogSuccessfulRequests = True
+                               End Sub
+
+        ' Optional: eigene zusätzliche Registrierungen, z. B. Logging-Provider
+        cfg.ConfigureServices = Sub(services)
+                                    services.AddLogging(Sub(b) b.AddConsole())
+                                End Sub
+    End Sub)
+{{/code}}
+
+{{code language="csharp"}}
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+
+ReCClient.BuildStaticClient(cfg =>
+{
+    cfg.BaseAddress = "https://ihre-rec-api-adresse.com/";
+
+    cfg.ConfigureOptions = opt =>
+    {
+        opt.LogSuccessfulRequests = true;
+    };
+
+    // Optional: additional service registrations, e.g. logging
+    cfg.ConfigureServices = services =>
+    {
+        services.AddLogging(b => b.AddConsole());
+    };
+});
+{{/code}}
+
+Eigenschaften von `StaticBuildConfiguration`:
+
+* `BaseAddress` – Basis-URI der ReC.API. **Schließt sich gegenseitig** mit `ConfigureClient` aus.
+* `ConfigureClient` – Delegate zum direkten Konfigurieren des `HttpClient` (z. B. `BaseAddress` + `Timeout` + Header). Schließt sich gegenseitig mit `BaseAddress` aus.
+* `ConfigureOptions` – Optionaler Delegate für `ReCClientOptions` (z. B. `LogSuccessfulRequests`).
+* `Logger` – Optionale `ILogger`-Instanz, die als Singleton in die interne `IServiceCollection` registriert wird.
+* `ConfigureServices` – Optionaler Delegate, mit dem der Aufrufer beliebige zusätzliche Registrierungen auf der internen `IServiceCollection` vornehmen kann (z. B. `AddLogging(...)` oder eigene Abhängigkeiten).
+
+Validierung beim Aufruf:
+
+* `BuildStaticClient` wirft `ArgumentNullException`, wenn der `configure`-Callback `null` ist.
+* `BuildStaticClient` wirft `InvalidOperationException`, wenn weder `BaseAddress` noch `ConfigureClient` gesetzt sind, **oder** wenn beide gleichzeitig gesetzt sind.
+
+{{info}}
+Auch diese callback-basierte Variante ist mit `[Obsolete]` markiert — der Hinweistext lautet hier jedoch *"Use a local service collection instead of the static provider."* Damit wird klargestellt, dass innerhalb des statischen Pfades die `StaticBuildConfiguration`-Variante die empfohlene Form ist, der statische Pfad als Ganzes aber weiterhin bewusst als Komfort-API gekennzeichnet bleibt (siehe Einleitung von Kapitel 6).
+{{/info}}
+
+Variante mit `HttpClient`-Feinkonfiguration:
+
+{{code language="vb.net"}}
+ReCClient.BuildStaticClient(
+    Sub(cfg)
+        cfg.ConfigureClient = Sub(http)
+                                  http.BaseAddress = New Uri("https://ihre-rec-api-adresse.com/")
+                                  http.Timeout = TimeSpan.FromSeconds(30)
+                              End Sub
+    End Sub)
+{{/code}}
+
+{{code language="csharp"}}
+ReCClient.BuildStaticClient(cfg =>
+{
+    cfg.ConfigureClient = http =>
+    {
+        http.BaseAddress = new Uri("https://ihre-rec-api-adresse.com/");
+        http.Timeout = TimeSpan.FromSeconds(30);
+    };
+});
+{{/code}}
+
+Nach dem `BuildStaticClient`-Aufruf liefert `ReCClient.Create()` Instanzen aus dem statischen Provider:
+
+{{code language="vb.net"}}
+Dim client As ReCClient = ReCClient.Create()
+Await client.RecActions.InvokeAsync(profilId, "batch-001")
+{{/code}}
+
+{{code language="csharp"}}
+var client = ReCClient.Create();
+await client.RecActions.InvokeAsync(profileId, "batch-001");
+{{/code}}
+
+==== 6.1.2 Ältere Komfort-Overloads ====
+
+Aus Bequemlichkeit existieren zwei weitere Overloads, die intern an die `StaticBuildConfiguration`-Variante delegieren. Sie sind als `Obsolete` markiert mit dem Hinweis, die `Action<StaticBuildConfiguration>`-Variante zu verwenden, bleiben aber funktionsfähig:
+
+{{code language="vb.net"}}
+' Variante mit Basis-URL als String
+ReCClient.BuildStaticClient("https://ihre-rec-api-adresse.com/")
+
+' Mit Options-Callback und optionalem Logger
+ReCClient.BuildStaticClient(
+    "https://ihre-rec-api-adresse.com/",
+    Sub(opt) opt.LogSuccessfulRequests = True,
+    myLogger)
+{{/code}}
+
+{{code language="csharp"}}
+// Variant with base URL string
+ReCClient.BuildStaticClient("https://ihre-rec-api-adresse.com/");
+
+// With options callback and optional logger
+ReCClient.BuildStaticClient(
+    "https://ihre-rec-api-adresse.com/",
+    opt => opt.LogSuccessfulRequests = true,
+    myLogger);
+{{/code}}
+
+=== 6.2 Synchrone Wrapper über TaskSyncExtensions ===
+
+`TaskSyncExtensions.Sync()` bzw. `Sync<TResult>()` blockieren den aktuellen Thread, bis die `Task` abgeschlossen ist. Sie sind nützlich, wenn der umliegende Code (noch) nicht asynchron sein kann.
+
+{{code language="vb.net"}}
+Imports ReC.Client
+
+' Blockiert bis die Task fertig ist
+recClient.RecActions.InvokeAsync(profilId, "batch-001").Sync()
+{{/code}}
+
+{{code language="csharp"}}
+using ReC.Client;
+
+// Blocks until the task completes
+recClient.RecActions.InvokeAsync(profileId, "batch-001").Sync();
+{{/code}}
+
+Hinweis: In Umgebungen mit einem `SynchronizationContext` (z. B. WinForms, WPF oder bestimmte Test-Runner) kann blockierendes Warten zu Deadlocks führen. Für Konsolen- und Hintergrundprozesse ist das Risiko in der Regel gering. Wo immer möglich: `async/await` bevorzugen.
+
+=== 6.3 Mittelfristige Empfehlung ===
+
+* **`BuildStaticClient` / `Create`**: für Legacy-Einstiege okay; sobald `IServiceCollection` vorhanden ist, auf `services.AddRecClient(...)` und Konstruktor-Injektion umstellen.
+* **`TaskSyncExtensions.Sync`**: nur lokal kapseln. Wenn eine Methode bereits `async` sein darf, direkt `await` verwenden.
+* Die `[Obsolete]`-Warnung dient als **dauerhafter Reminder**, dass es sich um einen bewussten Komfort-Pfad handelt – sie ist kein Hinweis darauf, dass die APIs entfernt werden.

src/ReC.API/Controllers/RecActionController.cs

@@ -13,14 +13,19 @@ public class RecActionController(IMediator mediator) : ControllerBase
     /// <summary>
     /// Invokes a batch of RecActions for a given profile.
     /// </summary>
-    /// <param name="command">The command containing the profile ID.</param>
+    /// <param name="profileId">The identifier of the profile whose RecActions should be invoked.</param>
+    /// <param name="references">Optional reference values that are passed through to all result records.</param>
     /// <param name="cancel">A token to cancel the operation.</param>
     /// <returns>An HTTP 202 Accepted response indicating the process has been started.</returns>
-    [HttpPost("invoke/{command}")]
+    [HttpPost("invoke/{profileId}")]
     [ProducesResponseType(StatusCodes.Status202Accepted)]
-    public async Task<IActionResult> Invoke([FromRoute] InvokeBatchRecActionViewsCommand command, CancellationToken cancel)
+    public async Task<IActionResult> Invoke([FromRoute] long profileId, [FromBody] InvokeReferences references, CancellationToken cancel = default)
     {
-        await mediator.Send(command, cancel);
+        await mediator.Send(new InvokeBatchRecActionViewsCommand
+        {
+            ProfileId = profileId,
+            References = references
+        }, cancel);
         return Accepted();
     }
 

src/ReC.API/Middleware/ExceptionHandlingMiddleware.cs

@@ -7,13 +7,11 @@ using System.Text.Json;
 
 namespace ReC.API.Middleware;
 
-//TODO: Fix and use DigitalData.Core.Exceptions.Middleware
 /// <summary>
 /// Middleware for handling exceptions globally in the application.
 /// Captures exceptions thrown during the request pipeline execution,
 /// logs them, and returns an appropriate HTTP response with a JSON error details.
 /// </summary>
-[Obsolete("Use DigitalData.Core.Exceptions.Middleware")]
 public class ExceptionHandlingMiddleware
 {
     private readonly RequestDelegate _next;
@@ -164,6 +162,22 @@ public class ExceptionHandlingMiddleware
                 };
                 break;
 
+            case RecActionException recActionEx:
+                logger.LogWarning(
+                    recActionEx,
+                    "Rec action failed. ActionId: {ActionId}, ProfileId: {ProfileId}",
+                    recActionEx.ActionId,
+                    recActionEx.ProfileId);
+
+                context.Response.StatusCode = (int)HttpStatusCode.UnprocessableEntity;
+                details = new()
+                {
+                    Title = "Rec Action Failed",
+                    Detail = recActionEx.InnerException?.Message
+                        ?? "An error occurred while executing the rec action. Check the logs for more details."
+                };
+                break;
+
             default:
                 logger.LogError(exception, "Unhandled exception occurred.");
                 context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;

src/ReC.API/Models/FakeRequest.cs

@@ -1,8 +0,0 @@
-namespace ReC.API.Models;
-
-public class FakeRequest
-{
-    public Dictionary<string, object>? Body { get; init; }
-
-    public Dictionary<string, object>? Header { get; init; }
-}

src/ReC.API/Models/ResultType.cs

@@ -1,17 +0,0 @@
-namespace ReC.API.Models;
-
-public enum ResultType
-{
-    /// <summary>
-    /// Return the full result object.
-    /// </summary>
-    Full,
-    /// <summary>
-    /// Return only the header part of the result.
-    /// </summary>
-    OnlyHeader,
-    /// <summary>
-    /// Return only the body part of the result.
-    /// </summary>
-    OnlyBody
-}

src/ReC.API/Program.cs

@@ -48,10 +48,13 @@ try
                                    ?? throw new InvalidOperationException("Connection string is not found.");
 
             var logger = provider.GetRequiredService<ILogger<RecDbContext>>();
+            var enableSensitiveDataLogging = config.GetValue("EfCore:EnableSensitiveDataLogging", true);
+            var enableDetailedErrors = config.GetValue("EfCore:EnableDetailedErrors", false);
+
             opt.UseSqlServer(cnnStr)
                     .LogTo(log => logger.LogInformation("{log}", log), LogLevel.Trace)
-                    .EnableSensitiveDataLogging()
-                    .EnableDetailedErrors();
+                    .EnableSensitiveDataLogging(enableSensitiveDataLogging)
+                    .EnableDetailedErrors(enableDetailedErrors);
         });
     });
 
@@ -70,9 +73,7 @@ try
 
     var app = builder.Build();
 
-#pragma warning disable CS0618
     app.UseMiddleware<ExceptionHandlingMiddleware>();
-#pragma warning restore CS0618
 
     // Configure the HTTP request pipeline.
     if (app.Environment.IsDevelopment() || config.GetValue<bool>("UseSwagger"))
@@ -97,3 +98,5 @@ catch(Exception ex)
     logger.Error(ex, "Stopped program because of exception");
     throw;
 }
+
+public partial class Program;

src/ReC.API/Properties/PublishProfiles/IISProfile.pubxml

@@ -9,7 +9,7 @@
     <LaunchSiteAfterPublish>true</LaunchSiteAfterPublish>
     <ExcludeApp_Data>false</ExcludeApp_Data>
     <ProjectGuid>420218ad-3c27-4003-9a84-36c92352f175</ProjectGuid>
-    <DesktopBuildPackageLocation>P:\Install .Net\0 DD - Smart UP\ReC\API\$(Version)\Rec.API.zip</DesktopBuildPackageLocation>	  
+    <DesktopBuildPackageLocation>M:\App&amp;Service\0 DD - Smart UP\ReC\API\$(Version)\Rec.API.zip</DesktopBuildPackageLocation>	  
     <PackageAsSingleFile>true</PackageAsSingleFile>
     <DeployIisAppPath>Rec.API</DeployIisAppPath>
     <_TargetId>IISWebDeployPackage</_TargetId>

src/ReC.API/ReC.API.csproj

@@ -10,10 +10,10 @@
 	<Product>ReC.API</Product>
 	<PackageIcon>Assets\icon.ico</PackageIcon>
 	<PackageTags>digital data rest-caller rec api</PackageTags>
-	<Version>2.0.2-beta</Version>
-	<AssemblyVersion>2.0.2.0</AssemblyVersion>
-	<FileVersion>2.0.2.0</FileVersion>
-	<InformationalVersion>2.0.1-beta</InformationalVersion>
+	<Version>2.4.0-beta</Version>
+	<AssemblyVersion>2.4.0.0</AssemblyVersion>
+	<FileVersion>2.4.0.0</FileVersion>
+	<InformationalVersion>2.4.0-beta</InformationalVersion>
 	<Copyright>Copyright © 2025 Digital Data GmbH. All rights reserved.</Copyright>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591</NoWarn>

src/ReC.API/appsettings.json

@@ -5,9 +5,13 @@
   },
   "AllowedHosts": "*",
   "LuckyPennySoftwareLicenseKey": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ikx1Y2t5UGVubnlTb2Z0d2FyZUxpY2Vuc2VLZXkvYmJiMTNhY2I1OTkwNGQ4OWI0Y2IxYzg1ZjA4OGNjZjkiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2x1Y2t5cGVubnlzb2Z0d2FyZS5jb20iLCJhdWQiOiJMdWNreVBlbm55U29mdHdhcmUiLCJleHAiOiIxNzg0ODUxMjAwIiwiaWF0IjoiMTc1MzM2MjQ5MSIsImFjY291bnRfaWQiOiIwMTk4M2M1OWU0YjM3MjhlYmZkMzEwM2MyYTQ4NmU4NSIsImN1c3RvbWVyX2lkIjoiY3RtXzAxazB5NmV3MmQ4YTk4Mzg3aDJnbTRuOWswIiwic3ViX2lkIjoiLSIsImVkaXRpb24iOiIwIiwidHlwZSI6IjIifQ.ZqsFG7kv_-xGfxS6ACk3i0iuNiVUXX2AvPI8iAcZ6-z2170lGv__aO32tWpQccD9LCv5931lBNLWSblKS0MT3gOt-5he2TEftwiSQGFwoIBgtOHWsNRMinUrg2trceSp3IhyS3UaMwnxZDrCvx4-0O-kpOzVpizeHUAZNr5U7oSCWO34bpKdae6grtM5e3f93Z1vs7BW_iPgItd-aLvPwApbaG9VhmBTKlQ7b4Jh64y7UXJ9mKP7Qb_Oa97oEg0oY5DPHOWTZWeE1EzORgVr2qkK2DELSHuZ_EIUhODojkClPNAKtvEl_qEjpq0HZCIvGwfCCRlKlSkQqIeZdFkiXg",
+  "EfCore": {
+    "EnableSensitiveDataLogging": true,
+    "EnableDetailedErrors": false
+  },
   "RecAction": {
-    "AddedWho": "ReC.API",
-    "UseHttp1ForNtlm": false
+    "UseHttp1ForNtlm": false,
+    "AutoDetectHeaders": false
   },
   // Bad request SqlException numbers numbers can be updated at runtime; no restart required.
   "SqlException": {

src/ReC.Application/Common/Behaviors/Action/BodyQueryBehavior.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Application.Common.Dto;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Interfaces;
+
+namespace ReC.Application.Common.Behaviors.Action;
+
+public class BodyQueryBehavior<TRequest, TResponse>(IRecDbContext dbContext) : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : notnull
+    where TResponse : IEnumerable<RecActionViewDto>
+{
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)
+    {
+        var actions = await next(cancel);
+
+        foreach (var action in actions)
+            await SetBody(action, cancel);
+
+        return actions;
+    }
+
+    private async Task SetBody(RecActionViewDto action, CancellationToken cancel)
+    {
+        if (action.BodyQuery is not string bodyQuery)
+            return;
+
+        await using var command = dbContext.Database.GetDbConnection().CreateCommand();
+        command.CommandText = bodyQuery;
+
+        await dbContext.Database.OpenConnectionAsync(cancel);
+        try
+        {
+            object? scalar;
+            try
+            {
+                scalar = await command.ExecuteScalarAsync(cancel);
+            }
+            catch (Exception ex)
+            {
+                throw new DataIntegrityException(
+                    $"Body query execution failed. The stored SQL may be malformed. ActionId: {action.Id}, ProfileId: {action.ProfileId}, Error: {ex.Message}");
+            }
+
+            action.Body = scalar as string
+                ?? throw new DataIntegrityException(
+                    $"Body query returned no result or a null value. ActionId: {action.Id}, ProfileId: {action.ProfileId}");
+        }
+        finally
+        {
+            await dbContext.Database.CloseConnectionAsync();
+        }
+    }
+}

src/ReC.Application/Common/Behaviors/Action/HeaderQueryBehavior.cs

@@ -0,0 +1,61 @@
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Application.Common.Dto;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Interfaces;
+using System.Text.Json;
+
+namespace ReC.Application.Common.Behaviors.Action;
+
+public class HeaderQueryBehavior<TRequest, TResponse>(IRecDbContext dbContext) : IPipelineBehavior<TRequest, TResponse>
+    where TRequest : notnull
+    where TResponse : IEnumerable<RecActionViewDto>
+{
+    public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)
+    {
+        var actions = await next(cancel);
+
+        foreach (var action in actions)
+            await SetHeader(action, cancel);
+
+        return actions;
+    }
+
+    private async Task SetHeader(RecActionViewDto action, CancellationToken cancel)
+    {
+        if (action.HeaderQuery is not string headerQuery)
+            return;
+
+        await using var command = dbContext.Database.GetDbConnection().CreateCommand();
+        command.CommandText = headerQuery;
+
+        await dbContext.Database.OpenConnectionAsync(cancel);
+        try
+        {
+            object? scalar;
+            try
+            {
+                scalar = await command.ExecuteScalarAsync(cancel);
+            }
+            catch (Exception ex)
+            {
+                throw new DataIntegrityException(
+                    $"Header query execution failed. The stored SQL may be malformed. ActionId: {action.Id}, ProfileId: {action.ProfileId}, Error: {ex.Message}");
+            }
+
+            if (scalar is not string rawHeader)
+                throw new DataIntegrityException(
+                    $"Header query returned no result or a null value. ActionId: {action.Id}, ProfileId: {action.ProfileId}");
+
+            var headerDict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(rawHeader)
+                ?? throw new DataIntegrityException(
+                    $"Header query returned invalid JSON. ActionId: {action.Id}, ProfileId: {action.ProfileId}");
+
+            action.Headers = headerDict.ToDictionary(header => header.Key, kvp => kvp.Value.ToString());
+        }
+        finally
+        {
+            await dbContext.Database.CloseConnectionAsync();
+        }
+    }
+}

src/ReC.Application/Common/Behaviors/BodyQueryBehavior.cs

@@ -1,23 +0,0 @@
-using MediatR;
-using ReC.Application.Common.Dto;
-using ReC.Application.Common.Interfaces;
-using Microsoft.EntityFrameworkCore;
-
-namespace ReC.Application.Common.Behaviors;
-
-public class BodyQueryBehavior<TRequest, TResponse>(IRecDbContext dbContext) : IPipelineBehavior<TRequest, TResponse>
-    where TRequest : RecActionViewDto
-    where TResponse : notnull
-{
-    public async Task<TResponse> Handle(TRequest action, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)
-    {
-        if (action.BodyQuery is null)
-            return await next(cancel);
-
-        var result = await dbContext.BodyQueryResults.FromSqlRaw(action.BodyQuery).SingleOrDefaultAsync(cancel);
-
-        action.Body = result?.RawBody;
-
-        return await next(cancel);
-    }
-}

src/ReC.Application/Common/Behaviors/HeaderQueryBehavior.cs

@@ -1,43 +0,0 @@
-using MediatR;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using ReC.Application.Common.Dto;
-using ReC.Application.Common.Interfaces;
-using System.Text.Json;
-
-namespace ReC.Application.Common.Behaviors;
-
-public class HeaderQueryBehavior<TRequest, TResponse>(IRecDbContext dbContext, ILogger<HeaderQueryBehavior<TRequest, TResponse>>? logger = null) : IPipelineBehavior<TRequest, TResponse>
-    where TRequest : RecActionViewDto
-    where TResponse : notnull
-{
-    public async Task<TResponse> Handle(TRequest action, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)
-    {
-        if (action.HeaderQuery is null)
-            return await next(cancel);
-
-        var result = await dbContext.HeaderQueryResults.FromSqlRaw(action.HeaderQuery).SingleOrDefaultAsync(cancel);
-
-        if (result?.RawHeader is null)
-        {
-            logger?.LogWarning("Header query did not return a result or returned a null REQUEST_HEADER. Profile ID: {ProfileId}, Action ID: {Id}", action.ProfileId, action.Id);
-
-            return await next(cancel);
-        }
-
-        var headerDict = JsonSerializer.Deserialize<Dictionary<string, JsonElement>>(result.RawHeader);
-
-        if(headerDict is null)
-        {
-            logger?.LogWarning(
-                "Header JSON deserialization returned null. RawHeader: {RawHeader}, ProfileId: {ProfileId}, Id: {Id}",
-                result.RawHeader, action.ProfileId, action.Id);
-
-            return await next(cancel);
-        }
-
-        action.Headers = headerDict.ToDictionary(header => header.Key, kvp => kvp.Value.ToString());
-
-        return await next(cancel);
-    }
-}

src/ReC.Application/Common/Behaviors/InvokeAction/PostprocessingBehavior.cs

@@ -1,11 +1,12 @@
 using MediatR;
+using ReC.Application.Common.Exceptions;
 using ReC.Application.Common.Interfaces;
 using ReC.Application.RecActions.Commands;
 using ReC.Application.Results.Commands;
 using ReC.Domain.Constants;
 using System.Text.Json;
 
-namespace ReC.Application.Common.Behaviors.Action;
+namespace ReC.Application.Common.Behaviors.InvokeAction;
 
 public class PostprocessingBehavior(IRecDbContext context, ISender sender) : IPipelineBehavior<InvokeRecActionViewCommand, Unit>
 {
@@ -22,8 +23,11 @@ public class PostprocessingBehavior(IRecDbContext context, ISender sender) : IPi
 
                 await sender.Send(new InsertResultCommand()
                 {
+                    Status = RecStatus.OK,
                     ActionId = request.Action.Id,
-                    Info = info
+                    InfoDetail = info,
+                    Type = ResultType.Post,
+                    References = request.References
                 }, cancel);
             }
         }
@@ -33,12 +37,15 @@ public class PostprocessingBehavior(IRecDbContext context, ISender sender) : IPi
 
             await sender.Send(new InsertResultCommand()
             {
+                Status = RecStatus.Error,
                 ActionId = request.Action.Id,
-                Error = error
+                Error = error,
+                Type = ResultType.Post,
+                References = request.References
             }, cancel);
 
             if (request.Action.ErrorAction == ErrorAction.Stop)
-                throw;
+                throw new RecActionException(request.Action.Id, request.Action.ProfileId, ex);
         }
 
         return Unit.Value;

src/ReC.Application/Common/Behaviors/InvokeAction/PreprocessingBehavior.cs

@@ -1,11 +1,12 @@
 using MediatR;
+using ReC.Application.Common.Exceptions;
 using ReC.Application.Common.Interfaces;
 using ReC.Application.RecActions.Commands;
 using ReC.Application.Results.Commands;
 using ReC.Domain.Constants;
 using System.Text.Json;
 
-namespace ReC.Application.Common.Behaviors.Action;
+namespace ReC.Application.Common.Behaviors.InvokeAction;
 
 public class PreprocessingBehavior(IRecDbContext context, ISender sender) : IPipelineBehavior<InvokeRecActionViewCommand, Unit>
 {
@@ -19,8 +20,11 @@ public class PreprocessingBehavior(IRecDbContext context, ISender sender) : IPip
 
                 await sender.Send(new InsertResultCommand()
                 {
+                    Status = RecStatus.OK,
                     ActionId = request.Action.Id,
-                    Info = JsonSerializer.Serialize(result)
+                    InfoDetail = JsonSerializer.Serialize(result),
+                    Type = ResultType.Pre,
+                    References = request.References
                 }, cancel);
             }
         }
@@ -28,12 +32,15 @@ public class PreprocessingBehavior(IRecDbContext context, ISender sender) : IPip
         {
             await sender.Send(new InsertResultCommand()
             {
+                Status = RecStatus.Error,
                 ActionId = request.Action.Id,
-                Error = ex.ToString()
+                Error = ex.ToString(),
+                Type = ResultType.Pre,
+                References = request.References
             }, cancel);
 
             if (request.Action.ErrorAction == ErrorAction.Stop)
-                throw;
+                throw new RecActionException(request.Action.Id, request.Action.ProfileId, ex);
         }
 
         return await next(cancel);

src/ReC.Application/Common/Dto/ConnectionDto.cs

@@ -1,32 +0,0 @@
-namespace ReC.Application.Common.Dto;
-
-public record ConnectionDto
-{
-    public short? Id { get; set; }
-
-    public string? Bezeichnung { get; set; }
-
-    public string? SqlProvider { get; set; }
-
-    public string? Server { get; set; }
-
-    public string? Datenbank { get; set; }
-
-    public string? Username { get; set; }
-
-    public string? Password { get; set; }
-
-    public string? Bemerkung { get; set; }
-
-    public bool? Aktiv { get; set; }
-
-    public string? ErstelltWer { get; set; }
-
-    public DateTime? ErstelltWann { get; set; }
-
-    public string? GeandertWer { get; set; }
-
-    public DateTime? GeaendertWann { get; set; }
-
-    public bool? SysConnection { get; set; }
-}

src/ReC.Application/Common/Dto/DtoMappingProfile.cs

@@ -1,4 +1,4 @@
-using ReC.Domain.Views;
+using ReC.Domain.Views;
 
 namespace ReC.Application.Common.Dto;
 
@@ -6,7 +6,12 @@ public class DtoMappingProfile : AutoMapper.Profile
 {
     public DtoMappingProfile()
     {
-        CreateMap<RecActionView, RecActionViewDto>();
+        CreateMap<RecActionView, RecActionViewDto>()
+            .ForMember(dest => dest.PreprocessingQuery, opt => opt.MapFrom((src, _) =>
+                src.PreprocessingQuery?.ReplacePlaceholders(src)))
+            .ForMember(dest => dest.PostprocessingQuery, opt => opt.MapFrom((src, _) =>
+                src.PostprocessingQuery?.ReplacePlaceholders(src)));
+
         CreateMap<ResultView, ResultViewDto>();
         CreateMap<ProfileView, ProfileViewDto>();
     }

src/ReC.Application/Common/Dto/EndpointAuthDto.cs

@@ -1,39 +0,0 @@
-using ReC.Domain.Constants;
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-public record EndpointAuthDto
-{
-    public long? Id { get; set; }
-
-    public bool? Active { get; set; }
-
-    public string? Description { get; set; }
-
-    public EndpointAuthType? Type { get; set; }
-
-    public string? ApiKey { get; set; }
-
-    public string? ApiValue { get; set; }
-
-    public ApiKeyLocation? ApiKeyAddTo { get; set; }
-
-    public string? Token { get; set; }
-
-    public string? Username { get; set; }
-
-    public string? Password { get; set; }
-
-    public string? Domain { get; set; }
-
-    public string? Workstation { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

src/ReC.Application/Common/Dto/EndpointDto.cs

@@ -1,22 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-public record EndpointDto
-{
-    public long Id { get; set; }
-
-    public bool? Active { get; set; }
-
-    public string? Description { get; set; }
-
-    public string? Uri { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

src/ReC.Application/Common/Dto/EndpointParamDto.cs

@@ -1,33 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-/// <summary>
-/// Represents the TBREC_CFG_ENDPOINT_PARAMS table.
-/// All properties are nullable to provide flexibility on the database side,
-/// preventing breaking changes if columns are altered to be nullable in production.
-/// </summary>
-public record EndpointParamDto
-{
-    public long? Id { get; set; }
-
-    public bool? Active { get; set; }
-
-    public string? Description { get; set; }
-
-    public short? GroupId { get; set; }
-
-    public byte? Sequence { get; set; }
-
-    public string? Key { get; set; }
-
-    public string? Value { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

src/ReC.Application/Common/Dto/OutResDto.cs

@@ -1,24 +0,0 @@
-namespace ReC.Application.Common.Dto;
-
-public record OutResDto
-{
-    public long Id { get; set; }
-
-    public long ActionId { get; set; }
-
-    public string? Header { get; set; }
-
-    public string? Body { get; set; }
-
-    public string? Info { get; set; }
-
-    public string? Error { get; set; }
-
-    public string AddedWho { get; set; } = null!;
-
-    public DateTime AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

src/ReC.Application/Common/Dto/PlaceholderExtensions.cs

@@ -0,0 +1,60 @@
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace ReC.Application.Common.Dto;
+
+public static partial class PlaceholderExtensions
+{
+    [GeneratedRegex(@"\{#[^#]+#[^}]+\}")]
+    private static partial Regex PlaceholderRegex();
+
+    /// <summary>
+    /// Replaces placeholders in the format <c>{#ANY_STRING#COLUMN_NAME}</c> with the corresponding
+    /// property value resolved via <see cref="GetValueByColumnName{T}"/> from the provided objects.
+    /// Values are converted to SQL-compatible string representations.
+    /// If a placeholder cannot be resolved, it is replaced with <c>NULL</c>.
+    /// </summary>
+    public static string ReplacePlaceholders(this string str, params object?[] objects)
+    {
+        return PlaceholderRegex().Replace(str, match =>
+        {
+            var placeholder = match.Value;
+            var inner = placeholder[2..^1]; // remove {# and }
+            var lastHash = inner.LastIndexOf('#');
+            var columnName = inner[(lastHash + 1)..];
+
+            foreach (var obj in objects)
+            {
+                if (obj is null)
+                    continue;
+
+                var value = obj.GetValueByColumnName(columnName);
+                if (value is not null)
+                    return ToSqlLiteral(value);
+            }
+
+            return "NULL";
+        });
+    }
+
+    private static string ToSqlLiteral(object value) => value switch
+    {
+        bool b => b ? "TRUE" : "FALSE",
+        DateTime dt => dt.ToString("yyyy-MM-dd HH:mm:ss"),
+        DateTimeOffset dto => dto.ToString("yyyy-MM-dd HH:mm:ss zzz"),
+        _ => value.ToString() ?? string.Empty
+    };
+
+    /// <summary>
+    /// Gets the value of a property by its column name defined in <see cref="ColumnAttribute"/>.
+    /// Returns <c>null</c> if no property with the given column name exists.
+    /// </summary>
+    public static object? GetValueByColumnName<T>(this T obj, string columnName) where T : class
+    {
+        var property = obj.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
+            .FirstOrDefault(p => p.GetCustomAttribute<ColumnAttribute>()?.Name == columnName);
+
+        return property?.GetValue(obj);
+    }
+}

src/ReC.Application/Common/Dto/ProfileDto.cs

@@ -1,30 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-public record ProfileDto
-{
-    public long Id { get; set; }
-
-    public bool? Active { get; set; }
-
-    public string? Type { get; set; }
-
-    public string? Mandantor { get; set; }
-
-    public string? Name { get; set; }
-
-    public string? Description { get; set; }
-
-    public string? LogLevel { get; set; }
-
-    public string? Language { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

src/ReC.Application/Common/Dto/RecActionDto.cs

@@ -1,53 +0,0 @@
-using ReC.Domain.Constants;
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-public record RecActionDto
-{
-    public long? Id { get; set; }
-
-    public long? ProfileId { get; set; }
-
-    public ProfileDto? Profile { get; set; }
-
-    public bool? Active { get; set; }
-
-    public byte? Sequence { get; set; }
-
-    public long? EndpointId { get; set; }
-
-    public EndpointDto? Endpoint { get; set; }
-
-    public long? EndpointAuthId { get; set; }
-
-    public EndpointAuthDto? EndpointAuth { get; set; }
-
-    public short? EndpointParamsId { get; set; }
-
-    public short? SqlConnectionId { get; set; }
-
-    public ConnectionDto? SqlConnection { get; set; }
-
-    public string? Type { get; set; }
-
-    public string? PreprocessingQuery { get; set; }
-
-    public string? HeaderQuery { get; set; }
-
-    public string? BodyQuery { get; set; }
-
-    public string? PostprocessingQuery { get; set; }
-
-    public ErrorAction? ErrorAction { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-
-    public OutResDto? OutRes { get; set; }
-}

src/ReC.Application/Common/Dto/RecActionViewDto.cs

@@ -8,6 +8,8 @@ public record RecActionViewDto
 
     public long? ProfileId { get; init; }
 
+    public ProfileViewDto? Profile { get; init; }
+
     public string? ProfileName { get; init; }
 
     public ProfileType? ProfileType { get; init; }

src/ReC.Application/Common/Dto/ResultViewDto.cs

@@ -1,11 +1,11 @@
-namespace ReC.Application.Common.Dto;
+using ReC.Domain.Constants;
+
+namespace ReC.Application.Common.Dto;
 
 public record ResultViewDto
 {
     public long Id { get; init; }
 
-    public OutResDto? Root { get; init; }
-
     public long? ActionId { get; init; }
 
     public RecActionViewDto? Action { get; init; }
@@ -16,7 +16,7 @@ public record ResultViewDto
 
     public string? ProfileName { get; init; }
 
-    public short? StatusCode { get; init; }
+    public RecStatus Status { get; set; }
 
     public string? StatusName { get; init; }
 
@@ -24,6 +24,14 @@ public record ResultViewDto
 
     public string? Body { get; init; }
 
+    public string? Info { get; set; }
+
+    public string? InfoDetail { get; set; }
+
+    public string? Error { get; set; }
+
+    public string? BatchId { get; set; }
+
     public string? AddedWho { get; init; }
 
     public DateTime? AddedWhen { get; init; }

src/ReC.Application/Common/Exceptions/RecActionException.cs

@@ -0,0 +1,9 @@
+namespace ReC.Application.Common.Exceptions;
+
+public class RecActionException(long actionId, long? profileId, Exception innerException) 
+    : Exception($"Rec action failed. ActionId: {actionId}, ProfileId: {profileId}", innerException)
+{
+    public long ActionId { get; } = actionId;
+
+    public long? ProfileId { get; } = profileId;
+}

src/ReC.Application/Common/Options/RecActionOptions.cs

@@ -2,7 +2,6 @@
 
 public class RecActionOptions
 {
-    public string AddedWho { get; set; } = null!;
-
     public bool UseHttp1ForNtlm { get; set; } = false;
+    public bool AutoDetectHeaders { get; set; } = false;
 }

src/ReC.Application/Common/Procedures/DeleteProcedure/DeleteObjectProcedure.cs

@@ -11,9 +11,9 @@ namespace ReC.Application.Common.Procedures.DeleteProcedure;
 public record DeleteObjectProcedure : IRequest<int>
 {
     /// <summary>
-    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// Target entity for the delete operation.
     /// </summary>
-    public string Entity { get; set; } = null!;
+    public required EntityType Entity { get; set; }
 
     /// <summary>
     /// Start GUID/ID (inclusive)
@@ -35,25 +35,16 @@ public class DeleteObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlE
 {
     public async Task<int> Handle(DeleteObjectProcedure request, CancellationToken cancel)
     {
-        var parameters = new[]
-        {
-            new SqlParameter("@pENTITY", request.Entity ?? (object)DBNull.Value),
-            new SqlParameter("@pSTART", request.Start.ToString()),
-            new SqlParameter("@pEND", request.End.ToString()),
-            new SqlParameter("@pFORCE", (object?)request.Force ?? DBNull.Value)
-        };
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_DELETE_OBJECT]", "RC")
+            .Add("pENTITY", request.Entity)
+            .Add("pSTART", request.Start.ToString())
+            .Add("pEND", request.End.ToString())
+            .Add("pFORCE", request.Force);
 
         try
         {
-            var result = await repo.ExecuteQueryRawAsync(
-                "DECLARE @RC SMALLINT = 0; " +
-                "EXEC @RC = [dbo].[PRREC_DELETE_OBJECT] " +
-                "@pENTITY, @pSTART, @pEND, @pFORCE; " +
-                "SELECT @RC;",
-                parameters,
-                cancel);
+            var result = await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
 
-            // The stored procedure returns 0 on success, error codes > 0 on failure
             if (result > 0)
             {
                 throw new DeleteObjectFailedException(request, $"DeleteObject stored procedure failed with error code: {result}");

src/ReC.Application/Common/Procedures/EntityType.cs

@@ -0,0 +1,51 @@
+namespace ReC.Application.Common.Procedures;
+
+/// <summary>
+/// Represents the target entity type for stored procedure operations (Insert, Update, Delete).
+/// </summary>
+public enum EntityType
+{
+    /// <summary>
+    /// A scheduled or configured action within a profile that invokes an endpoint (maps to TBREC_CFG_ACTION).
+    /// </summary>
+    Action,
+
+    /// <summary>
+    /// A REST endpoint URI configuration (maps to TBREC_CFG_ENDPOINT).
+    /// </summary>
+    Endpoint,
+
+    /// <summary>
+    /// Authentication credentials for an endpoint such as API key, Bearer token, or NTLM (maps to TBREC_CFG_ENDPOINT_AUTH).
+    /// </summary>
+    EndpointAuth,
+
+    /// <summary>
+    /// Key-value parameters attached to an endpoint (maps to TBREC_CFG_ENDPOINT_PARAMS).
+    /// </summary>
+    EndpointParams,
+
+    /// <summary>
+    /// A profile that groups one or more actions and defines execution settings (maps to TBREC_CFG_PROFILE).
+    /// </summary>
+    Profile,
+
+    /// <summary>
+    /// The outcome of an action invocation including HTTP status, headers, body, and error details (maps to TBREC_OUT_RESULT).
+    /// </summary>
+    Result
+}
+
+public static class EntityTypeExtensions
+{
+    public static string ToDbString(this EntityType entityType) => entityType switch
+    {
+        EntityType.Action => "ACTION",
+        EntityType.Endpoint => "ENDPOINT",
+        EntityType.EndpointAuth => "ENDPOINT_AUTH",
+        EntityType.EndpointParams => "ENDPOINT_PARAMS",
+        EntityType.Profile => "PROFILE",
+        EntityType.Result => "RESULT",
+        _ => throw new ArgumentOutOfRangeException(nameof(entityType), $"Not expected entity type value: {entityType}")
+    };
+}

src/ReC.Application/Common/Procedures/InsertProcedure/InsertObjectProcedure.cs

@@ -11,112 +11,95 @@ using ReC.Application.Endpoints.Commands;
 using ReC.Application.Profile.Commands;
 using ReC.Application.RecActions.Commands;
 using ReC.Application.Results.Commands;
+using System.Data;
 
 namespace ReC.Application.Common.Procedures.InsertProcedure;
 
 public record InsertObjectProcedure : IRequest<long>
 {
     /// <summary>
-    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// Target entity for the insert operation.
     /// </summary>
-    public string Entity { get; set; } = null!;
+    public required EntityType Entity { get; set; }
 
     //TODO: update to set in authentication middleware or similar, and remove from procedure properties
     internal string? AddedWho { get; private set; } = "ReC.API";
 
-    public InsertActionCommand Action { get; set; } = new();
-    public InsertEndpointCommand Endpoint { get; set; } = new();
-    public InsertEndpointAuthCommand EndpointAuth { get; set; } = new();
-    public InsertProfileCommand Profile { get; set; } = new();
-    public InsertResultCommand Result { get; set; } = new();
-    public InsertEndpointParamsCommand EndpointParams { get; set; } = new();
+    public InsertActionCommand? Action { get; set; }
+    public InsertEndpointCommand? Endpoint { get; set; }
+    public InsertEndpointAuthCommand? EndpointAuth { get; set; }
+    public InsertProfileCommand? Profile { get; set; }
+    public InsertResultCommand? Result { get; set; }
+    public InsertEndpointParamsCommand? EndpointParams { get; set; }
 }
 
 public class InsertObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<InsertObjectProcedure, long>
 {
     public async Task<long> Handle(InsertObjectProcedure request, CancellationToken cancel)
     {
-        var parameters = new[]
-        {
-            new SqlParameter("@pENTITY", request.Entity ?? (object)DBNull.Value),
-
-            new SqlParameter("@pADDED_WHO", (object?)request.AddedWho ?? DBNull.Value),
-            new SqlParameter("@pADDED_WHEN", (object?)DateTime.UtcNow ?? DBNull.Value),
-
-            new SqlParameter("@pACTION_PROFILE_ID", (object?)request.Action.ProfileId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ACTIVE", (object?)request.Action.Active ?? DBNull.Value),
-            new SqlParameter("@pACTION_SEQUENCE", (object?)request.Action.Sequence ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_ID", (object?)request.Action.EndpointId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_AUTH_ID", (object?)request.Action.EndpointAuthId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_PARAMS_ID", (object?)request.Action.EndpointParamsId ?? DBNull.Value),
-            new SqlParameter("@pACTION_SQL_CONNECTION_ID", (object?)request.Action.SqlConnectionId ?? DBNull.Value),
-            new SqlParameter("@pACTION_TYPE_ID", (object?)(byte?)request.Action.TypeId ?? DBNull.Value),
-            new SqlParameter("@pACTION_PRE_SQL", (object?)request.Action.PreSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_HEADER_SQL", (object?)request.Action.HeaderSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_BODY_SQL", (object?)request.Action.BodySql ?? DBNull.Value),
-            new SqlParameter("@pACTION_POST_SQL", (object?)request.Action.PostSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_ERROR_ACTION_ID", (object?)request.Action.ErrorActionId ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_ACTIVE", (object?)request.Endpoint.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_DESCRIPTION", (object?)request.Endpoint.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_URI", (object?)request.Endpoint.Uri ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_AUTH_ACTIVE", (object?)request.EndpointAuth.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_DESCRIPTION", (object?)request.EndpointAuth.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_TYPE_ID", (object?)request.EndpointAuth.TypeId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_KEY", (object?)request.EndpointAuth.ApiKey ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_VALUE", (object?)request.EndpointAuth.ApiValue ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_KEY_ADD_TO_ID", (object?)request.EndpointAuth.ApiKeyAddToId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_TOKEN", (object?)request.EndpointAuth.Token ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_USERNAME", (object?)request.EndpointAuth.Username ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_PASSWORD", (object?)request.EndpointAuth.Password ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_DOMAIN", (object?)request.EndpointAuth.Domain ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_WORKSTATION", (object?)request.EndpointAuth.Workstation ?? DBNull.Value),
-
-            new SqlParameter("@pPROFILE_ACTIVE", (object?)request.Profile.Active ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_TYPE_ID", (object?)request.Profile.TypeId ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_MANDANTOR", (object?)request.Profile.Mandantor ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_NAME", (object?)request.Profile.Name ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_DESCRIPTION", (object?)request.Profile.Description ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LOG_LEVEL_ID", (object?)request.Profile.LogLevelId ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LANGUAGE_ID", (object?)request.Profile.LanguageId ?? DBNull.Value),
-
-            new SqlParameter("@pRESULT_ACTION_ID", (object?)request.Result.ActionId ?? DBNull.Value),
-            new SqlParameter("@pRESULT_STATUS_ID", (object?)request.Result.StatusId ?? DBNull.Value),
-            new SqlParameter("@pRESULT_HEADER", (object?)request.Result.Header ?? DBNull.Value),
-            new SqlParameter("@pRESULT_BODY", (object?)request.Result.Body ?? DBNull.Value),
-            new SqlParameter("@pRESULT_INFO", (object?)request.Result.Info ?? DBNull.Value),
-            new SqlParameter("@pRESULT_ERROR", (object?)request.Result.Error ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_PARAMS_ACTIVE", (object?)request.EndpointParams.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_DESCRIPTION", (object?)request.EndpointParams.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_GROUP_ID", (object?)request.EndpointParams.GroupId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_SEQUENCE", (object?)request.EndpointParams.Sequence ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_KEY", (object?)request.EndpointParams.Key ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_VALUE", (object?)request.EndpointParams.Value ?? DBNull.Value),
-
-            new SqlParameter
-            {
-                ParameterName = "@oGUID",
-                SqlDbType = System.Data.SqlDbType.BigInt,
-                Direction = System.Data.ParameterDirection.Output
-            }
-        };
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_INSERT_OBJECT]")
+            .Add("pENTITY", request.Entity)
+            .Add("pADDED_WHO", request.AddedWho)
+            .Add("pADDED_WHEN", DateTime.UtcNow)
+            .Add("pACTION_PROFILE_ID", request.Action?.ProfileId)
+            .Add("pACTION_ACTIVE", request.Action?.Active)
+            .Add("pACTION_SEQUENCE", request.Action?.Sequence, SqlDbType.TinyInt)
+            .Add("pACTION_ENDPOINT_ID", request.Action?.EndpointId)
+            .Add("pACTION_ENDPOINT_AUTH_ID", request.Action?.EndpointAuthId)
+            .Add("pACTION_ENDPOINT_PARAMS_ID", request.Action?.EndpointParamsId, SqlDbType.SmallInt)
+            .Add("pACTION_SQL_CONNECTION_ID", request.Action?.SqlConnectionId, SqlDbType.SmallInt)
+            .Add("pACTION_TYPE_ID", request.Action?.TypeId is not null ? (byte)request.Action.TypeId : null, SqlDbType.TinyInt)
+            .Add("pACTION_PRE_SQL", request.Action?.PreSql)
+            .Add("pACTION_HEADER_SQL", request.Action?.HeaderSql)
+            .Add("pACTION_BODY_SQL", request.Action?.BodySql)
+            .Add("pACTION_POST_SQL", request.Action?.PostSql)
+            .Add("pACTION_ERROR_ACTION_ID", request.Action?.ErrorActionId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_ACTIVE", request.Endpoint?.Active)
+            .Add("pENDPOINT_DESCRIPTION", request.Endpoint?.Description)
+            .Add("pENDPOINT_URI", request.Endpoint?.Uri)
+            .Add("pENDPOINT_AUTH_ACTIVE", request.EndpointAuth?.Active)
+            .Add("pENDPOINT_AUTH_DESCRIPTION", request.EndpointAuth?.Description)
+            .Add("pENDPOINT_AUTH_TYPE_ID", request.EndpointAuth?.TypeId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_AUTH_API_KEY", request.EndpointAuth?.ApiKey)
+            .Add("pENDPOINT_AUTH_API_VALUE", request.EndpointAuth?.ApiValue)
+            .Add("pENDPOINT_AUTH_API_KEY_ADD_TO_ID", request.EndpointAuth?.ApiKeyAddToId)
+            .Add("pENDPOINT_AUTH_TOKEN", request.EndpointAuth?.Token)
+            .Add("pENDPOINT_AUTH_USERNAME", request.EndpointAuth?.Username)
+            .Add("pENDPOINT_AUTH_PASSWORD", request.EndpointAuth?.Password)
+            .Add("pENDPOINT_AUTH_DOMAIN", request.EndpointAuth?.Domain)
+            .Add("pENDPOINT_AUTH_WORKSTATION", request.EndpointAuth?.Workstation)
+            .Add("pPROFILE_ACTIVE", request.Profile?.Active)
+            .Add("pPROFILE_TYPE_ID", request.Profile?.TypeId, SqlDbType.TinyInt)
+            .Add("pPROFILE_MANDANTOR", request.Profile?.Mandantor)
+            .Add("pPROFILE_NAME", request.Profile?.Name)
+            .Add("pPROFILE_DESCRIPTION", request.Profile?.Description)
+            .Add("pPROFILE_LOG_LEVEL_ID", request.Profile?.LogLevelId, SqlDbType.TinyInt)
+            .Add("pPROFILE_LANGUAGE_ID", request.Profile?.LanguageId, SqlDbType.SmallInt)
+            .Add("pRESULT_ACTION_ID", request.Result?.ActionId)
+            .Add("pRESULT_STATUS_ID", request.Result?.Status, SqlDbType.TinyInt)
+            .Add("pRESULT_TYPE_ID", request.Result?.Type is not null ? (byte)request.Result.Type : null, SqlDbType.TinyInt)
+            .Add("pRESULT_HEADER", request.Result?.Header)
+            .Add("pRESULT_BODY", request.Result?.Body)
+            .Add("pRESULT_INFO_ID", request.Result?.Info, SqlDbType.SmallInt)
+            .Add("pRESULT_INFO_DETAIL", request.Result?.InfoDetail)
+            .Add("pRESULT_ERROR", request.Result?.Error)
+            .Add("pRESULT_BATCH_ID", request.Result?.References?.BatchId)
+            .Add("pRESULT_REFERENCE1", request.Result?.References?.Reference1)
+            .Add("pRESULT_REFERENCE2", request.Result?.References?.Reference2)
+            .Add("pRESULT_REFERENCE3", request.Result?.References?.Reference3)
+            .Add("pRESULT_REFERENCE4", request.Result?.References?.Reference4)
+            .Add("pRESULT_REFERENCE5", request.Result?.References?.Reference5)
+            .Add("pENDPOINT_PARAMS_ACTIVE", request.EndpointParams?.Active)
+            .Add("pENDPOINT_PARAMS_DESCRIPTION", request.EndpointParams?.Description)
+            .Add("pENDPOINT_PARAMS_GROUP_ID", request.EndpointParams?.GroupId, SqlDbType.SmallInt)
+            .Add("pENDPOINT_PARAMS_SEQUENCE", request.EndpointParams?.Sequence, SqlDbType.TinyInt)
+            .Add("pENDPOINT_PARAMS_KEY", request.EndpointParams?.Key)
+            .Add("pENDPOINT_PARAMS_VALUE", request.EndpointParams?.Value)
+            .AddOutput("oGUID", SqlDbType.BigInt);
 
         try
         {
-            await repo.ExecuteQueryRawAsync(
-                "EXEC [dbo].[PRREC_INSERT_OBJECT] " +
-                "@pENTITY, @pADDED_WHO, @pADDED_WHEN, " +
-                "@pACTION_PROFILE_ID, @pACTION_ACTIVE, @pACTION_SEQUENCE, @pACTION_ENDPOINT_ID, @pACTION_ENDPOINT_AUTH_ID, @pACTION_ENDPOINT_PARAMS_ID, @pACTION_SQL_CONNECTION_ID, @pACTION_TYPE_ID, @pACTION_PRE_SQL, @pACTION_HEADER_SQL, @pACTION_BODY_SQL, @pACTION_POST_SQL, @pACTION_ERROR_ACTION_ID, " +
-                "@pENDPOINT_ACTIVE, @pENDPOINT_DESCRIPTION, @pENDPOINT_URI, " +
-                "@pENDPOINT_AUTH_ACTIVE, @pENDPOINT_AUTH_DESCRIPTION, @pENDPOINT_AUTH_TYPE_ID, @pENDPOINT_AUTH_API_KEY, @pENDPOINT_AUTH_API_VALUE, @pENDPOINT_AUTH_API_KEY_ADD_TO_ID, @pENDPOINT_AUTH_TOKEN, @pENDPOINT_AUTH_USERNAME, @pENDPOINT_AUTH_PASSWORD, @pENDPOINT_AUTH_DOMAIN, @pENDPOINT_AUTH_WORKSTATION, " +
-                "@pPROFILE_ACTIVE, @pPROFILE_TYPE_ID, @pPROFILE_MANDANTOR, @pPROFILE_NAME, @pPROFILE_DESCRIPTION, @pPROFILE_LOG_LEVEL_ID, @pPROFILE_LANGUAGE_ID, " +
-                "@pRESULT_ACTION_ID, @pRESULT_STATUS_ID, @pRESULT_HEADER, @pRESULT_BODY, " +
-                "@pENDPOINT_PARAMS_ACTIVE, @pENDPOINT_PARAMS_DESCRIPTION, @pENDPOINT_PARAMS_GROUP_ID, @pENDPOINT_PARAMS_SEQUENCE, @pENDPOINT_PARAMS_KEY, @pENDPOINT_PARAMS_VALUE, " +
-                "@oGUID OUTPUT",
-                parameters,
-                cancel);
+            await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
         }
         catch (SqlException ex)
         {
@@ -126,12 +109,12 @@ public class InsertObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlE
                 throw;
         }
 
-        var guidParam = parameters.Last();
+        var guidParam = sp.GetParameter("oGUID");
 
-        if (guidParam.Value != DBNull.Value)
-            if (guidParam.Value is long longValue)
+        if (guidParam?.Value != DBNull.Value)
+            if (guidParam!.Value is long longValue)
                 return longValue;
-            else if (long.TryParse(guidParam.Value.ToString(), out var guid))
+            else if (long.TryParse(guidParam.Value?.ToString(), out var guid))
                 return guid;
 
         throw new InsertObjectFailedException(request, "InsertObject stored procedure did not return a valid identifier.");

src/ReC.Application/Common/Procedures/StoredProcedureBuilder.cs

@@ -0,0 +1,81 @@
+using Microsoft.Data.SqlClient;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using System.Data;
+using System.Text;
+
+namespace ReC.Application.Common.Procedures;
+
+internal sealed class StoredProcedureBuilder(string procedureName, string? returnVariable = null)
+{
+    private readonly StringBuilder _execSql = returnVariable is not null
+            ? new StringBuilder($"EXEC @{returnVariable} = {procedureName}")
+            : new StringBuilder($"EXEC {procedureName}");
+    private readonly List<SqlParameter> _parameters = [];
+    private char _separator = ' ';
+
+    public StoredProcedureBuilder Add(string name, object? value, SqlDbType? dbType = null)
+    {
+        if (value is null) return this;
+
+        _execSql.AppendLine($"{_separator}@{name} = @{name}");
+        _separator = ',';
+
+        if (!dbType.HasValue && value is DateTime)
+            dbType = SqlDbType.DateTime;
+
+        if (dbType.HasValue)
+            _parameters.Add(new SqlParameter($"@{name}", dbType.Value) { Value = value });
+        else
+            _parameters.Add(new SqlParameter($"@{name}", value));
+
+        return this;
+    }
+
+    public StoredProcedureBuilder Add(string name, EntityType entityType)
+    {
+        var entityTypeStr = entityType switch
+        {
+            EntityType.Action => "ACTION",
+            EntityType.Endpoint => "ENDPOINT",
+            EntityType.EndpointAuth => "ENDPOINT_AUTH",
+            EntityType.EndpointParams => "ENDPOINT_PARAMS",
+            EntityType.Profile => "PROFILE",
+            EntityType.Result => "RESULT",
+            _ => throw new ArgumentOutOfRangeException(nameof(entityType), $"Not expected entity type value: {entityType}")
+        };
+
+        return Add(name, entityTypeStr);
+    }
+
+    public StoredProcedureBuilder AddOutput(string name, SqlDbType dbType)
+    {
+        _execSql.AppendLine($"{_separator}@{name} = @{name} OUTPUT");
+        _separator = ',';
+
+        _parameters.Add(new SqlParameter
+        {
+            ParameterName = $"@{name}",
+            SqlDbType = dbType,
+            Direction = ParameterDirection.Output
+        });
+
+        return this;
+    }
+
+    public string BuildSql()
+    {
+        if (returnVariable is null)
+            return _execSql.ToString();
+
+        return new StringBuilder()
+            .AppendLine($"DECLARE @{returnVariable} SMALLINT = 0;")
+            .Append(_execSql).AppendLine(";")
+            .AppendLine($"SELECT @{returnVariable};")
+            .ToString();
+    }
+
+    public SqlParameter[] BuildParameters() => [.. _parameters];
+
+    public SqlParameter? GetParameter(string name) =>
+        _parameters.Find(p => p.ParameterName == $"@{name}");
+}

src/ReC.Application/Common/Procedures/UpdateProcedure/Dto/UpdateResultDto.cs

@@ -1,4 +1,6 @@
-namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.RecActions.Commands;
+
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
 
 public record UpdateResultDto
 {
@@ -6,4 +8,8 @@ public record UpdateResultDto
     public short? StatusId { get; set; }
     public string? Header { get; set; }
     public string? Body { get; set; }
+    public short? Info { get; set; }
+    public string? InfoDetail { get; set; }
+    public string? Error { get; set; }
+    public InvokeReferences? References { get; set; }
 }

src/ReC.Application/Common/Procedures/UpdateProcedure/UpdateObjectProcedure.cs

@@ -6,21 +6,16 @@ using Microsoft.Extensions.Options;
 using ReC.Application.Common.Exceptions;
 using ReC.Application.Common.Options;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
-using ReC.Application.EndpointAuth.Commands;
-using ReC.Application.EndpointParams.Commands;
-using ReC.Application.Endpoints.Commands;
-using ReC.Application.Profile.Commands;
-using ReC.Application.RecActions.Commands;
-using ReC.Application.Results.Commands;
+using System.Data;
 
 namespace ReC.Application.Common.Procedures.UpdateProcedure;
 
 public record UpdateObjectProcedure : IRequest<int>
 {
     /// <summary>
-    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// Target entity for the update operation.
     /// </summary>
-    public string Entity { get; set; } = null!;
+    public required EntityType Entity { get; set; }
 
     /// <summary>
     /// Target GUID to update (required)
@@ -42,85 +37,72 @@ public class UpdateObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlE
 {
     public async Task<int> Handle(UpdateObjectProcedure request, CancellationToken cancel)
     {
-        var parameters = new[]
-        {
-            new SqlParameter("@pENTITY", request.Entity ?? (object)DBNull.Value),
-            new SqlParameter("@pGUID", (object?)request.Id ?? DBNull.Value),
-
-            new SqlParameter("@pCHANGED_WHO", (object?)request.ChangedWho ?? DBNull.Value),
-            new SqlParameter("@pCHANGED_WHEN", (object?)DateTime.UtcNow ?? DBNull.Value),
-
-            new SqlParameter("@pACTION_PROFILE_ID", (object?)request.Action.ProfileId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ACTIVE", (object?)request.Action.Active ?? DBNull.Value),
-            new SqlParameter("@pACTION_SEQUENCE", (object?)request.Action.Sequence ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_ID", (object?)request.Action.EndpointId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_AUTH_ID", (object?)request.Action.EndpointAuthId ?? DBNull.Value),
-            new SqlParameter("@pACTION_ENDPOINT_PARAMS_ID", (object?)request.Action.EndpointParamsId ?? DBNull.Value),
-            new SqlParameter("@pACTION_SQL_CONNECTION_ID", (object?)request.Action.SqlConnectionId ?? DBNull.Value),
-            new SqlParameter("@pACTION_TYPE_ID", (object?)request.Action.TypeId ?? DBNull.Value),
-            new SqlParameter("@pACTION_PRE_SQL", (object?)request.Action.PreSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_HEADER_SQL", (object?)request.Action.HeaderSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_BODY_SQL", (object?)request.Action.BodySql ?? DBNull.Value),
-            new SqlParameter("@pACTION_POST_SQL", (object?)request.Action.PostSql ?? DBNull.Value),
-            new SqlParameter("@pACTION_ERROR_ACTION_ID", (object?)request.Action.ErrorActionId ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_ACTIVE", (object?)request.Endpoint.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_DESCRIPTION", (object?)request.Endpoint.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_URI", (object?)request.Endpoint.Uri ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_AUTH_ACTIVE", (object?)request.EndpointAuth.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_DESCRIPTION", (object?)request.EndpointAuth.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_TYPE_ID", (object?)request.EndpointAuth.TypeId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_KEY", (object?)request.EndpointAuth.ApiKey ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_VALUE", (object?)request.EndpointAuth.ApiValue ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_API_KEY_ADD_TO_ID", (object?)request.EndpointAuth.ApiKeyAddToId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_TOKEN", (object?)request.EndpointAuth.Token ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_USERNAME", (object?)request.EndpointAuth.Username ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_PASSWORD", (object?)request.EndpointAuth.Password ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_DOMAIN", (object?)request.EndpointAuth.Domain ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_AUTH_WORKSTATION", (object?)request.EndpointAuth.Workstation ?? DBNull.Value),
-
-            new SqlParameter("@pENDPOINT_PARAMS_ACTIVE", (object?)request.EndpointParams.Active ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_DESCRIPTION", (object?)request.EndpointParams.Description ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_GROUP_ID", (object?)request.EndpointParams.GroupId ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_SEQUENCE", (object?)request.EndpointParams.Sequence ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_KEY", (object?)request.EndpointParams.Key ?? DBNull.Value),
-            new SqlParameter("@pENDPOINT_PARAMS_VALUE", (object?)request.EndpointParams.Value ?? DBNull.Value),
-
-            new SqlParameter("@pPROFILE_ACTIVE", (object?)request.Profile.Active ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_TYPE_ID", (object?)request.Profile.TypeId ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_MANDANTOR", (object?)request.Profile.Mandantor ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_NAME", (object?)request.Profile.Name ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_DESCRIPTION", (object?)request.Profile.Description ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LOG_LEVEL_ID", (object?)request.Profile.LogLevelId ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LANGUAGE_ID", (object?)request.Profile.LanguageId ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_FIRST_RUN", (object?)request.Profile.FirstRun ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LAST_RUN", (object?)request.Profile.LastRun ?? DBNull.Value),
-            new SqlParameter("@pPROFILE_LAST_RESULT", (object?)request.Profile.LastResult ?? DBNull.Value),
-
-            new SqlParameter("@pRESULT_ACTION_ID", (object?)request.Result.ActionId ?? DBNull.Value),
-            new SqlParameter("@pRESULT_STATUS_ID", (object?)request.Result.StatusId ?? DBNull.Value),
-            new SqlParameter("@pRESULT_HEADER", (object?)request.Result.Header ?? DBNull.Value),
-            new SqlParameter("@pRESULT_BODY", (object?)request.Result.Body ?? DBNull.Value)
-        };
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_UPDATE_OBJECT]", "RC")
+            .Add("pENTITY", request.Entity)
+            .Add("pGUID", request.Id)
+            .Add("pCHANGED_WHO", request.ChangedWho)
+            .Add("pCHANGED_WHEN", DateTime.UtcNow)
+            .Add("pACTION_PROFILE_ID", request.Action.ProfileId)
+            .Add("pACTION_ACTIVE", request.Action.Active)
+            .Add("pACTION_SEQUENCE", request.Action.Sequence, SqlDbType.TinyInt)
+            .Add("pACTION_ENDPOINT_ID", request.Action.EndpointId)
+            .Add("pACTION_ENDPOINT_AUTH_ID", request.Action.EndpointAuthId)
+            .Add("pACTION_ENDPOINT_PARAMS_ID", request.Action.EndpointParamsId, SqlDbType.SmallInt)
+            .Add("pACTION_SQL_CONNECTION_ID", request.Action.SqlConnectionId, SqlDbType.SmallInt)
+            .Add("pACTION_TYPE_ID", request.Action.TypeId, SqlDbType.TinyInt)
+            .Add("pACTION_PRE_SQL", request.Action.PreSql)
+            .Add("pACTION_HEADER_SQL", request.Action.HeaderSql)
+            .Add("pACTION_BODY_SQL", request.Action.BodySql)
+            .Add("pACTION_POST_SQL", request.Action.PostSql)
+            .Add("pACTION_ERROR_ACTION_ID", request.Action.ErrorActionId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_ACTIVE", request.Endpoint.Active)
+            .Add("pENDPOINT_DESCRIPTION", request.Endpoint.Description)
+            .Add("pENDPOINT_URI", request.Endpoint.Uri)
+            .Add("pENDPOINT_AUTH_ACTIVE", request.EndpointAuth.Active)
+            .Add("pENDPOINT_AUTH_DESCRIPTION", request.EndpointAuth.Description)
+            .Add("pENDPOINT_AUTH_TYPE_ID", request.EndpointAuth.TypeId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_AUTH_API_KEY", request.EndpointAuth.ApiKey)
+            .Add("pENDPOINT_AUTH_API_VALUE", request.EndpointAuth.ApiValue)
+            .Add("pENDPOINT_AUTH_API_KEY_ADD_TO_ID", request.EndpointAuth.ApiKeyAddToId)
+            .Add("pENDPOINT_AUTH_TOKEN", request.EndpointAuth.Token)
+            .Add("pENDPOINT_AUTH_USERNAME", request.EndpointAuth.Username)
+            .Add("pENDPOINT_AUTH_PASSWORD", request.EndpointAuth.Password)
+            .Add("pENDPOINT_AUTH_DOMAIN", request.EndpointAuth.Domain)
+            .Add("pENDPOINT_AUTH_WORKSTATION", request.EndpointAuth.Workstation)
+            .Add("pENDPOINT_PARAMS_ACTIVE", request.EndpointParams.Active)
+            .Add("pENDPOINT_PARAMS_DESCRIPTION", request.EndpointParams.Description)
+            .Add("pENDPOINT_PARAMS_GROUP_ID", request.EndpointParams.GroupId, SqlDbType.SmallInt)
+            .Add("pENDPOINT_PARAMS_SEQUENCE", request.EndpointParams.Sequence, SqlDbType.TinyInt)
+            .Add("pENDPOINT_PARAMS_KEY", request.EndpointParams.Key)
+            .Add("pENDPOINT_PARAMS_VALUE", request.EndpointParams.Value)
+            .Add("pPROFILE_ACTIVE", request.Profile.Active)
+            .Add("pPROFILE_TYPE_ID", request.Profile.TypeId, SqlDbType.TinyInt)
+            .Add("pPROFILE_MANDANTOR", request.Profile.Mandantor)
+            .Add("pPROFILE_NAME", request.Profile.Name)
+            .Add("pPROFILE_DESCRIPTION", request.Profile.Description)
+            .Add("pPROFILE_LOG_LEVEL_ID", request.Profile.LogLevelId, SqlDbType.TinyInt)
+            .Add("pPROFILE_LANGUAGE_ID", request.Profile.LanguageId, SqlDbType.SmallInt)
+            .Add("pPROFILE_FIRST_RUN", request.Profile.FirstRun)
+            .Add("pPROFILE_LAST_RUN", request.Profile.LastRun)
+            .Add("pPROFILE_LAST_RESULT", request.Profile.LastResult)
+            .Add("pRESULT_ACTION_ID", request.Result.ActionId)
+            .Add("pRESULT_STATUS_ID", request.Result.StatusId, SqlDbType.TinyInt)
+            .Add("pRESULT_HEADER", request.Result.Header)
+            .Add("pRESULT_BODY", request.Result.Body)
+            .Add("pRESULT_INFO_ID", request.Result.Info, SqlDbType.SmallInt)
+            .Add("pRESULT_INFO_DETAIL", request.Result.InfoDetail)
+            .Add("pRESULT_ERROR", request.Result.Error)
+            .Add("pRESULT_BATCH_ID", request.Result.References?.BatchId)
+            .Add("pRESULT_REFERENCE1", request.Result.References?.Reference1)
+            .Add("pRESULT_REFERENCE2", request.Result.References?.Reference2)
+            .Add("pRESULT_REFERENCE3", request.Result.References?.Reference3)
+            .Add("pRESULT_REFERENCE4", request.Result.References?.Reference4)
+            .Add("pRESULT_REFERENCE5", request.Result.References?.Reference5);
 
         try
         {
-            var result = await repo.ExecuteQueryRawAsync(
-                "DECLARE @RC SMALLINT = 0; " +
-                "EXEC @RC = [dbo].[PRREC_UPDATE_OBJECT] " +
-                "@pENTITY, @pGUID, @pCHANGED_WHO, @pCHANGED_WHEN, " +
-                "@pACTION_PROFILE_ID, @pACTION_ACTIVE, @pACTION_SEQUENCE, @pACTION_ENDPOINT_ID, @pACTION_ENDPOINT_AUTH_ID, @pACTION_ENDPOINT_PARAMS_ID, @pACTION_SQL_CONNECTION_ID, @pACTION_TYPE_ID, @pACTION_PRE_SQL, @pACTION_HEADER_SQL, @pACTION_BODY_SQL, @pACTION_POST_SQL, @pACTION_ERROR_ACTION_ID, " +
-                "@pENDPOINT_ACTIVE, @pENDPOINT_DESCRIPTION, @pENDPOINT_URI, " +
-                "@pENDPOINT_AUTH_ACTIVE, @pENDPOINT_AUTH_DESCRIPTION, @pENDPOINT_AUTH_TYPE_ID, @pENDPOINT_AUTH_API_KEY, @pENDPOINT_AUTH_API_VALUE, @pENDPOINT_AUTH_API_KEY_ADD_TO_ID, @pENDPOINT_AUTH_TOKEN, @pENDPOINT_AUTH_USERNAME, @pENDPOINT_AUTH_PASSWORD, @pENDPOINT_AUTH_DOMAIN, @pENDPOINT_AUTH_WORKSTATION, " +
-                "@pENDPOINT_PARAMS_ACTIVE, @pENDPOINT_PARAMS_DESCRIPTION, @pENDPOINT_PARAMS_GROUP_ID, @pENDPOINT_PARAMS_SEQUENCE, @pENDPOINT_PARAMS_KEY, @pENDPOINT_PARAMS_VALUE, " +
-                "@pPROFILE_ACTIVE, @pPROFILE_TYPE_ID, @pPROFILE_MANDANTOR, @pPROFILE_NAME, @pPROFILE_DESCRIPTION, @pPROFILE_LOG_LEVEL_ID, @pPROFILE_LANGUAGE_ID, @pPROFILE_FIRST_RUN, @pPROFILE_LAST_RUN, @pPROFILE_LAST_RESULT, " +
-                "@pRESULT_ACTION_ID, @pRESULT_STATUS_ID, @pRESULT_HEADER, @pRESULT_BODY; " +
-                "SELECT @RC;",
-                parameters,
-                cancel);
+            var result = await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
 
-            // The stored procedure returns 0 on success, error codes > 0 on failure
             if (result > 0)
             {
                 throw new UpdateObjectFailedException(request, $"UpdateObject stored procedure failed with error code: {result}");

src/ReC.Application/Common/Validations/DeleteObjectProcedureValidator.cs

@@ -0,0 +1,22 @@
+using FluentValidation;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.Common.Validations;
+
+public class DeleteObjectProcedureValidator : AbstractValidator<DeleteObjectProcedure>
+{
+    public DeleteObjectProcedureValidator()
+    {
+        RuleFor(x => x.Entity)
+            .IsInEnum()
+            .WithMessage("ENTITY must be a valid EntityType value.");
+
+        RuleFor(x => x.Start)
+            .GreaterThan(0)
+            .WithMessage("Start GUID/ID must be greater than 0.");
+
+        RuleFor(x => x.End)
+            .GreaterThanOrEqualTo(x => x.Start)
+            .WithMessage("End GUID/ID must be greater than or equal to Start GUID/ID.");
+    }
+}

src/ReC.Application/Common/Validations/InsertObjectProcedureValidator.cs

@@ -7,66 +7,60 @@ public class InsertObjectProcedureValidator : AbstractValidator<InsertObjectProc
 {
     public InsertObjectProcedureValidator()
     {
-        // ENTITY must be one of the allowed values
         RuleFor(x => x.Entity)
-            .NotEmpty()
-            .Must(e => e is "ACTION" or "ENDPOINT" or "ENDPOINT_AUTH" or "ENDPOINT_PARAMS" or "PROFILE" or "RESULT")
-            .WithMessage("ENTITY must be one of: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT.");
+            .IsInEnum()
+            .WithMessage("ENTITY must be a valid EntityType value.");
 
         // ACTION validation
-        When(x => x.Entity == "ACTION", () =>
+        When(x => x.Action != null, () =>
         {
-            RuleFor(x => x.Action.ProfileId)
+            RuleFor(x => x.Action!.ProfileId)
                 .NotNull()
                 .WithMessage("ACTION requires ActionProfileId (maps to @pACTION_PROFILE_ID).");
 
-            RuleFor(x => x.Action.EndpointId)
+            RuleFor(x => x.Action!.EndpointId)
                 .NotNull()
                 .WithMessage("ACTION requires ActionEndpointId (maps to @pACTION_ENDPOINT_ID).");
         });
 
         // ENDPOINT validation
-        When(x => x.Entity == "ENDPOINT", () =>
+        When(x => x.Endpoint != null, () =>
         {
-            RuleFor(x => x.Endpoint.Uri)
+            RuleFor(x => x.Endpoint!.Uri)
                 .NotEmpty()
                 .WithMessage("ENDPOINT requires EndpointUri (maps to @pENDPOINT_URI).")
                 .MaximumLength(2000);
         });
 
         // PROFILE validation
-        When(x => x.Entity == "PROFILE", () =>
+        When(x => x.Profile != null, () =>
         {
-            RuleFor(x => x.Profile.Name)
+            RuleFor(x => x.Profile!.Name)
                 .NotEmpty()
                 .WithMessage("PROFILE requires ProfileName (maps to @pPROFILE_NAME).")
                 .MaximumLength(50);
 
-            RuleFor(x => x.Profile.Mandantor)
+            RuleFor(x => x.Profile!.Mandantor)
                 .MaximumLength(50)
-                .When(x => x.Profile.Mandantor != null);
+                .When(x => x.Profile!.Mandantor != null);
 
-            RuleFor(x => x.Profile.Description)
+            RuleFor(x => x.Profile!.Description)
                 .MaximumLength(250)
-                .When(x => x.Profile.Description != null);
+                .When(x => x.Profile!.Description != null);
         });
 
         // RESULT validation
-        When(x => x.Entity == "RESULT", () =>
+        When(x => x.Result != null, () =>
         {
-            RuleFor(x => x.Result.ActionId)
+            RuleFor(x => x.Result!.ActionId)
                 .NotNull()
                 .WithMessage("RESULT requires ResultActionId (maps to @pRESULT_ACTION_ID).");
-
-            RuleFor(x => x.Result.StatusId)
-                .NotNull()
-                .WithMessage("RESULT requires ResultStatusId (maps to @pRESULT_STATUS_ID).");
         });
 
         // ENDPOINT_PARAMS validation
-        When(x => x.Entity == "ENDPOINT_PARAMS", () =>
+        When(x => x.EndpointParams != null, () =>
         {
-            RuleFor(x => x.EndpointParams.GroupId)
+            RuleFor(x => x.EndpointParams!.GroupId)
                 .NotNull()
                 .WithMessage("ENDPOINT_PARAMS requires EndpointParamsGroupId (maps to @pENDPOINT_PARAMS_GROUP_ID).");
         });
@@ -76,12 +70,12 @@ public class InsertObjectProcedureValidator : AbstractValidator<InsertObjectProc
             .MaximumLength(50)
             .When(x => x.AddedWho != null);
 
-        RuleFor(x => x.Endpoint.Description)
+        RuleFor(x => x.Endpoint!.Description)
             .MaximumLength(250)
-            .When(x => x.Endpoint.Description != null);
+            .When(x => x.Endpoint is { Description: not null });
 
-        RuleFor(x => x.EndpointAuth.Description)
+        RuleFor(x => x.EndpointAuth!.Description)
             .MaximumLength(250)
-            .When(x => x.EndpointAuth.Description != null);
+            .When(x => x.EndpointAuth is { Description: not null });
     }
 }

src/ReC.Application/Common/Validations/InsertResultCommandValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using ReC.Application.Results.Commands;
+
+namespace ReC.Application.Common.Validations;
+
+public class InsertResultCommandValidator : AbstractValidator<InsertResultCommand>
+{
+    public InsertResultCommandValidator()
+    {
+        RuleFor(x => x.ActionId)
+            .NotNull()
+            .WithMessage("ActionId is required.")
+            .GreaterThan(0L)
+            .When(x => x.ActionId.HasValue)
+            .WithMessage("ActionId must be greater than 0.");
+
+        RuleFor(x => x.References.BatchId)
+            .NotEmpty()
+            .WithMessage("BatchId is required.");
+    }
+}

src/ReC.Application/Common/Validations/InvokeBatchRecActionViewsCommandValidator.cs

@@ -0,0 +1,22 @@
+using FluentValidation;
+using MediatR;
+using ReC.Application.RecActions.Commands;
+using ReC.Application.Results.Queries;
+
+namespace ReC.Application.Common.Validations;
+
+public class InvokeBatchRecActionViewsCommandValidator : AbstractValidator<InvokeBatchRecActionViewsCommand>
+{
+    public InvokeBatchRecActionViewsCommandValidator(ISender sender)
+    {
+        RuleFor(x => x.References.BatchId)
+            .NotEmpty()
+            .WithMessage("BatchId is required.")
+            .MustAsync(async (batchId, cancel) =>
+            {
+                var any = await sender.Send(new AnyResultViewQuery(BatchId: batchId), cancel);
+                return !any;
+            })
+            .WithMessage(x => $"Cannot invoke rec actions for batch '{x.References.BatchId}' because there are already results associated with it.");
+    }
+}

src/ReC.Application/Common/Validations/ReadProfileViewQueryValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using ReC.Application.Profile.Queries;
+
+namespace ReC.Application.Common.Validations;
+
+public class ReadProfileViewQueryValidator : AbstractValidator<ReadProfileViewQuery>
+{
+    public ReadProfileViewQueryValidator()
+    {
+        RuleFor(x => x.Id)
+            .GreaterThan(0)
+            .When(x => x.Id.HasValue)
+            .WithMessage("Id must be greater than 0.");
+    }
+}

src/ReC.Application/Common/Validations/ReadRecActionViewQueryValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using ReC.Application.RecActions.Queries;
+
+namespace ReC.Application.Common.Validations;
+
+public class ReadRecActionViewQueryValidator : AbstractValidator<ReadRecActionViewQuery>
+{
+    public ReadRecActionViewQueryValidator()
+    {
+        RuleFor(x => x.ProfileId)
+            .GreaterThan(0)
+            .When(x => x.ProfileId.HasValue)
+            .WithMessage("ProfileId must be greater than 0.");
+    }
+}

src/ReC.Application/Common/Validations/ReadResultViewQueryValidator.cs

@@ -0,0 +1,34 @@
+using FluentValidation;
+using ReC.Application.Results.Queries;
+
+namespace ReC.Application.Common.Validations;
+
+public class ReadResultViewQueryValidator : AbstractValidator<ReadResultViewQuery>
+{
+    public ReadResultViewQueryValidator()
+    {
+        RuleFor(x => x)
+            .Must(x => x.Id.HasValue || x.ActionId.HasValue || x.ProfileId.HasValue || x.BatchId is not null)
+            .WithMessage("At least one filter (Id, ActionId, ProfileId or BatchId) must be provided.");
+
+        RuleFor(x => x.Id)
+            .GreaterThan(0)
+            .When(x => x.Id.HasValue)
+            .WithMessage("Id must be greater than 0.");
+
+        RuleFor(x => x.ActionId)
+            .GreaterThan(0)
+            .When(x => x.ActionId.HasValue)
+            .WithMessage("ActionId must be greater than 0.");
+
+        RuleFor(x => x.ProfileId)
+            .GreaterThan(0)
+            .When(x => x.ProfileId.HasValue)
+            .WithMessage("ProfileId must be greater than 0.");
+
+        RuleFor(x => x.BatchId)
+            .NotEmpty()
+            .When(x => x.BatchId is not null)
+            .WithMessage("BatchId must not be empty when provided.");
+    }
+}

src/ReC.Application/Common/Validations/UpdateObjectProcedureValidator.cs

@@ -0,0 +1,52 @@
+using FluentValidation;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.Common.Validations;
+
+public class UpdateObjectProcedureValidator : AbstractValidator<UpdateObjectProcedure>
+{
+    public UpdateObjectProcedureValidator()
+    {
+        RuleFor(x => x.Entity)
+            .IsInEnum()
+            .WithMessage("ENTITY must be a valid EntityType value.");
+
+        RuleFor(x => x.Id)
+            .GreaterThan(0)
+            .WithMessage("Target GUID/ID must be greater than 0.");
+
+        RuleFor(x => x.ChangedWho)
+            .MaximumLength(50)
+            .When(x => x.ChangedWho != null);
+
+        When(x => x.Endpoint is { Description: not null }, () =>
+        {
+            RuleFor(x => x.Endpoint.Description)
+                .MaximumLength(250);
+        });
+
+        When(x => x.EndpointAuth is { Description: not null }, () =>
+        {
+            RuleFor(x => x.EndpointAuth.Description)
+                .MaximumLength(250);
+        });
+
+        When(x => x.Profile is { Name: not null }, () =>
+        {
+            RuleFor(x => x.Profile.Name)
+                .MaximumLength(50);
+        });
+
+        When(x => x.Profile is { Mandantor: not null }, () =>
+        {
+            RuleFor(x => x.Profile.Mandantor)
+                .MaximumLength(50);
+        });
+
+        When(x => x.Profile is { Description: not null }, () =>
+        {
+            RuleFor(x => x.Profile.Description)
+                .MaximumLength(250);
+        });
+    }
+}

src/ReC.Application/DependencyInjection.cs

@@ -4,6 +4,7 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using ReC.Application.Common.Behaviors;
 using ReC.Application.Common.Behaviors.Action;
+using ReC.Application.Common.Behaviors.InvokeAction;
 using ReC.Application.Common.Constants;
 using ReC.Application.Common.Options;
 using ReC.Application.RecActions.Commands;

src/ReC.Application/EndpointAuth/Commands/DeleteEndpointAuthCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointAuth.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteEndpointAuthProcedureHandler(ISender sender) : IRequestHandle
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "ENDPOINT_AUTH",
+            Entity = EntityType.EndpointAuth,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/EndpointAuth/Commands/InsertEndpointAuthCommand.cs

@@ -1,5 +1,6 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointAuth.Commands;
 
@@ -24,7 +25,7 @@ public class InsertEndpointAuthProcedureHandler(ISender sender) : IRequestHandle
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "ENDPOINT_AUTH",
+            Entity = EntityType.EndpointAuth,
             EndpointAuth = request
         }, cancel);
     }

src/ReC.Application/EndpointAuth/Commands/UpdateEndpointAuthCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointAuth.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateEndpointAuthProcedureHandler(ISender sender) : IRequestHandle
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "ENDPOINT_AUTH",
+            Entity = EntityType.EndpointAuth,
             Id = request.Id,
             EndpointAuth = request.Data
         }, cancel);

src/ReC.Application/EndpointParams/Commands/DeleteEndpointParamsCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointParams.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteEndpointParamsProcedureHandler(ISender sender) : IRequestHand
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "ENDPOINT_PARAMS",
+            Entity = EntityType.EndpointParams,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/EndpointParams/Commands/InsertEndpointParamsCommand.cs

@@ -1,5 +1,6 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointParams.Commands;
 
@@ -19,7 +20,7 @@ public class InsertEndpointParamsProcedureHandler(ISender sender) : IRequestHand
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "ENDPOINT_PARAMS",
+            Entity = EntityType.EndpointParams,
             EndpointParams = request
         }, cancel);
     }

src/ReC.Application/EndpointParams/Commands/UpdateEndpointParamsCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.EndpointParams.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateEndpointParamsProcedureHandler(ISender sender) : IRequestHand
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "ENDPOINT_PARAMS",
+            Entity = EntityType.EndpointParams,
             Id = request.Id,
             EndpointParams = request.Data
         }, cancel);

src/ReC.Application/Endpoints/Commands/DeleteEndpointCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Endpoints.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteEndpointProcedureHandler(ISender sender) : IRequestHandler<De
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "ENDPOINT",
+            Entity = EntityType.Endpoint,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/Endpoints/Commands/InsertEndpointCommand.cs

@@ -1,5 +1,6 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Endpoints.Commands;
 
@@ -16,7 +17,7 @@ public class InsertEndpointProcedureHandler(ISender sender) : IRequestHandler<In
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "ENDPOINT",
+            Entity = EntityType.Endpoint,
             Endpoint = request
         }, cancel);
     }

src/ReC.Application/Endpoints/Commands/UpdateEndpointCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Endpoints.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateEndpointProcedureHandler(ISender sender) : IRequestHandler<Up
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "ENDPOINT",
+            Entity = EntityType.Endpoint,
             Id = request.Id,
             Endpoint = request.Data
         }, cancel);

src/ReC.Application/Profile/Commands/DeleteProfileCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Profile.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteProfileProcedureHandler(ISender sender) : IRequestHandler<Del
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "PROFILE",
+            Entity = EntityType.Profile,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/Profile/Commands/InsertProfileCommand.cs

@@ -1,5 +1,6 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Profile.Commands;
 
@@ -20,7 +21,7 @@ public class InsertProfileProcedureHandler(ISender sender) : IRequestHandler<Ins
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "PROFILE",
+            Entity = EntityType.Profile,
             Profile = request
         }, cancel);
     }

src/ReC.Application/Profile/Commands/UpdateProfileCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Profile.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateProfileProcedureHandler(ISender sender) : IRequestHandler<Upd
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "PROFILE",
+            Entity = EntityType.Profile,
             Id = request.Id,
             Profile = request.Data
         }, cancel);

src/ReC.Application/ReC.Application.csproj

@@ -7,7 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="15.1.0" />
+    <PackageReference Include="AutoMapper" Version="16.1.1" />
     <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.6.0" />
     <PackageReference Include="DigitalData.Core.Application" Version="3.4.0" />
     <PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.1" />

src/ReC.Application/RecActions/Commands/DeleteActionCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.RecActions.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteActionProcedureHandler(ISender sender) : IRequestHandler<Dele
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "ACTION",
+            Entity = EntityType.Action,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/RecActions/Commands/InsertActionCommand.cs

@@ -1,6 +1,7 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
 using ReC.Domain.Constants;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.RecActions.Commands;
 
@@ -27,7 +28,7 @@ public class InsertActionProcedureHandler(ISender sender) : IRequestHandler<Inse
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "ACTION",
+            Entity = EntityType.Action,
             Action = request
         }, cancel);
     }

src/ReC.Application/RecActions/Commands/InvokeBatchRecActionViewsCommand.cs

@@ -1,5 +1,6 @@
-using DigitalData.Core.Abstractions.Interfaces;
-using MediatR;
+using MediatR;
+using Microsoft.Extensions.Logging;
+using ReC.Application.Common.Exceptions;
 using ReC.Application.RecActions.Queries;
 using ReC.Domain.Constants;
 
@@ -8,15 +9,10 @@ namespace ReC.Application.RecActions.Commands;
 public record InvokeBatchRecActionViewsCommand : IRequest
 {
     public long ProfileId { get; init; }
+    public required InvokeReferences References { get; init; }
 }
 
-public static class InvokeBatchRecActionViewsCommandExtensions
-{
-    public static Task InvokeBatchRecActionView(this ISender sender, long profileId, CancellationToken cancel = default)
-        => sender.Send(new InvokeBatchRecActionViewsCommand { ProfileId = profileId }, cancel);
-}
-
-public class InvokeRecActionViewsCommandHandler(ISender sender) : IRequestHandler<InvokeBatchRecActionViewsCommand>
+public class InvokeRecActionViewsCommandHandler(ISender sender, ILogger<InvokeRecActionViewsCommandHandler>? logger = null) : IRequestHandler<InvokeBatchRecActionViewsCommand>
 {
     public async Task Handle(InvokeBatchRecActionViewsCommand request, CancellationToken cancel)
     {
@@ -26,13 +22,30 @@ public class InvokeRecActionViewsCommandHandler(ISender sender) : IRequestHandle
         {
             try
             {
-                await sender.Send(new InvokeRecActionViewCommand() { Action = action }, cancel);
+                await sender.Send(new InvokeRecActionViewCommand()
+                {
+                    Action = action,
+                    References = request.References
+                }, cancel);
             }
-            catch
+            catch (RecActionException ex)
             {
                 switch (action.ErrorAction)
                 {
                     case ErrorAction.Continue:
+                        logger?.LogWarning(ex, "Rec action failed but continuing. ActionId: {ActionId}, ProfileId: {ProfileId}", ex.ActionId, ex.ProfileId);
+                        break;
+                    default:
+                        // Rethrow the exception to stop processing further actions
+                        throw;
+                }
+            }
+            catch (Exception ex)
+            {
+                switch (action.ErrorAction)
+                {
+                    case ErrorAction.Continue:
+                        logger?.LogError(ex, "Unexpected error during rec action. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
                         break;
                     default:
                         // Rethrow the exception to stop processing further actions

src/ReC.Application/RecActions/Commands/InvokeRecActionViewCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using ReC.Application.Common.Constants;
 using ReC.Application.Common.Dto;
@@ -7,6 +8,7 @@ using ReC.Application.Common.Exceptions;
 using ReC.Application.Common.Options;
 using ReC.Application.Results.Commands;
 using ReC.Domain.Constants;
+using ReC.Domain.Views;
 using System.Net;
 using System.Net.Http.Headers;
 using System.Text;
@@ -17,13 +19,25 @@ namespace ReC.Application.RecActions.Commands;
 public record InvokeRecActionViewCommand : IRequest
 {
     public RecActionViewDto Action { get; set; } = null!;
+    public required InvokeReferences References { get; set; }
+}
+
+public record InvokeReferences
+{
+    public required string BatchId { get; init; }
+    public string? Reference1 { get; init; }
+    public string? Reference2 { get; init; }
+    public string? Reference3 { get; init; }
+    public string? Reference4 { get; init; }
+    public string? Reference5 { get; init; }
 }
 
 public class InvokeRecActionViewCommandHandler(
     IOptions<RecActionOptions> options,
     ISender sender,
     IHttpClientFactory clientFactory,
-    IConfiguration? config = null
+    IConfiguration? config = null,
+    ILogger<InvokeRecActionViewCommandHandler>? logger = null
     ) : IRequestHandler<InvokeRecActionViewCommand>
 {
     private readonly RecActionOptions _options = options.Value;
@@ -45,11 +59,47 @@ public class InvokeRecActionViewCommandHandler(
             using var httpReq = CreateHttpRequestMessage(restType, action.EndpointUri);
 
             if (action.Body is not null)
+            {
                 httpReq.Content = new StringContent(action.Body);
 
+                var contentType = action.Headers?.FirstOrDefault(h => h.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase));
+                if (contentType is not null && !string.IsNullOrWhiteSpace(contentType.Value.Value))
+                    try { httpReq.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType.Value.Value); }
+                    catch (FormatException ex)
+                    {
+                        logger?.LogWarning(ex, "Content-Type '{Value}' could not be parsed with strict validation, falling back to TryAddWithoutValidation. ActionId: {ActionId}, ProfileId: {ProfileId}", contentType.Value.Value, action.Id, action.ProfileId);
+                        httpReq.Content.Headers.TryAddWithoutValidation("Content-Type", contentType.Value.Value);
+                    }
+                else if (_options.AutoDetectHeaders)
+                {
+                    var body = action.Body.TrimStart();
+                    if (body.StartsWith('{') || body.StartsWith('['))
+                    {
+                        httpReq.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
+                        logger?.LogWarning("Content-Type header was not specified. Auto-detected 'application/json; charset=utf-8' based on body content. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
+                    }
+                    else if (body.StartsWith('<'))
+                    {
+                        httpReq.Content.Headers.ContentType = new MediaTypeHeaderValue("application/xml") { CharSet = "utf-8" };
+                        logger?.LogWarning("Content-Type header was not specified. Auto-detected 'application/xml; charset=utf-8' based on body content. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
+                    }
+                }
+            }
+
             if (action.Headers is not null)
-                foreach (var header in action.Headers)
-                    httpReq.Headers.Add(header.Key, header.Value);
+                foreach (var header in action.Headers.Where(h => !h.Key.Equals("Content-Type", StringComparison.OrdinalIgnoreCase)))
+                    try { httpReq.Headers.Add(header.Key, header.Value); }
+                    catch (FormatException ex)
+                    {
+                        logger?.LogWarning(ex, "Header '{Key}' could not be added with strict validation, falling back to TryAddWithoutValidation. ActionId: {ActionId}, ProfileId: {ProfileId}", header.Key, action.Id, action.ProfileId);
+                        httpReq.Headers.TryAddWithoutValidation(header.Key, header.Value);
+                    }
+
+            if (_options.AutoDetectHeaders && !httpReq.Headers.Contains("Accept"))
+            {
+                httpReq.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+                logger?.LogWarning("Accept header was not specified. Defaulting to 'application/json'. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
+            }
 
             switch (action.EndpointAuthType)
             {
@@ -62,7 +112,12 @@ public class InvokeRecActionViewCommandHandler(
                         switch (action.EndpointAuthApiKeyAddTo)
                         {
                             case ApiKeyLocation.Header:
-                                httpReq.Headers.Add(apiKey, apiValue);
+                                try { httpReq.Headers.Add(apiKey, apiValue); }
+                                catch (FormatException ex)
+                                {
+                                    logger?.LogWarning(ex, "ApiKey header '{Key}' could not be added with strict validation, falling back to TryAddWithoutValidation. ActionId: {ActionId}, ProfileId: {ProfileId}", apiKey, action.Id, action.ProfileId);
+                                    httpReq.Headers.TryAddWithoutValidation(apiKey, apiValue);
+                                }
                                 break;                        
                             case ApiKeyLocation.Query:                        
                                 var uriBuilder = new UriBuilder(httpReq.RequestUri!);
@@ -85,14 +140,24 @@ public class InvokeRecActionViewCommandHandler(
                 case EndpointAuthType.JwtBearer:
                 case EndpointAuthType.OAuth2:
                     if (action.EndpointAuthToken is string authToken)
-                        httpReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authToken);
+                        try { httpReq.Headers.Authorization = new AuthenticationHeaderValue("Bearer", authToken); }
+                        catch (FormatException ex)
+                        {
+                            logger?.LogWarning(ex, "Bearer token could not be set with strict validation, falling back to TryAddWithoutValidation. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
+                            httpReq.Headers.TryAddWithoutValidation("Authorization", $"Bearer {authToken}");
+                        }
                     break;
 
                 case EndpointAuthType.BasicAuth:
                     if (action.EndpointAuthUsername is string authUsername && action.EndpointAuthPassword is string authPassword)
                     {
                         var basicAuth = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{authUsername}:{authPassword}"));
-                        httpReq.Headers.Authorization = new AuthenticationHeaderValue("Basic", basicAuth);
+                        try { httpReq.Headers.Authorization = new AuthenticationHeaderValue("Basic", basicAuth); }
+                        catch (FormatException ex)
+                        {
+                            logger?.LogWarning(ex, "Basic auth could not be set with strict validation, falling back to TryAddWithoutValidation. ActionId: {ActionId}, ProfileId: {ProfileId}", action.Id, action.ProfileId);
+                            httpReq.Headers.TryAddWithoutValidation("Authorization", $"Basic {basicAuth}");
+                        }
                     }
                     break;
 
@@ -142,26 +207,30 @@ public class InvokeRecActionViewCommandHandler(
             var resBody = await response.Content.ReadAsStringAsync(cancel);
             var resHeaders = response.Headers.ToDictionary();
 
-            var statusCode = (short)response.StatusCode;
-
             await sender.Send(new InsertResultCommand()
             {
-                StatusId = statusCode,
+                Status = response.StatusCode.ToRecStatus(),
                 ActionId = action.Id,
                 Header = JsonSerializer.Serialize(resHeaders, options: new() { WriteIndented = false }),
-                Body = resBody
+                Body = resBody,
+                Info = (short)response.StatusCode,
+                Type = ResultType.Main,
+                References = request.References
             }, cancel);
         }
         catch(Exception ex)
         {
             await sender.Send(new InsertResultCommand()
             {
+                Status = RecStatus.Error,
                 ActionId = action.Id,
-                Error = ex.ToString()
+                Error = ex.ToString(),
+                Type = ResultType.Main,
+                References = request.References
             }, cancel);
 
             if (action.ErrorAction == ErrorAction.Stop)
-                throw;
+                throw new RecActionException(action.Id, action.ProfileId, ex);
         }
         finally
         {

src/ReC.Application/RecActions/Commands/UpdateActionCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.RecActions.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateActionProcedureHandler(ISender sender) : IRequestHandler<Upda
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "ACTION",
+            Entity = EntityType.Action,
             Id = request.Id,
             Action = request.Data
         }, cancel);

src/ReC.Application/Results/Commands/DeleteResultCommand.cs

@@ -1,5 +1,6 @@
 using MediatR;
 using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Results.Commands;
 
@@ -27,7 +28,7 @@ public class DeleteResultProcedureHandler(ISender sender) : IRequestHandler<Dele
     {
         return await sender.Send(new DeleteObjectProcedure
         {
-            Entity = "RESULT",
+            Entity = EntityType.Result,
             Start = request.Start,
             End = request.End,
             Force = request.Force

src/ReC.Application/Results/Commands/InsertResultCommand.cs

@@ -1,16 +1,22 @@
-using MediatR;
+using MediatR;
 using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.RecActions.Commands;
+using ReC.Domain.Constants;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Results.Commands;
 
 public record InsertResultCommand : IInsertProcedure
 {
     public long? ActionId { get; set; }
-    public short? StatusId { get; set; }
+    public required RecStatus Status { get; set; }
     public string? Header { get; set; }
     public string? Body { get; set; }
-    public string? Info { get; set; }
+    public short Info { get; set; }
+    public string? InfoDetail { get; set; }
     public string? Error { get; set; }
+    public required ResultType Type { get; set; }
+    public required InvokeReferences References { get; set; }
 }
 
 public class InsertResultProcedureHandler(ISender sender) : IRequestHandler<InsertResultCommand, long>
@@ -19,7 +25,7 @@ public class InsertResultProcedureHandler(ISender sender) : IRequestHandler<Inse
     {
         return await sender.Send(new InsertObjectProcedure
         {
-            Entity = "RESULT",
+            Entity = EntityType.Result,
             Result = request
         }, cancel);
     }

src/ReC.Application/Results/Commands/UpdateResultCommand.cs

@@ -1,6 +1,7 @@
 using MediatR;
 using ReC.Application.Common.Procedures.UpdateProcedure;
 using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
 
 namespace ReC.Application.Results.Commands;
 
@@ -17,7 +18,7 @@ public class UpdateResultProcedureHandler(ISender sender) : IRequestHandler<Upda
     {
         return await sender.Send(new UpdateObjectProcedure
         {
-            Entity = "RESULT",
+            Entity = EntityType.Result,
             Id = request.Id,
             Result = request.Data
         }, cancel);

src/ReC.Application/Results/Queries/AnyResultViewQuery.cs

@@ -0,0 +1,35 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Domain.Views;
+
+namespace ReC.Application.Results.Queries;
+
+public record AnyResultViewQuery(
+    long? Id = null,
+    long? ActionId = null,
+    long? ProfileId = null,
+    string? BatchId = null
+) : IRequest<bool>;
+
+public class AnyResultViewQueryHandler(IRepository<ResultView> repo) : IRequestHandler<AnyResultViewQuery, bool>
+{
+    public Task<bool> Handle(AnyResultViewQuery request, CancellationToken cancel)
+    {
+        var q = repo.Query;
+
+        if(request.Id is long id)
+            q = q.Where(rv => rv.Id == id);
+
+        if(request.ActionId is long actionId)
+            q = q.Where(rv => rv.ActionId == actionId);
+
+        if(request.ProfileId is long profileId)
+            q = q.Where(rv => rv.ProfileId == profileId);
+
+        if(request.BatchId is string batchId)
+            q = q.Where(rv => rv.BatchId == batchId);
+
+        return q.AnyAsync(cancel);
+    }
+}

src/ReC.Application/Results/Queries/ReadResultViewQuery.cs

@@ -17,11 +17,13 @@ public record ReadResultViewQuery : IRequest<IEnumerable<ResultViewDto>>
 
     public long? ProfileId { get; init; } = null;
 
+    public string? BatchId { get; init; } = null;
+
     public bool IncludeAction { get; init; } = true;
 
     public bool IncludeProfile { get; init; } = false;
 
-    public bool Last { get; init; } = false;
+    public bool LastBatch { get; init; } = false;
 }
 
 public class ReadResultViewQueryHandler(IRepository<ResultView> repo, IMapper mapper) : IRequestHandler<ReadResultViewQuery, IEnumerable<ResultViewDto>>
@@ -39,13 +41,18 @@ public class ReadResultViewQueryHandler(IRepository<ResultView> repo, IMapper ma
         if(request.ProfileId is long profileId)
             q = q.Where(rv => rv.ProfileId == profileId);
 
-        if(request.IncludeAction)
+        if(request.BatchId is string batchId)
+            q = q.Where(rv => rv.BatchId == batchId);
+
+        if (request.IncludeAction)
             q = q.Include(rv => rv.Action);
 
         if(request.IncludeProfile)
             q = q.Include(rv => rv.Profile);
 
-        var entities = request.Last ? [await q.OrderBy(rv => rv.AddedWhen).LastOrDefaultAsync(cancel)] : await q.ToListAsync(cancel);
+        var entities = request.LastBatch
+            ? await GetLastBatchEntitiesAsync(q, cancel)
+            : await q.ToListAsync(cancel);
 
         if (entities.Count == 0)
             throw new NotFoundException($"No result views found for the given criteria. Criteria: {
@@ -58,4 +65,20 @@ public class ReadResultViewQueryHandler(IRepository<ResultView> repo, IMapper ma
 
         return mapper.Map<IEnumerable<ResultViewDto>>(entities);
     }
+
+    private static async Task<List<ResultView>> GetLastBatchEntitiesAsync(IQueryable<ResultView> q, CancellationToken cancel)
+    {
+        var lastBatchId = await q
+            .Where(rv => rv.BatchId != null)
+            .OrderByDescending(rv => rv.AddedWhen)
+            .Select(rv => rv.BatchId)
+            .FirstOrDefaultAsync(cancel);
+
+        if (lastBatchId is null)
+            return [];
+
+        return await q
+            .Where(rv => rv.BatchId == lastBatchId)
+            .ToListAsync(cancel);
+    }
 }

src/ReC.Client/Api/BaseCrudApi.cs

@@ -2,6 +2,7 @@ using System;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -20,15 +21,37 @@ namespace ReC.Client.Api
         /// </summary>
         protected readonly string ResourcePath;
 
+        /// <summary>
+        /// An optional logger used to record API call outcomes. May be <see langword="null"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        protected readonly ILogger Logger;
+#else
+        protected readonly ILogger? Logger;
+#endif
+
+        /// <summary>
+        /// The options controlling client behavior. Never <see langword="null"/>.
+        /// </summary>
+        protected readonly ReCClientOptions Options;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="BaseCrudApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
         /// <param name="resourcePath">The base resource path for the API endpoint.</param>
-        protected BaseCrudApi(HttpClient http, string resourcePath)
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        protected BaseCrudApi(HttpClient http, string resourcePath, ILogger logger = null, ReCClientOptions options = null)
+#else
+        protected BaseCrudApi(HttpClient http, string resourcePath, ILogger? logger = null, ReCClientOptions? options = null)
+#endif
         {
             Http = http ?? throw new ArgumentNullException(nameof(http));
             ResourcePath = resourcePath ?? throw new ArgumentNullException(nameof(resourcePath));
+            Logger = logger;
+            Options = options ?? new ReCClientOptions();
         }
 
         /// <summary>
@@ -37,9 +60,15 @@ namespace ReC.Client.Api
         /// <typeparam name="T">The payload type.</typeparam>
         /// <param name="payload">The payload to send.</param>
         /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> CreateAsync<T>(T payload, CancellationToken cancel = default)
-            => Http.PostAsync(ResourcePath, ReCClientHelpers.ToJsonContent(payload), cancel);
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+        public async Task CreateAsync<T>(T payload, CancellationToken cancel = default)
+        {
+            using (var content = ReCClientHelpers.ToJsonContent(payload))
+            using (var resp = await Http.PostAsync(ResourcePath, content, cancel))
+            {
+                await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+            }
+        }
 
         /// <summary>
         /// Updates a resource by identifier.
@@ -48,24 +77,31 @@ namespace ReC.Client.Api
         /// <param name="id">The resource identifier.</param>
         /// <param name="payload">The payload to send.</param>
         /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> UpdateAsync<T>(long id, T payload, CancellationToken cancel = default)
-            => Http.PutAsync($"{ResourcePath}/{id}", ReCClientHelpers.ToJsonContent(payload), cancel);
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+        public async Task UpdateAsync<T>(long id, T payload, CancellationToken cancel = default)
+        {
+            using (var content = ReCClientHelpers.ToJsonContent(payload))
+            using (var resp = await Http.PutAsync($"{ResourcePath}/{id}", content, cancel))
+            {
+                await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+            }
+        }
 
         /// <summary>
-        /// Deletes resources with identifiers supplied in the payload.
+        /// Deletes resources with identifiers supplied in the payload. The payload is serialized into
+        /// the query string because the API binds delete payloads from the URL query.
         /// </summary>
         /// <typeparam name="T">The payload type containing identifiers.</typeparam>
         /// <param name="payload">The payload to send.</param>
         /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> DeleteAsync<T>(T payload, CancellationToken cancel = default)
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+        public async Task DeleteAsync<T>(T payload, CancellationToken cancel = default)
         {
-            var request = new HttpRequestMessage(HttpMethod.Delete, ResourcePath)
+            var query = ReCClientHelpers.BuildQueryFromObject(payload);
+            using (var resp = await Http.DeleteAsync($"{ResourcePath}{query}", cancel))
             {
-                Content = ReCClientHelpers.ToJsonContent(payload)
-            };
-            return Http.SendAsync(request, cancel);
+                await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+            }
         }
     }
 }

src/ReC.Client/Api/CommonApi.cs

@@ -1,11 +1,14 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
     /// <summary>
-    /// Provides access to common object endpoints.
+    /// Provides access to common object endpoints. The Common API binds update and delete
+    /// payloads from the body / query string (no id route segment), so the inherited CRUD
+    /// helpers from <see cref="BaseCrudApi"/> are hidden with overloads that match the API.
     /// </summary>
     public class CommonApi : BaseCrudApi
     {
@@ -13,8 +16,32 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="CommonApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public CommonApi(HttpClient http) : base(http, "api/Common")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public CommonApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/Common", logger, options)
+#else
+        public CommonApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/Common", logger, options)
+#endif
         {
         }
+
+        /// <summary>
+        /// Updates an object via the Common update procedure. The identifier is expected to be
+        /// part of <paramref name="payload"/> rather than the URL.
+        /// </summary>
+        /// <typeparam name="T">The payload type.</typeparam>
+        /// <param name="payload">The payload to send.</param>
+        /// <param name="cancel">A token to cancel the operation.</param>
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+        public async Task UpdateAsync<T>(T payload, CancellationToken cancel = default)
+        {
+            using (var content = ReCClientHelpers.ToJsonContent(payload))
+            using (var resp = await Http.PutAsync(ResourcePath, content, cancel))
+            {
+                await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+            }
+        }
     }
 }
+

src/ReC.Client/Api/EndpointAuthApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,7 +14,13 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="EndpointAuthApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public EndpointAuthApi(HttpClient http) : base(http, "api/EndpointAuth")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public EndpointAuthApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/EndpointAuth", logger, options)
+#else
+        public EndpointAuthApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/EndpointAuth", logger, options)
+#endif
         {
         }
     }

src/ReC.Client/Api/EndpointParamsApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,7 +14,13 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="EndpointParamsApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public EndpointParamsApi(HttpClient http) : base(http, "api/EndpointParams")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public EndpointParamsApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/EndpointParams", logger, options)
+#else
+        public EndpointParamsApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/EndpointParams", logger, options)
+#endif
         {
         }
     }

src/ReC.Client/Api/EndpointsApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,7 +14,13 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="EndpointsApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public EndpointsApi(HttpClient http) : base(http, "api/Endpoints")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public EndpointsApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/Endpoints", logger, options)
+#else
+        public EndpointsApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/Endpoints", logger, options)
+#endif
         {
         }
     }

src/ReC.Client/Api/InvokeReferences.cs

@@ -0,0 +1,50 @@
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Optional reference values that are passed through to all result records when invoking a profile.
+    /// </summary>
+    public class InvokeReferences
+    {
+        /// <summary>Batch identifier.</summary>
+        public string
+#if NET
+            ?
+#endif
+            BatchId { get; set; }
+
+        /// <summary>Reference value 1.</summary>
+        public string
+#if NET
+            ?
+#endif
+            Reference1 { get; set; }
+
+        /// <summary>Reference value 2.</summary>
+        public string
+#if NET
+            ?
+#endif
+            Reference2 { get; set; }
+
+        /// <summary>Reference value 3.</summary>
+        public string
+#if NET
+            ?
+#endif
+            Reference3 { get; set; }
+
+        /// <summary>Reference value 4.</summary>
+        public string
+#if NET
+            ?
+#endif
+            Reference4 { get; set; }
+
+        /// <summary>Reference value 5.</summary>
+        public string
+#if NET
+            ?
+#endif
+            Reference5 { get; set; }
+    }
+}

src/ReC.Client/Api/ProfileApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,21 +14,45 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="ProfileApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public ProfileApi(HttpClient http) : base(http, "api/Profile")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public ProfileApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/Profile", logger, options)
+#else
+        public ProfileApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/Profile", logger, options)
+#endif
         {
         }
 
         /// <summary>
-        /// Retrieves a profile by identifier.
+        /// Retrieves profiles and deserializes the JSON response into <typeparamref name="T"/>.
         /// </summary>
-        /// <param name="id">The profile identifier.</param>
-        /// <param name="includeActions">Whether to include related actions.</param>
-        /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> GetAsync(long id, bool includeActions = false, CancellationToken cancel = default)
+#if NETFRAMEWORK
+        public async Task<T> GetAsync<T>(long? id = null, bool includeActions = true, CancellationToken cancel = default)
+#else
+        public async Task<T?> GetAsync<T>(long? id = null, bool includeActions = true, CancellationToken cancel = default)
+#endif
         {
             var query = ReCClientHelpers.BuildQuery(("Id", id), ("IncludeActions", includeActions));
-            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+            using (var resp = await Http.GetAsync($"{ResourcePath}{query}", cancel).ConfigureAwait(false))
+            {
+                var body = await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+                return ReCClientHelpers.Deserialize<T>(body);
+            }
+        }
+
+    /// <summary>
+    /// Retrieves profiles and returns a dynamically deserialized payload
+    /// (typically a <see cref="System.Text.Json.JsonElement"/>). This is the non-generic
+    /// overload of <see cref="GetAsync{T}"/>.
+    /// </summary>
+#if NETFRAMEWORK
+    public Task<dynamic> GetAsync(long? id = null, bool includeActions = true, CancellationToken cancel = default)
+#else
+    public Task<dynamic?> GetAsync(long? id = null, bool includeActions = true, CancellationToken cancel = default)
+#endif
+    {
+        return GetAsync<object>(id, includeActions, cancel);
     }
     }
 }

src/ReC.Client/Api/RecActionApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,33 +14,78 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="RecActionApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public RecActionApi(HttpClient http) : base(http, "api/RecAction")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public RecActionApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/RecAction", logger, options)
+#else
+        public RecActionApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/RecAction", logger, options)
+#endif
         {
         }
 
         /// <summary>
-        /// Invokes a ReC action for the specified profile.
+        /// Invokes a batch of RecActions for the specified profile.
         /// </summary>
         /// <param name="profileId">The profile identifier.</param>
+        /// <param name="references">Optional reference values to pass through to all result records.</param>
         /// <param name="cancellationToken">A token to cancel the operation.</param>
-        /// <returns><see langword="true"/> if the request succeeds; otherwise, <see langword="false"/>.</returns>
-        public async Task<bool> InvokeAsync(int profileId, CancellationToken cancellationToken = default)
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+#if NETFRAMEWORK
+        public async Task InvokeAsync(long profileId, InvokeReferences references = null, CancellationToken cancellationToken = default)
+#else
+        public async Task InvokeAsync(long profileId, InvokeReferences? references = null, CancellationToken cancellationToken = default)
+#endif
         {
-            var resp = await Http.PostAsync($"{ResourcePath}/invoke/{profileId}", content: null, cancellationToken);
-            return resp.IsSuccessStatusCode;
+            var content = references != null ? ReCClientHelpers.ToJsonContent(references) : null;
+            using (content)
+            using (var resp = await Http.PostAsync($"{ResourcePath}/invoke/{profileId}", content, cancellationToken))
+            {
+                await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancellationToken).ConfigureAwait(false);
+            }
         }
 
         /// <summary>
-        /// Retrieves Rec actions.
+        /// Invokes a batch of RecActions for the specified profile.
         /// </summary>
-        /// <param name="profileId">Optional profile filter.</param>
-        /// <param name="invoked">Optional invoked filter.</param>
-        /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> GetAsync(long? profileId = null, bool? invoked = null, CancellationToken cancel = default)
+        /// <param name="profileId">The profile identifier.</param>
+        /// <param name="batchId">Batch identifier.</param>
+        /// <param name="cancellationToken">A token to cancel the operation.</param>
+        /// <exception cref="ReCApiException">Thrown when the API responds with a non-success status code.</exception>
+        public Task InvokeAsync(long profileId, string batchId, CancellationToken cancellationToken = default)
+        {
+            return InvokeAsync(profileId, new InvokeReferences() { BatchId = batchId }, cancellationToken);
+        }
+
+        /// <summary>
+        /// Retrieves Rec actions and deserializes the JSON response into <typeparamref name="T"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public async Task<T> GetAsync<T>(long? profileId = null, bool? invoked = null, CancellationToken cancel = default)
+#else
+        public async Task<T?> GetAsync<T>(long? profileId = null, bool? invoked = null, CancellationToken cancel = default)
+#endif
         {
             var query = ReCClientHelpers.BuildQuery(("ProfileId", profileId), ("Invoked", invoked));
-            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+            using (var resp = await Http.GetAsync($"{ResourcePath}{query}", cancel).ConfigureAwait(false))
+            {
+                var body = await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+                return ReCClientHelpers.Deserialize<T>(body);
+            }
+        }
+
+        /// <summary>
+        /// Retrieves Rec actions and returns a dynamically deserialized payload
+        /// (typically a <see cref="System.Text.Json.JsonElement"/>). This is the non-generic
+        /// overload of <see cref="GetAsync{T}"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public Task<dynamic> GetAsync(long? profileId = null, bool? invoked = null, CancellationToken cancel = default)
+#else
+        public Task<dynamic?> GetAsync(long? profileId = null, bool? invoked = null, CancellationToken cancel = default)
+#endif
+        {
+            return GetAsync<object>(profileId, invoked, cancel);
         }
     }
 }

src/ReC.Client/Api/ResultApi.cs

@@ -1,6 +1,7 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client.Api
 {
@@ -13,22 +14,53 @@ namespace ReC.Client.Api
         /// Initializes a new instance of the <see cref="ResultApi"/> class.
         /// </summary>
         /// <param name="http">The HTTP client used for requests.</param>
-        public ResultApi(HttpClient http) : base(http, "api/Result")
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+#if NETFRAMEWORK
+        public ResultApi(HttpClient http, ILogger logger = null, ReCClientOptions options = null) : base(http, "api/Result", logger, options)
+#else
+        public ResultApi(HttpClient http, ILogger? logger = null, ReCClientOptions? options = null) : base(http, "api/Result", logger, options)
+#endif
         {
         }
 
         /// <summary>
-        /// Retrieves results with optional filters.
+        /// Retrieves results with optional filters and deserializes the JSON response into <typeparamref name="T"/>.
         /// </summary>
-        /// <param name="id">Optional result identifier.</param>
-        /// <param name="actionId">Optional action identifier.</param>
-        /// <param name="profileId">Optional profile identifier.</param>
-        /// <param name="cancel">A token to cancel the operation.</param>
-        /// <returns>The HTTP response message.</returns>
-        public Task<HttpResponseMessage> GetAsync(long? id = null, long? actionId = null, long? profileId = null, CancellationToken cancel = default)
+#if NETFRAMEWORK
+        public async Task<T> GetAsync<T>(long? id = null, long? actionId = null, long? profileId = null, string batchId = null, bool includeAction = true, bool includeProfile = false, bool lastBatch = false, CancellationToken cancel = default)
+#else
+        public async Task<T?> GetAsync<T>(long? id = null, long? actionId = null, long? profileId = null, string? batchId = null, bool includeAction = true, bool includeProfile = false, bool lastBatch = false, CancellationToken cancel = default)
+#endif
         {
-            var query = ReCClientHelpers.BuildQuery(("Id", id), ("ActionId", actionId), ("ProfileId", profileId));
-            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+            var query = ReCClientHelpers.BuildQuery(
+                ("Id", id),
+                ("ActionId", actionId),
+                ("ProfileId", profileId),
+                ("BatchId", batchId),
+                ("IncludeAction", includeAction),
+                ("IncludeProfile", includeProfile),
+                ("LastBatch", lastBatch));
+
+            using (var resp = await Http.GetAsync($"{ResourcePath}{query}", cancel).ConfigureAwait(false))
+            {
+                var body = await ReCClientHelpers.HandleResponseAsync(resp, Logger, Options.LogSuccessfulRequests, cancel).ConfigureAwait(false);
+                return ReCClientHelpers.Deserialize<T>(body);
+            }
+        }
+
+    /// <summary>
+    /// Retrieves results with optional filters and returns a dynamically deserialized payload
+    /// (typically a <see cref="System.Text.Json.JsonElement"/>). This is the non-generic
+    /// overload of <see cref="GetAsync{T}"/>.
+    /// </summary>
+#if NETFRAMEWORK
+    public Task<dynamic> GetAsync(long? id = null, long? actionId = null, long? profileId = null, string batchId = null, bool includeAction = true, bool includeProfile = false, bool lastBatch = false, CancellationToken cancel = default)
+#else
+    public Task<dynamic?> GetAsync(long? id = null, long? actionId = null, long? profileId = null, string? batchId = null, bool includeAction = true, bool includeProfile = false, bool lastBatch = false, CancellationToken cancel = default)
+#endif
+    {
+        return GetAsync<object>(id, actionId, profileId, batchId, includeAction, includeProfile, lastBatch, cancel);
     }
     }
 }

src/ReC.Client/DependencyInjection.cs

@@ -1,6 +1,6 @@
 using Microsoft.Extensions.DependencyInjection;
-#if NETFRAMEWORK
 using System;
+#if NETFRAMEWORK
 using System.Net.Http;
 #endif
 
@@ -16,9 +16,15 @@ namespace ReC.Client
         /// </summary>
         /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
         /// <param name="apiUri">The base URI of the ReC API.</param>
+        /// <param name="configureOptions">An optional action to configure <see cref="ReCClientOptions"/>. When omitted, defaults are used.</param>
         /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
-        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri)
+#if NETFRAMEWORK
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri, Action<ReCClientOptions> configureOptions = null)
+#else
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri, Action<ReCClientOptions>? configureOptions = null)
+#endif
         {
+            AddRecClientOptions(services, configureOptions);
             services.AddScoped<ReCClient>();
             return services.AddHttpClient(ReCClient.ClientName, client =>
             {
@@ -31,11 +37,29 @@ namespace ReC.Client
         /// </summary>
         /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
         /// <param name="configureClient">An action to configure the <see cref="HttpClient"/>.</param>
+        /// <param name="configureOptions">An optional action to configure <see cref="ReCClientOptions"/>. When omitted, defaults are used.</param>
         /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
-        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient)
+#if NETFRAMEWORK
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient, Action<ReCClientOptions> configureOptions = null)
+#else
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient, Action<ReCClientOptions>? configureOptions = null)
+#endif
         {
+            AddRecClientOptions(services, configureOptions);
             services.AddScoped<ReCClient>();
             return services.AddHttpClient(ReCClient.ClientName, configureClient);
         }
+
+#if NETFRAMEWORK
+        private static void AddRecClientOptions(IServiceCollection services, Action<ReCClientOptions> configureOptions)
+#else
+        private static void AddRecClientOptions(IServiceCollection services, Action<ReCClientOptions>? configureOptions)
+#endif
+        {
+            // Ensure default options are always registered even when the caller does not configure anything.
+            var builder = services.AddOptions<ReCClientOptions>();
+            if (configureOptions != null)
+                builder.Configure(configureOptions);
+        }
     }
 }

src/ReC.Client/ReC.Client.csproj

@@ -10,10 +10,10 @@
 		<Copyright>Copyright 2025</Copyright>
 		<PackageIcon>icon.png</PackageIcon>
 		<RepositoryUrl>http://git.dd:3000/AppStd/Rec.git</RepositoryUrl>
-		<PackageTags>digital data rec api</PackageTags>
-		<Version>1.0.0-beta</Version>
-		<AssemblyVersion>1.0.0.0</AssemblyVersion>
-		<FileVersion>1.0.0.0</FileVersion>
+		<PackageTags>digital data rec api client</PackageTags>
+		<Version>2.0.0-beta</Version>
+		<AssemblyVersion>2.0.0.0</AssemblyVersion>
+		<FileVersion>2.0.0.0</FileVersion>
 		<Description>Client-Bibliothek für die Interaktion mit der ReC.API, die typisierten HTTP-Zugriff und DI-Integration bietet.</Description>
 	</PropertyGroup>
 

src/ReC.Client/ReCApiException.cs

@@ -0,0 +1,88 @@
+using System;
+using System.Net;
+using System.Net.Http;
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Represents an error returned by the ReC API.
+    /// </summary>
+#if !NETFRAMEWORK
+    [Serializable]
+#endif
+    public class ReCApiException : Exception
+    {
+        /// <summary>
+        /// The HTTP status code returned by the API.
+        /// </summary>
+        public HttpStatusCode StatusCode { get; }
+
+        /// <summary>
+        /// The HTTP reason phrase returned by the API, if any.
+        /// </summary>
+#if NETFRAMEWORK
+        public string ReasonPhrase { get; }
+#else
+        public string? ReasonPhrase { get; }
+#endif
+
+        /// <summary>
+        /// The raw response body returned by the API, if any.
+        /// </summary>
+#if NETFRAMEWORK
+        public string ResponseBody { get; }
+#else
+        public string? ResponseBody { get; }
+#endif
+
+        /// <summary>
+        /// The HTTP method used for the failed request.
+        /// </summary>
+#if NETFRAMEWORK
+        public string Method { get; }
+#else
+        public string? Method { get; }
+#endif
+
+        /// <summary>
+        /// The request URI that was called.
+        /// </summary>
+#if NETFRAMEWORK
+        public Uri RequestUri { get; }
+#else
+        public Uri? RequestUri { get; }
+#endif
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReCApiException"/> class.
+        /// </summary>
+        /// <param name="message">A summary message describing the error.</param>
+        /// <param name="statusCode">The HTTP status code returned by the API.</param>
+        /// <param name="reasonPhrase">The HTTP reason phrase returned by the API.</param>
+        /// <param name="responseBody">The raw response body returned by the API.</param>
+        /// <param name="method">The HTTP method used for the request.</param>
+        /// <param name="requestUri">The request URI that was called.</param>
+        public ReCApiException(
+            string message,
+            HttpStatusCode statusCode,
+#if NETFRAMEWORK
+            string reasonPhrase,
+            string responseBody,
+            string method,
+            Uri requestUri
+#else
+            string? reasonPhrase,
+            string? responseBody,
+            string? method,
+            Uri? requestUri
+#endif
+            ) : base(message)
+        {
+            StatusCode = statusCode;
+            ReasonPhrase = reasonPhrase;
+            ResponseBody = responseBody;
+            Method = method;
+            RequestUri = requestUri;
+        }
+    }
+}

src/ReC.Client/ReCClient.Static.cs

@@ -0,0 +1,142 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Net.Http;
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Static convenience entry-point for building and resolving a <see cref="ReCClient"/> without an
+    /// externally provided <see cref="IServiceProvider"/>. Intended for legacy scenarios (e.g. .NET Framework
+    /// codebases without an established DI container). For new code, prefer
+    /// <see cref="DependencyInjection.AddRecClient(IServiceCollection, string, Action{ReCClientOptions})"/>.
+    /// </summary>
+    public partial class ReCClient
+    {
+#if NET8_0_OR_GREATER
+        private static Action<IServiceCollection>? _staticConfigure = null;
+#else
+        private static Action<IServiceCollection> _staticConfigure = null;
+#endif
+
+        private static readonly Lazy<IServiceProvider> LazyProvider = new Lazy<IServiceProvider>(() =>
+        {
+            var configure = _staticConfigure
+                ?? throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
+
+            var services = new ServiceCollection();
+            configure(services);
+            return services.BuildServiceProvider();
+        }, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
+
+        /// <summary>
+        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be called once during application startup. The underlying
+        /// <see cref="IServiceProvider"/> is created lazily and thread-safely on first access via <see cref="Create"/>.
+        /// </remarks>
+        /// <param name="configure">Callback that populates a <see cref="StaticBuildConfiguration"/> instance.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="configure"/> is null.</exception>
+        /// <exception cref="InvalidOperationException">Thrown when neither <see cref="StaticBuildConfiguration.BaseAddress"/> nor <see cref="StaticBuildConfiguration.ConfigureClient"/> is set, when both are set, or when the static provider has already been built.</exception>
+        [Obsolete("Use a local service collection instead of the static provider.")]
+        public static void BuildStaticClient(Action<StaticBuildConfiguration> configure)
+        {
+            if (configure == null)
+                throw new ArgumentNullException(nameof(configure));
+
+            var cfg = new StaticBuildConfiguration();
+            configure(cfg);
+
+            var hasBaseAddress = !string.IsNullOrWhiteSpace(cfg.BaseAddress);
+            var hasConfigureClient = cfg.ConfigureClient != null;
+
+            if (!hasBaseAddress && !hasConfigureClient)
+                throw new InvalidOperationException(
+                    $"Either {nameof(StaticBuildConfiguration.BaseAddress)} or {nameof(StaticBuildConfiguration.ConfigureClient)} must be set on {nameof(StaticBuildConfiguration)}.");
+
+            if (hasBaseAddress && hasConfigureClient)
+                throw new InvalidOperationException(
+                    $"{nameof(StaticBuildConfiguration.BaseAddress)} and {nameof(StaticBuildConfiguration.ConfigureClient)} are mutually exclusive on {nameof(StaticBuildConfiguration)}.");
+
+            Action<IServiceCollection> register = services =>
+            {
+                if (hasBaseAddress)
+                    services.AddRecClient(cfg.BaseAddress, cfg.ConfigureOptions);
+                else
+                    services.AddRecClient(cfg.ConfigureClient, cfg.ConfigureOptions);
+
+                if (cfg.Logger != null)
+                    services.AddSingleton(cfg.Logger);
+
+                cfg.ConfigureServices?.Invoke(services);
+            };
+
+            if (System.Threading.Interlocked.CompareExchange(ref _staticConfigure, register, null) != null)
+                throw new InvalidOperationException("Static Provider is already built.");
+        }
+
+        /// <summary>
+        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be called once during application startup.
+        /// The underlying <see cref="IServiceProvider"/> is created lazily and thread-safely on first access via <see cref="Create"/>.
+        /// </remarks>
+        /// <param name="apiUri">The base URI of the ReC API.</param>
+        /// <param name="configureOptions">An optional callback to configure <see cref="ReCClientOptions"/>.</param>
+        /// <param name="logger">An optional <see cref="ILogger"/> instance to be used by the <see cref="ReCClient"/>. When provided, it is registered as a singleton in the internal service collection.</param>
+        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
+        [Obsolete("Use BuildStaticClient(Action<StaticBuildConfiguration>) instead.")]
+#if NETFRAMEWORK
+        public static void BuildStaticClient(string apiUri, Action<ReCClientOptions> configureOptions = null, ILogger logger = null)
+#else
+        public static void BuildStaticClient(string apiUri, Action<ReCClientOptions>? configureOptions = null, ILogger<ReCClient>? logger = null)
+#endif
+        {
+            BuildStaticClient(cfg =>
+            {
+                cfg.BaseAddress = apiUri;
+                cfg.ConfigureOptions = configureOptions;
+                cfg.Logger = logger;
+            });
+        }
+
+        /// <summary>
+        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be called once during application startup.
+        /// The underlying <see cref="IServiceProvider"/> is created lazily and thread-safely on first access via <see cref="Create"/>.
+        /// </remarks>
+        /// <param name="configureClient">An action to configure the <see cref="HttpClient"/>.</param>
+        /// <param name="configureOptions">An optional callback to configure <see cref="ReCClientOptions"/>.</param>
+        /// <param name="logger">An optional <see cref="ILogger"/> instance to be used by the <see cref="ReCClient"/>. When provided, it is registered as a singleton in the internal service collection.</param>
+        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
+        [Obsolete("Use BuildStaticClient(Action<StaticBuildConfiguration>) instead.")]
+#if NETFRAMEWORK
+        public static void BuildStaticClient(Action<HttpClient> configureClient, Action<ReCClientOptions> configureOptions = null, ILogger logger = null)
+#else
+        public static void BuildStaticClient(Action<HttpClient> configureClient, Action<ReCClientOptions>? configureOptions = null, ILogger<ReCClient>? logger = null)
+#endif
+        {
+            BuildStaticClient(cfg =>
+            {
+                cfg.ConfigureClient = configureClient;
+                cfg.ConfigureOptions = configureOptions;
+                cfg.Logger = logger;
+            });
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="ReCClient"/> instance using the statically configured provider.
+        /// </summary>
+        /// <returns>A new instance of the <see cref="ReCClient"/>.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if <see cref="BuildStaticClient(Action{StaticBuildConfiguration})"/> has not been called yet.</exception>
+        [Obsolete("Use a local service collection instead of the static provider.")]
+        public static ReCClient Create()
+        {
+            return LazyProvider.Value.GetRequiredService<ReCClient>();
+        }
+    }
+}

src/ReC.Client/ReCClient.cs

@@ -1,4 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using System;
 using System.Net.Http;
 using ReC.Client.Api;
@@ -8,7 +10,7 @@ namespace ReC.Client
     /// <summary>
     /// A client for interacting with the ReC API.
     /// </summary>
-    public class ReCClient
+    public partial class ReCClient
     {
         private readonly HttpClient _http;
 
@@ -56,77 +58,31 @@ namespace ReC.Client
         /// Initializes a new instance of the <see cref="ReCClient"/> class.
         /// </summary>
         /// <param name="httpClientFactory">The factory to create HttpClients.</param>
-        public ReCClient(IHttpClientFactory httpClientFactory)
+        /// <param name="options">An optional set of client options. Defaults are used when omitted.</param>
+        /// <param name="logger">An optional logger used to record API call outcomes.</param>
+#if NETFRAMEWORK
+        public ReCClient(IHttpClientFactory httpClientFactory, IOptions<ReCClientOptions> options = null, ILogger logger = null)
+#else
+        public ReCClient(IHttpClientFactory httpClientFactory, IOptions<ReCClientOptions>? options = null, ILogger<ReCClient>? logger = null)
+#endif
         {
             _http = httpClientFactory.CreateClient(ClientName);
-            RecActions = new RecActionApi(_http);
-            Results = new ResultApi(_http);
-            Profiles = new ProfileApi(_http);
-            EndpointAuth = new EndpointAuthApi(_http);
-            EndpointParams = new EndpointParamsApi(_http);
-            Endpoints = new EndpointsApi(_http);
-            Common = new CommonApi(_http);
+            var opts = options?.Value ?? new ReCClientOptions();
+
+            if (opts.LogSuccessfulRequests && logger == null)
+                throw new InvalidOperationException(
+                    $"{nameof(ReCClientOptions.LogSuccessfulRequests)} is enabled, but no {nameof(ILogger)} was injected into {nameof(ReCClient)}. " +
+                    $"Register a logging provider (e.g. services.AddLogging()) so that an {nameof(ILogger)} can be resolved, " +
+                    $"or set {nameof(ReCClientOptions.LogSuccessfulRequests)} to false.");
+
+            RecActions = new RecActionApi(_http, logger, opts);
+            Results = new ResultApi(_http, logger, opts);
+            Profiles = new ProfileApi(_http, logger, opts);
+            EndpointAuth = new EndpointAuthApi(_http, logger, opts);
+            EndpointParams = new EndpointParamsApi(_http, logger, opts);
+            Endpoints = new EndpointsApi(_http, logger, opts);
+            Common = new CommonApi(_http, logger, opts);
         }
-
-        #region Static
-        private static readonly IServiceCollection Services = new ServiceCollection();
-
-#if NET8_0_OR_GREATER
-        private static IServiceProvider? Provider = null;
-#else
-        private static IServiceProvider Provider = null;
-#endif
-
-        /// <summary>
-        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
-        /// </summary>
-        /// <remarks>
-        /// This method should only be called once during application startup.
-        /// </remarks>
-        /// <param name="apiUri">The base URI of the ReC API.</param>
-        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
-        [Obsolete("Use a local service collection instead of the static provider.")]
-        public static void BuildStaticClient(string apiUri)
-        {
-            if(Provider != null)
-                throw new InvalidOperationException("Static Provider is already built.");
-
-            Services.AddRecClient(apiUri);
-            Provider = Services.BuildServiceProvider();
-        }
-
-        /// <summary>
-        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
-        /// </summary>
-        /// <remarks>
-        /// This method should only be called once during application startup.
-        /// </remarks>
-        /// <param name="configureClient">An action to configure the <see cref="HttpClient"/>.</param>
-        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
-        [Obsolete("Use a local service collection instead of the static provider.")]
-        public static void BuildStaticClient(Action<HttpClient> configureClient)
-        {
-            if (Provider != null)
-                throw new InvalidOperationException("Static Provider is already built.");
-
-            Services.AddRecClient(configureClient);
-            Provider = Services.BuildServiceProvider();
-        }
-
-        /// <summary>
-        /// Creates a new <see cref="ReCClient"/> instance using the statically configured provider.
-        /// </summary>
-        /// <returns>A new instance of the <see cref="ReCClient"/>.</returns>
-        /// <exception cref="InvalidOperationException">Thrown if <see cref="BuildStaticClient(string)"/> has not been called yet.</exception>
-        [Obsolete("Use a local service collection instead of the static provider.")]
-        public static ReCClient Create()
-        {
-            if (Provider == null)
-                throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
-
-            return Provider.GetRequiredService<ReCClient>();
-        }
-        #endregion
     }
 
     /// <summary>

src/ReC.Client/ReCClientHelpers.cs

@@ -1,11 +1,14 @@
 using System;
+using System.Collections;
 using System.Globalization;
 using System.Linq;
-using System.Net.Http.Json;
-
-#if NETFRAMEWORK
 using System.Net.Http;
-#endif
+using System.Net.Http.Json;
+using System.Reflection;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
 
 namespace ReC.Client
 {
@@ -45,5 +48,110 @@ namespace ReC.Client
         /// <param name="payload">The payload to serialize.</param>
         /// <returns>A <see cref="JsonContent"/> instance ready for HTTP requests.</returns>
         public static JsonContent ToJsonContent<T>(T payload) => JsonContent.Create(payload);
+
+        /// <summary>
+        /// Builds a query string from the public readable properties of <paramref name="payload"/>,
+        /// skipping properties whose values are <see langword="null"/>.
+        /// </summary>
+        /// <typeparam name="T">The payload type.</typeparam>
+        /// <param name="payload">The payload to serialize into a query string.</param>
+        /// <returns>A query string beginning with '?', or an empty string if no values are provided.</returns>
+        public static string BuildQueryFromObject<T>(T payload)
+        {
+            if (payload == null)
+                return string.Empty;
+
+            var props = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Where(p => p.CanRead && p.GetIndexParameters().Length == 0);
+
+            var parts = props
+                .Select(p => new { p.Name, Value = p.GetValue(payload) })
+                .Where(p => p.Value != null)
+                .Select(p => $"{Uri.EscapeDataString(p.Name)}={Uri.EscapeDataString(Convert.ToString(p.Value, CultureInfo.InvariantCulture) ?? string.Empty)}");
+
+            var query = string.Join("&", parts);
+            return string.IsNullOrWhiteSpace(query) ? string.Empty : $"?{query}";
+        }
+
+        /// <summary>
+        /// JSON serializer options used when deserializing API responses.
+        /// </summary>
+        public static readonly JsonSerializerOptions JsonOptions = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+            PropertyNameCaseInsensitive = true,
+        };
+
+        /// <summary>
+        /// Reads the response body and logs the outcome. Throws a <see cref="ReCApiException"/> when
+        /// the response indicates a non-success status code.
+        /// </summary>
+#if NETFRAMEWORK
+        public static async Task<string> HandleResponseAsync(HttpResponseMessage response, ILogger logger = null, bool logSuccess = true, CancellationToken cancel = default)
+#else
+        public static async Task<string?> HandleResponseAsync(HttpResponseMessage response, ILogger? logger = null, bool logSuccess = true, CancellationToken cancel = default)
+#endif
+        {
+            var request = response.RequestMessage;
+            var method = request?.Method?.Method;
+            var uri = request?.RequestUri;
+            var statusCode = (int)response.StatusCode;
+
+#if NETFRAMEWORK
+            string body = null;
+#else
+            string? body = null;
+#endif
+            if (response.Content != null)
+            {
+                try
+                {
+#if NETFRAMEWORK
+                    body = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
+#else
+                    body = await response.Content.ReadAsStringAsync(cancel).ConfigureAwait(false);
+#endif
+                }
+                catch
+                {
+                }
+            }
+
+            if (response.IsSuccessStatusCode)
+            {
+                if (logSuccess)
+                {
+                    logger?.LogInformation(
+                        "ReC API request succeeded. {Method} {Uri} -> {StatusCode} ({ReasonPhrase})",
+                        method,
+                        uri,
+                        statusCode,
+                        response.ReasonPhrase);
+                }
+
+                return body;
+            }
+
+            var message = $"ReC API request failed with status {statusCode} ({response.ReasonPhrase}). "
+                + $"{method} {uri}"
+                + (string.IsNullOrWhiteSpace(body) ? string.Empty : $": {body}");
+
+            throw new ReCApiException(message, response.StatusCode, response.ReasonPhrase, body, method, uri);
+        }
+
+        /// <summary>
+        /// Deserializes a JSON body string into <typeparamref name="T"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public static T Deserialize<T>(string body)
+#else
+        public static T? Deserialize<T>(string? body)
+#endif
+        {
+            if (string.IsNullOrWhiteSpace(body))
+                return default;
+
+            return JsonSerializer.Deserialize<T>(body, JsonOptions);
+        }
     }
 }

src/ReC.Client/ReCClientOptions.cs

@@ -0,0 +1,16 @@
+namespace ReC.Client
+{
+    /// <summary>
+    /// Options that control the behavior of the <see cref="ReCClient"/>.
+    /// </summary>
+    public class ReCClientOptions
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether successful API requests should be
+        /// logged through the injected <see cref="Microsoft.Extensions.Logging.ILogger"/>.
+        /// Failed requests always throw <see cref="ReCApiException"/> regardless of this setting.
+        /// Defaults to <see langword="true"/>.
+        /// </summary>
+        public bool LogSuccessfulRequests { get; set; } = true;
+    }
+}

src/ReC.Client/StaticBuildConfiguration.cs

@@ -0,0 +1,63 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Net.Http;
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Configuration object for <see cref="ReCClient.BuildStaticClient(Action{StaticBuildConfiguration})"/>.
+    /// Groups all optional settings for the static <see cref="ReCClient"/> bootstrap path.
+    /// </summary>
+    /// <remarks>
+    /// Either <see cref="BaseAddress"/> or <see cref="ConfigureClient"/> must be set; setting both at the same time is not allowed.
+    /// </remarks>
+    public class StaticBuildConfiguration
+    {
+        /// <summary>
+        /// Base URI of the ReC API. Mutually exclusive with <see cref="ConfigureClient"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public string BaseAddress { get; set; }
+#else
+        public string? BaseAddress { get; set; }
+#endif
+
+        /// <summary>
+        /// Callback that configures the underlying <see cref="HttpClient"/>. Mutually exclusive with <see cref="BaseAddress"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public Action<HttpClient> ConfigureClient { get; set; }
+#else
+        public Action<HttpClient>? ConfigureClient { get; set; }
+#endif
+
+        /// <summary>
+        /// Optional callback to configure <see cref="ReCClientOptions"/>.
+        /// </summary>
+#if NETFRAMEWORK
+        public Action<ReCClientOptions> ConfigureOptions { get; set; }
+#else
+        public Action<ReCClientOptions>? ConfigureOptions { get; set; }
+#endif
+
+        /// <summary>
+        /// Optional logger instance to be registered as a singleton in the internal service collection.
+        /// </summary>
+#if NETFRAMEWORK
+        public ILogger Logger { get; set; }
+#else
+        public ILogger<ReCClient>? Logger { get; set; }
+#endif
+
+        /// <summary>
+        /// Optional callback for additional service registrations on the internal <see cref="IServiceCollection"/>
+        /// (e.g. <c>services.AddLogging(...)</c> or custom dependencies).
+        /// </summary>
+#if NETFRAMEWORK
+        public Action<IServiceCollection> ConfigureServices { get; set; }
+#else
+        public Action<IServiceCollection>? ConfigureServices { get; set; }
+#endif
+    }
+}

src/ReC.Client/TaskSyncExtensions.cs

@@ -7,12 +7,14 @@ namespace ReC.Client
     /// <summary>
     /// Provides synchronous wrappers for Task-based operations.
     /// </summary>
+    [System.Obsolete("Synchronous blocking helpers (Task.Sync) are no longer recommended. These methods can cause deadlocks or unexpected behavior. Rewrite calling code to use async/await (e.g. async Task tests). This helper class will be removed in a future release.", false)]
     public static class TaskSyncExtensions
     {
         /// <summary>
         /// Blocks until the task completes and propagates any exception.
         /// </summary>
         /// <param name="task">The task to wait for.</param>
+        [System.Obsolete("Use async/await instead of synchronous blocking. This method can cause deadlocks.", false)]
         public static void Sync(this Task task) => task.ConfigureAwait(false).GetAwaiter().GetResult();
 
         /// <summary>
@@ -21,6 +23,7 @@ namespace ReC.Client
         /// <typeparam name="TResult">The type of the task result.</typeparam>
         /// <param name="task">The task to wait for.</param>
         /// <returns>The result of the completed task.</returns>
+        [System.Obsolete("Use async/await instead of synchronous blocking. This method can cause deadlocks.", false)]
         public static TResult Sync<TResult>(this Task<TResult> task) => task.ConfigureAwait(false).GetAwaiter().GetResult();
     }
 }

src/ReC.Domain/Constants/RecStatus.cs

@@ -0,0 +1,23 @@
+namespace ReC.Domain.Constants;
+
+/// <summary>
+/// Represents the general outcome of an operation, independent of any specific technology or protocol.
+/// <para>
+/// Technology-specific details (e.g., HTTP status codes) are stored separately
+/// in the <c>RESULT_INFO</c> and <c>RESULT_INFO_DETAIL</c> fields.
+/// </para>
+/// </summary>
+/// <seealso cref="RecStatusExtensions"/>
+public enum RecStatus : byte
+{
+    /// <summary>
+    /// Indicates that the operation completed successfully (value 0).
+    /// </summary>
+    OK = 0,
+
+    /// <summary>
+    /// Indicates that the operation failed (value 1).
+    /// When set, the <c>RESULT_ERROR</c> field should contain the error details.
+    /// </summary>
+    Error = 1
+}

src/ReC.Domain/Constants/RecStatusExtensions.cs

@@ -0,0 +1,16 @@
+using System.Net;
+
+namespace ReC.Domain.Constants;
+
+public static class RecStatusExtensions
+{
+    /// <summary>
+    /// Converts an <see cref="HttpStatusCode"/> to a general <see cref="RecStatus"/>
+    /// based on whether the HTTP status represents a success (2xx) or an error.
+    /// </summary>
+    public static RecStatus ToRecStatus(this HttpStatusCode code)
+    {
+        int value = (int)code;
+        return value >= 200 && value <= 299 ? RecStatus.OK : RecStatus.Error;
+    }
+}

src/ReC.Domain/Constants/ResultType.cs

@@ -0,0 +1,8 @@
+namespace ReC.Domain.Constants;
+
+public enum ResultType : byte
+{
+    Pre = 1,
+    Main,
+    Post
+}

src/ReC.Domain/QueryOutput/BodyQueryResult.cs.cs

@@ -1,6 +1,9 @@
-namespace ReC.Domain.QueryOutput;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.QueryOutput;
 
 public class BodyQueryResult
 {
+    [Column("REQUEST_BODY")]
     public string? RawBody { get; init; }
 }

src/ReC.Domain/QueryOutput/HeaderQueryResult.cs

@@ -1,6 +1,9 @@
-namespace ReC.Domain.QueryOutput;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.QueryOutput;
 
 public class HeaderQueryResult
 {
+    [Column("REQUEST_HEADER")]
     public string? RawHeader { get; init; }
 }

src/ReC.Domain/QueryOutput/InsertObjectResult.cs

@@ -4,5 +4,6 @@ namespace ReC.Domain.QueryOutput;
 
 public class InsertObjectResult
 {
+    [Column("oGUID")]
     public required long NewObjectId { get; set; }
 }

src/ReC.Domain/Views/ProfileView.cs

@@ -1,4 +1,5 @@
 using ReC.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
 namespace ReC.Domain.Views;
@@ -8,39 +9,58 @@ public record ProfileView
 {
     public virtual IEnumerable<RecActionView>? Actions { get; init; }
 
+    [Key]
+    [Column("PROFILE_GUID")]
     public long Id { get; init; }
 
+    [Column("ACTIVE")]
     public bool Active { get; init; }
 
+    [Column("TYPE_ID")]
     public ProfileType TypeId { get; init; }
 
+    [Column("TYPE")]
     public string? Type { get; init; }
 
+    [Column("MANDANTOR")]
     public string? Mandantor { get; init; }
 
+    [Column("PROFILE_NAME")]
     public string? ProfileName { get; init; }
 
+    [Column("DESCRIPTION")]
     public string? Description { get; init; }
 
+    [Column("LOG_LEVEL_ID")]
     public byte LogLevelId { get; init; }
 
+    [Column("LOG_LEVEL")]
     public string? LogLevel { get; init; }
 
+    [Column("LANGUAGE_ID")]
     public short LanguageId { get; init; }
 
+    [Column("LANGUAGE")]
     public string? Language { get; init; }
 
+    [Column("ADDED_WHO")]
     public string? AddedWho { get; init; }
 
+    [Column("ADDED_WHEN")]
     public DateTime AddedWhen { get; init; }
 
+    [Column("CHANGED_WHO")]
     public string? ChangedWho { get; init; }
 
+    [Column("CHANGED_WHEN")]
     public DateTime? ChangedWhen { get; init; }
 
+    [Column("FIRST_RUN")]
     public DateTime? FirstRun { get; init; }
 
+    [Column("LAST_RUN")]
     public DateTime? LastRun { get; init; }
 
+    [Column("LAST_RESULT")]
     public string? LastResult { get; init; }
 }

src/ReC.Domain/Views/RecActionView.cs

@@ -1,4 +1,5 @@
 using ReC.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
 
 namespace ReC.Domain.Views;
@@ -16,72 +17,109 @@ public class RecActionView
 {
     public virtual IEnumerable<ResultView>? Results { get; set; }
 
+    [Key]
+    [Column("ACTION_GUID")]
     public required long Id { get; set; }
 
+    [Column("PROFILE_ID")]
     public long? ProfileId { get; set; }
 
     [ForeignKey("ProfileId")]
     public ProfileView? Profile { get; set; }
 
+    [Column("PROFILE_NAME")]
     public string? ProfileName { get; set; }
 
+    [Column("PROFILE_TYPE_ID")]
     public ProfileType? ProfileType { get; set; }
 
+    [Column("PROFILE_TYPE")]
+    public string? ProfileTypeName { get; set; }
+
+    [Column("SEQUENCE")]
     public byte? Sequence { get; set; }
 
+    [Column("ENDPOINT_ID")]
     public long? EndpointId { get; set; }
 
+    [Column("ENDPOINT_URI")]
     public string? EndpointUri { get; set; }
 
+    [Column("ENDPOINT_AUTH_ID")]
     public long? EndpointAuthId { get; set; }
 
+    [Column("ENDPOINT_AUTH_TYPE_ID")]
     public EndpointAuthType? EndpointAuthType { get; set; }
 
+    [Column("ENDPOINT_AUTH_TYPE")]
     public string? EndpointAuthTypeName { get; set; }
 
+    [Column("ENDPOINT_AUTH_API_KEY")]
     public string? EndpointAuthApiKey { get; set; }
 
+    [Column("ENDPOINT_AUTH_API_VALUE")]
     public string? EndpointAuthApiValue { get; set; }
 
+    [Column("ENDPOINT_AUTH_API_KEY_ADD_TO_ID")]
     public ApiKeyLocation? EndpointAuthApiKeyAddTo { get; set; }
 
+    [Column("ENDPOINT_AUTH_API_KEY_ADD_TO")]
     public string? EndpointAuthApiKeyAddToName { get; set; }
 
+    [Column("ENDPOINT_AUTH_TOKEN")]
     public string? EndpointAuthToken { get; set; }
 
+    [Column("ENDPOINT_AUTH_USERNAME")]
     public string? EndpointAuthUsername { get; set; }
 
+    [Column("ENDPOINT_AUTH_PASSWORD")]
     public string? EndpointAuthPassword { get; set; }
 
+    [Column("ENDPOINT_AUTH_DOMAIN")]
     public string? EndpointAuthDomain { get; set; }
 
+    [Column("ENDPOINT_AUTH_WORKSTATION")]
     public string? EndpointAuthWorkstation { get; set; }
 
+    [Column("ENDPOINT_PARAMS_ID")]
     public short? EndpointParamsId { get; set; }
 
+    [Column("SQL_CONNECTION_ID")]
     public short? SqlConnectionId { get; set; }
 
+    [Column("SQL_CONNECTION_SERVER")]
     public string? SqlConnectionServer { get; set; }
 
+    [Column("SQL_CONNECTION_DB")]
     public string? SqlConnectionDb { get; set; }
 
+    [Column("SQL_CONNECTION_USERNAME")]
     public string? SqlConnectionUsername { get; set; }
 
+    [Column("SQL_CONNECTION_PASSWORD")]
     public string? SqlConnectionPassword { get; set; }
 
+    [Column("REST_TYPE_ID")]
     public RestType? RestType { get; set; }
 
+    [Column("REST_TYPE")]
     public string? RestTypeName { get; set; }
 
+    [Column("PREPROCESSING_QUERY")]
     public string? PreprocessingQuery { get; set; }
 
+    [Column("HEADER_QUERY")]
     public string? HeaderQuery { get; set; }
 
+    [Column("BODY_QUERY")]
     public string? BodyQuery { get; set; }
 
+    [Column("POSTPROCESSING_QUERY")]
     public string? PostprocessingQuery { get; set; }
 
+    [Column("ERROR_ACTION_ID")]
     public ErrorAction? ErrorAction { get; set; }
 
+    [Column("ERROR_ACTION")]
     public string? ErrorActionName { get; set; }
 }

src/ReC.Domain/Views/ResultView.cs

@@ -1,39 +1,86 @@
-using System.ComponentModel.DataAnnotations.Schema;
+using ReC.Domain.Constants;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
 
 namespace ReC.Domain.Views;
 
 [Table("VWREC_RESULT", Schema = "dbo")]
 public class ResultView
 {
+    [Key]
+    [Column("RESULT_GUID")]
     public long Id { get; set; }
 
+    [Column("ACTION_ID")]
     public long? ActionId { get; set; }
 
     public RecActionView? Action { get; set; }
 
+    [Column("PROFILE_ID")]
     public long? ProfileId { get; set; }
 
     public ProfileView? Profile { get; set; }
 
+    [Column("PROFILE_NAME")]
     public string? ProfileName { get; set; }
 
-    public short? StatusCode { get; set; }
+    [Column("STATUS_ID")]
+    public RecStatus Status { get; set; }
 
+    [Column("STATUS")]
     public string? StatusName { get; set; }
 
+    [Column("RESULT_TYPE_ID")]
+    public ResultType? Type { get; set; }
+
+    [Column("RESULT_TYPE")]
+    public string? TypeName { get; set; }
+
+    [Column("RESULT_HEADER")]
     public string? Header { get; set; }
 
+    [Column("RESULT_BODY")]
     public string? Body { get; set; }
 
+    [Column("RESULT_INFO_ID")]
+    public short? InfoId { get; set; }
+
+    [Column("RESULT_INFO")]
     public string? Info { get; set; }
 
+    [Column("RESULT_INFO_DETAIL")]
+    public string? InfoDetail { get; set; }
+
+    [Column("RESULT_ERROR")]
     public string? Error { get; set; }
 
+    [Column("BATCH_ID")]
+    public string? BatchId { get; set; }
+
+    [Column("REFERENCE1")]
+    public string? Reference1 { get; set; }
+
+    [Column("REFERENCE2")]
+    public string? Reference2 { get; set; }
+
+    [Column("REFERENCE3")]
+    public string? Reference3 { get; set; }
+
+    [Column("REFERENCE4")]
+    public string? Reference4 { get; set; }
+
+    [Column("REFERENCE5")]
+    public string? Reference5 { get; set; }
+
+    [Column("ADDED_WHO")]
     public string? AddedWho { get; set; }
 
+    [Column("ADDED_WHEN")]
     public DateTime? AddedWhen { get; set; }
 
+    [Column("CHANGED_WHO")]
     public string? ChangedWho { get; set; }
 
+    [Column("CHANGED_WHEN")]
     public DateTime? ChangedWhen { get; set; }
 }

src/ReC.Infrastructure/DependencyInjection.cs

@@ -29,7 +29,7 @@ public static class DependencyInjection
             opt.RegisterDefaultRepository<TRecDbContext>();
         });
 
-        services.AddValidatorsFromAssembly(typeof(AuthScopedValidator).Assembly);
+        services.AddValidatorsFromAssembly(typeof(InsertObjectProcedureValidator).Assembly);
 
         return services;
     }

src/ReC.Infrastructure/Exceptions/DbModelConfigurationException.cs

@@ -1,12 +0,0 @@
-namespace ReC.Infrastructure.Exceptions;
-
-public class DbModelConfigurationException : Exception
-{
-    public DbModelConfigurationException(string message) : base(message)
-    {
-    }
-
-    public DbModelConfigurationException()
-    {
-    }
-}

src/ReC.Infrastructure/Options/DbModelOptions.cs

@@ -1,23 +0,0 @@
-using ReC.Infrastructure.Exceptions;
-using ReC.Infrastructure.Options.Shared;
-
-namespace ReC.Infrastructure.Options;
-
-public record DbModelOptions
-{
-    public Dictionary<string, EntityOptions> Entities { get; init; } = [];
-
-    public Dictionary<string, VirtualEntityOptions> VirtualEntities { get; init; } = [];
-
-    public void EnsureEntity<T>(bool isVirtual)
-    {
-        var entities = isVirtual
-            ? VirtualEntities.ToDictionary(kvp => kvp.Key, kvp => kvp.Value as EntityBaseOptions)
-            : Entities.ToDictionary(kvp => kvp.Key, kvp => kvp.Value as EntityBaseOptions);
-
-        if(entities.TryGetValue(nameof(T), out var entityOptions))
-            entityOptions.EnsureProperties<T>();
-        else
-            throw new DbModelConfigurationException($"Entity options for type '{typeof(T).FullName}' not found.");
-    }
-}

src/ReC.Infrastructure/Options/Shared/EntityBaseOptions.cs

@@ -1,33 +0,0 @@
-using ReC.Domain.Attributes;
-using ReC.Infrastructure.Exceptions;
-
-namespace ReC.Infrastructure.Options.Shared;
-
-public record EntityBaseOptions()
-{
-    public Dictionary<string, string> ColumnMappings { get; init; } = [];
-
-    public IEnumerable<string> PropertyNames => ColumnMappings.Select(col => col.Key);
-
-    public IEnumerable<string> ColumnNames => ColumnMappings.Select(col => col.Value);
-
-    public void EnsureProperties(IEnumerable<string> propertyNames)
-    {
-        var missingProperties = propertyNames.Except(PropertyNames).ToList();
-
-        if (missingProperties.Count != 0)
-            throw new DbModelConfigurationException($"The following properties are not configured: {string.Join(", ", missingProperties)}");
-    }
-
-    public void EnsureProperties(params string[] propertyNames) 
-        => EnsureProperties(propertyNames.AsEnumerable());
-
-    public void EnsureProperties<T>()
-    {
-        var propertyNames = typeof(T)
-            .GetProperties()
-            .Where(prop => Attribute.IsDefined(prop, typeof(MustConfiguredAttribute)))
-            .Select(prop => prop.Name);
-        EnsureProperties(propertyNames);
-    }
-}

src/ReC.Infrastructure/Options/Shared/EntityOptions.cs

@@ -1,3 +0,0 @@
-namespace ReC.Infrastructure.Options.Shared;
-
-public record EntityOptions(TableOptions Table) : EntityBaseOptions;