Add project description to ReC.Client.csproj

A `<Description>` tag was added to the `ReC.Client.csproj` file.
This tag describes the project as a client library for interacting
with the ReC.API, offering typed HTTP access and DI integration.
This change improves project metadata for better documentation
and package management.

ReC.sln

@@ -15,6 +15,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReC.Application", "src\ReC.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReC.Client", "src\ReC.Client\ReC.Client.csproj", "{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}"
 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
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

src/ReC.API/Controllers/ActionController.cs

@@ -1,15 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-
-namespace ReC.API.Controllers;
-
-[Route("api/[controller]")]
-[ApiController]
-public class ActionController : ControllerBase
-{
-    [HttpPost("{profileId}")]
-    public Task<IActionResult> Trigger([FromRoute] int profileId)
-    {
-        // Implementation for retrieving actions would go here.
-        throw new NotImplementedException();
-    }
-}

src/ReC.API/Controllers/OutResController.cs

@@ -0,0 +1,77 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.API.Extensions;
+using ReC.Application.OutResults.Queries;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class OutResController(IMediator mediator, IConfiguration config) : ControllerBase
+{
+    /// <summary>
+    /// Gets output results based on the provided query parameters.
+    /// </summary>
+    /// <param name="query">The query to filter output results.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>A list of output results matching the query.</returns>
+    [HttpGet]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get([FromQuery] ReadOutResQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, cancel));
+
+    /// <summary>
+    /// Gets output results for a fake/test profile.
+    /// </summary>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>A list of output results for the fake profile.</returns>
+    [HttpGet("fake")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get(CancellationToken cancel) => Ok(await mediator.Send(new ReadOutResQuery()
+    {
+        ProfileId = config.GetFakeProfileId()
+    }, cancel));
+
+    /// <summary>
+    /// Gets a specific output result for a fake/test profile and action.
+    /// </summary>
+    /// <param name="actionId">The ID of the action to retrieve the result for.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <param name="resultType">Specifies which part of the result to return (Full, Header, or Body).</param>
+    /// <returns>The requested output result or a part of it (header/body).</returns>
+    [HttpGet("fake/{actionId}")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get([FromRoute] long actionId, CancellationToken cancel, ResultType resultType = ResultType.Full)
+    {
+        var res = (await mediator.Send(new ReadOutResQuery()
+        {
+            ProfileId = config.GetFakeProfileId(),
+            ActionId = actionId
+        }, cancel)).First();
+
+        return resultType switch
+        {
+            ResultType.Body => res.Body is null ? Ok(new object { }) : Ok(res.Body.JsonToDynamic()),
+            ResultType.Header => res.Header is null ? Ok(new object { }) : Ok(res.Header.JsonToDynamic()),
+            _ => Ok(res),
+        };
+    }
+}
+
+/// <summary>
+/// Defines the type of result to be returned from an output result query.
+/// </summary>
+public enum ResultType
+{
+    /// <summary>
+    /// Return the full result object.
+    /// </summary>
+    Full,
+    /// <summary>
+    /// Return only the header part of the result.
+    /// </summary>
+    Header,
+    /// <summary>
+    /// Return only the body part of the result.
+    /// </summary>
+    Body
+}

src/ReC.API/Controllers/RecActionController.cs

@@ -0,0 +1,151 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.API.Extensions;
+using ReC.API.Models;
+using ReC.Application.RecActions.Commands;
+using ReC.Application.RecActions.Queries;
+using System.Text.Json;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class RecActionController(IMediator mediator, IConfiguration config) : ControllerBase
+{
+    /// <summary>
+    /// Invokes a batch of RecActions for a given profile.
+    /// </summary>
+    /// <param name="profileId">The ID of the profile.</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/{cmd}")]
+    [ProducesResponseType(StatusCodes.Status202Accepted)]
+    public async Task<IActionResult> Invoke([FromRoute] int profileId, CancellationToken cancel)
+    {
+        await mediator.InvokeBatchRecAction(profileId, cancel);
+        return Accepted();
+    }
+
+    /// <summary>
+    /// Invokes a batch of RecActions for a fake/test profile.
+    /// </summary>
+    /// <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/fake")]
+    [ProducesResponseType(StatusCodes.Status202Accepted)]
+    public async Task<IActionResult> Invoke(CancellationToken cancel)
+    {
+        await mediator.InvokeBatchRecAction(config.GetFakeProfileId(), cancel);
+        return Accepted();
+    }
+
+    #region CRUD
+    /// <summary>
+    /// Gets all RecActions for a given profile.
+    /// </summary>
+    /// <param name="profileId">The ID of the profile.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>A list of RecActions for the specified profile.</returns>
+    [HttpGet]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get([FromQuery] ReadRecActionQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, cancel));
+
+    /// <summary>
+    /// Gets all RecActions for a fake/test profile.
+    /// </summary>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <param name="invoked"></param>
+    /// <returns>A list of RecActions for the fake profile.</returns>
+    [HttpGet("fake")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get(CancellationToken cancel, [FromQuery] bool invoked = false) => Ok(await mediator.Send(new ReadRecActionQuery()
+    {
+        ProfileId = config.GetFakeProfileId(),
+        Invoked = invoked
+    }, cancel));
+
+    /// <summary>
+    /// Creates a new RecAction.
+    /// </summary>
+    /// <param name="command">The command containing the details for the new RecAction.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>An HTTP 201 Created response.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> CreateAction([FromBody] CreateRecActionCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+
+        return CreatedAtAction(nameof(CreateAction), null);
+    }
+
+    /// <summary>
+    /// Creates a new fake RecAction for testing purposes.
+    /// </summary>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <param name="request">The optional request body and header for the fake action.</param>
+    /// <param name="endpointUri">The target endpoint URI.</param>
+    /// <param name="endpointPath">The optional path to append to the endpoint URI.</param>
+    /// <param name="type">The HTTP method type (e.g., GET, POST).</param>
+    /// <returns>An HTTP 201 Created response.</returns>
+    [HttpPost("fake")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> CreateFakeAction(
+        CancellationToken cancel,
+        [FromBody] FakeRequest? request = null,
+        [FromQuery] string endpointUri = "https://jsonplaceholder.typicode.com/posts",
+        [FromQuery] string? endpointPath = "1",
+        [FromQuery] string type = "GET")
+    {
+        if (endpointPath is not null)
+            endpointUri = new Uri(new Uri(endpointUri.TrimEnd('/') + "/"), endpointPath.TrimStart('/')).ToString();
+
+        var bodyJson = request?.Body is not null ? JsonSerializer.Serialize(request.Body, options: new() { WriteIndented = false }) : null;
+        var headerJson = request?.Header is not null ? JsonSerializer.Serialize(request.Header, options: new() { WriteIndented = false }) : null;
+
+        await mediator.Send(new CreateRecActionCommand()
+        {
+            ProfileId = config.GetFakeProfileId(),
+            EndpointUri = endpointUri,
+            Type = type,
+            BodyQuery = $@"SELECT '{bodyJson ?? "NULL"}' AS REQUEST_BODY;",
+            HeaderQuery = headerJson is not null ? $@"SELECT '{headerJson}' AS REQUEST_HEADER;" : null,
+            Active = true,
+            EndpointAuthId = 4
+        }, cancel);
+
+        return CreatedAtAction(nameof(CreateFakeAction), null);
+    }
+
+    /// <summary>
+    /// Deletes all RecActions associated with a specific profile.
+    /// </summary>
+    /// <param name="cmd"></param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>An HTTP 204 No Content response upon successful deletion.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromQuery] DeleteRecActionsCommand cmd, CancellationToken cancel)
+    {
+        await mediator.Send(cmd, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes all RecActions for a fake/test profile.
+    /// </summary>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>An HTTP 204 No Content response upon successful deletion.</returns>
+    [HttpDelete("fake")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete(CancellationToken cancel)
+    {
+        await mediator.Send(new DeleteRecActionsCommand()
+        {
+            ProfileId = config.GetFakeProfileId()
+        }, cancel);
+
+        return NoContent();
+    }
+    #endregion CRUD
+}

src/ReC.API/Extensions/ConfigExtensions.cs

@@ -0,0 +1,6 @@
+namespace ReC.API.Extensions;
+
+public static class ConfigurationExtensions
+{
+    public static int GetFakeProfileId(this IConfiguration config) => config.GetValue("FakeProfileId", 2);
+}

src/ReC.API/Extensions/JsonExtensions.cs

@@ -0,0 +1,53 @@
+using System.Text.Json;
+
+public static class JsonExtensions
+{
+    /// <summary>
+    /// Deserialize JSON string and automatically parse nested JSON strings.
+    /// </summary>
+    public static dynamic? JsonToDynamic(this string json)
+    {
+        // Deserialize the top-level JSON
+        var result = JsonSerializer.Deserialize<JsonElement>(json);
+
+        // Recursively fix stringified JSON objects
+        return JsonToDynamic(result);
+    }
+
+    private static dynamic? JsonToDynamic(JsonElement obj)
+    {
+        switch (obj.ValueKind)
+        {
+            case JsonValueKind.Object:
+                var dict = new Dictionary<string, dynamic?>();
+                foreach (var prop in obj.EnumerateObject())
+                {
+                    dict[prop.Name] = JsonToDynamic(prop.Value);
+                }
+                return dict;
+
+            case JsonValueKind.Array:
+                var list = new List<dynamic>();
+                foreach (var item in obj.EnumerateArray())
+                {
+                    list.Add(JsonToDynamic(item));
+                }
+                return list;
+
+            case JsonValueKind.String:
+                var str = obj.GetString();
+                // Try to parse string as JSON
+                if (!string.IsNullOrWhiteSpace(str) && (str.StartsWith('{') || str.StartsWith('[')))
+                {
+                    try
+                    {
+                        return JsonToDynamic(JsonSerializer.Deserialize<JsonElement>(str));
+                    }
+                    catch { }
+                }
+                return str;
+            default:
+                return obj.GetRawText();
+        }
+    }
+}

src/ReC.API/Middleware/ExceptionHandlingMiddleware.cs

@@ -0,0 +1,123 @@
+using DigitalData.Core.Exceptions;
+using FluentValidation;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Exceptions;
+using System.Net;
+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;
+    private readonly ILogger<ExceptionHandlingMiddleware> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExceptionHandlingMiddleware"/> class.
+    /// </summary>
+    /// <param name="next">The next middleware in the request pipeline.</param>
+    /// <param name="logger">The logger instance for logging exceptions.</param>
+    public ExceptionHandlingMiddleware(RequestDelegate next, ILogger<ExceptionHandlingMiddleware> logger)
+    {
+        _next = next;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Invokes the middleware to handle the HTTP request.
+    /// </summary>
+    /// <param name="context">The HTTP context of the current request.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    public async Task InvokeAsync(HttpContext context)
+    {
+        try
+        {
+            await _next(context); // Continue down the pipeline
+        }
+        catch (Exception ex)
+        {
+            await HandleExceptionAsync(context, ex, _logger);
+        }
+    }
+
+    /// <summary>
+    /// Handles exceptions by logging them and writing an appropriate JSON response.
+    /// </summary>
+    /// <param name="context">The HTTP context of the current request.</param>
+    /// <param name="exception">The exception that occurred.</param>
+    /// <param name="logger">The logger instance for logging the exception.</param>
+    /// <returns>A task that represents the asynchronous operation.</returns>
+    private static async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger logger)
+    {
+        context.Response.ContentType = "application/json";
+
+        ValidationProblemDetails? details = null;
+
+        switch (exception)
+        {
+            case BadRequestException badRequestEx:
+                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
+                details = new() 
+                { 
+                    Title = "Bad Request", 
+                    Detail = badRequestEx.Message 
+                };
+                break;
+
+            case ValidationException validationEx:
+                context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
+
+                var errors = validationEx.Errors
+                    .GroupBy(e => e.PropertyName, e => e.ErrorMessage)
+                    .ToDictionary(failureGroup => failureGroup.Key, failureGroup => failureGroup.ToArray());
+
+                details = new ValidationProblemDetails()
+                {
+                    Title = "Validation failed",
+                    Errors = validationEx.Errors
+                        .GroupBy(e => e.PropertyName, e => e.ErrorMessage)
+                        .ToDictionary(failureGroup => failureGroup.Key, failureGroup => failureGroup.ToArray()),
+                };
+
+                break;
+
+            case NotFoundException notFoundEx:
+                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
+                details = new() 
+                {
+                    Title = "Not Found",
+                    Detail = notFoundEx.Message
+                };
+                break;
+
+            case DataIntegrityException dataIntegrityEx:
+                context.Response.StatusCode = (int)HttpStatusCode.Conflict;
+                details = new() 
+                {
+                    Title = "Data Integrity Violation",
+                    Detail = dataIntegrityEx.Message
+                };
+                break;
+
+            default:
+                logger.LogError(exception, "Unhandled exception occurred.");
+                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                details = new()
+                {
+                    Title = "Internal Server Error",
+                    Detail = "An unexpected error occurred. Please try again later."
+                };
+                break;
+        }
+
+        if (details is not null)
+            await context.Response.WriteAsJsonAsync(details);
+    }
+}

src/ReC.API/Models/FakeRequest.cs

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

src/ReC.API/Program.cs

@@ -1,25 +1,78 @@
-var builder = WebApplication.CreateBuilder(args);
+using Microsoft.EntityFrameworkCore;
+using NLog;
+using NLog.Web;
+using ReC.API.Middleware;
+using ReC.Application;
+using ReC.Infrastructure;
+using LogLevel = Microsoft.Extensions.Logging.LogLevel;
 
-// Add services to the container.
+var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
+logger.Info("Logging initialized!");
 
-builder.Services.AddControllers();
-// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
-
-var app = builder.Build();
-
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
+try
 {
-    app.UseSwagger();
-    app.UseSwaggerUI();
+    var builder = WebApplication.CreateBuilder(args);
+
+    builder.Logging.SetMinimumLevel(LogLevel.Trace);
+
+    if (!builder.Environment.IsDevelopment())
+    {
+        builder.Logging.ClearProviders();
+        builder.Host.UseNLog();
+    }
+
+    var config = builder.Configuration;
+
+    // Add services to the container.
+    builder.Services.AddRecServices(options =>
+    {
+        options.LuckyPennySoftwareLicenseKey = builder.Configuration["LuckyPennySoftwareLicenseKey"];
+        options.ConfigureRecActions(config.GetSection("RecAction"));
+    });
+
+    builder.Services.AddRecInfrastructure(options =>
+    {
+        options.ConfigureDbContext((provider, opt) =>
+        {
+            var cnnStr = builder.Configuration.GetConnectionString("Default")
+                                   ?? throw new InvalidOperationException("Connection string is not found.");
+
+            var logger = provider.GetRequiredService<ILogger<RecDbContext>>();
+            opt.UseSqlServer(cnnStr)
+                    .LogTo(log => logger.LogInformation("{log}", log), LogLevel.Trace)
+                    .EnableSensitiveDataLogging()
+                    .EnableDetailedErrors();
+        });
+    });
+
+    builder.Services.AddControllers();
+    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen();
+
+    var app = builder.Build();
+
+#pragma warning disable CS0618
+    app.UseMiddleware<ExceptionHandlingMiddleware>();
+#pragma warning restore CS0618
+
+    // Configure the HTTP request pipeline.
+    if (app.Environment.IsDevelopment())
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI();
+    }
+
+    app.UseHttpsRedirection();
+
+    app.UseAuthorization();
+
+    app.MapControllers();
+
+    app.Run();
 }
-
-app.UseHttpsRedirection();
-
-app.UseAuthorization();
-
-app.MapControllers();
-
-app.Run();
+catch(Exception ex)
+{
+    logger.Error(ex, "Stopped program because of exception");
+    throw;
+}

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

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- https://go.microsoft.com/fwlink/?LinkID=208121. -->
+<Project>
+  <PropertyGroup>
+    <WebPublishMethod>Package</WebPublishMethod>
+    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
+    <LastUsedPlatform>Any CPU</LastUsedPlatform>
+    <SiteUrlToLaunchAfterPublish />
+    <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>	  
+    <PackageAsSingleFile>true</PackageAsSingleFile>
+    <DeployIisAppPath>Rec.API</DeployIisAppPath>
+    <_TargetId>IISWebDeployPackage</_TargetId>
+  </PropertyGroup>
+</Project>

src/ReC.API/ReC.API.csproj

@@ -1,13 +1,32 @@
-<Project Sdk="Microsoft.NET.Sdk.Web">
+<Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
+	<TargetFramework>net8.0</TargetFramework>
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<PackageId>ReC.API</PackageId>
+	<Authors>Digital Data GmbH</Authors>
+	<Company>Digital Data GmbH</Company>
+	<Product>ReC.API</Product>
+	<PackageIcon>Assets\icon.ico</PackageIcon>
+	<PackageTags>digital data rest-caller rec api</PackageTags>
+	<Version>1.0.0-beta</Version>
+    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <FileVersion>1.0.0.0</FileVersion>
+    <InformationalVersion>1.0.0-beta</InformationalVersion>
+	<Copyright>Copyright © 2025 Digital Data GmbH. All rights reserved.</Copyright>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.11" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />  
+	<PackageReference Include="NLog" Version="5.2.5" />
+	<PackageReference Include="NLog.Web.AspNetCore" Version="5.3.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ReC.Application\ReC.Application.csproj" />
+    <ProjectReference Include="..\ReC.Infrastructure\ReC.Infrastructure.csproj" />
   </ItemGroup>
 
 </Project>

src/ReC.API/appsettings.json

@@ -5,5 +5,65 @@
       "Microsoft.AspNetCore": "Warning"
     }
   },
-  "AllowedHosts": "*"
-}
+  "ConnectionStrings": {
+    "Default": "Server=SDD-VMP04-SQL19\\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;"
+  },
+  "AllowedHosts": "*",
+  "LuckyPennySoftwareLicenseKey": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ikx1Y2t5UGVubnlTb2Z0d2FyZUxpY2Vuc2VLZXkvYmJiMTNhY2I1OTkwNGQ4OWI0Y2IxYzg1ZjA4OGNjZjkiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2x1Y2t5cGVubnlzb2Z0d2FyZS5jb20iLCJhdWQiOiJMdWNreVBlbm55U29mdHdhcmUiLCJleHAiOiIxNzg0ODUxMjAwIiwiaWF0IjoiMTc1MzM2MjQ5MSIsImFjY291bnRfaWQiOiIwMTk4M2M1OWU0YjM3MjhlYmZkMzEwM2MyYTQ4NmU4NSIsImN1c3RvbWVyX2lkIjoiY3RtXzAxazB5NmV3MmQ4YTk4Mzg3aDJnbTRuOWswIiwic3ViX2lkIjoiLSIsImVkaXRpb24iOiIwIiwidHlwZSI6IjIifQ.ZqsFG7kv_-xGfxS6ACk3i0iuNiVUXX2AvPI8iAcZ6-z2170lGv__aO32tWpQccD9LCv5931lBNLWSblKS0MT3gOt-5he2TEftwiSQGFwoIBgtOHWsNRMinUrg2trceSp3IhyS3UaMwnxZDrCvx4-0O-kpOzVpizeHUAZNr5U7oSCWO34bpKdae6grtM5e3f93Z1vs7BW_iPgItd-aLvPwApbaG9VhmBTKlQ7b4Jh64y7UXJ9mKP7Qb_Oa97oEg0oY5DPHOWTZWeE1EzORgVr2qkK2DELSHuZ_EIUhODojkClPNAKtvEl_qEjpq0HZCIvGwfCCRlKlSkQqIeZdFkiXg",
+  "RecAction": {
+    "MaxConcurrentInvocations": 5
+  },
+  "AddedWho": "ReC.API",
+  "FakeProfileId": 2,
+  "NLog": {
+    "throwConfigExceptions": true,
+    "variables": {
+      "logDirectory": "E:\\LogFiles\\Digital Data\\Rec.API",
+      "logFileNamePrefix": "${shortdate}.Rec.API"
+    },
+    "targets": {
+      "infoLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Info.log",
+        "maxArchiveDays": 30
+      },
+      "warningLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Warning.log",
+        "maxArchiveDays": 30
+      },
+      "errorLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Error.log",
+        "maxArchiveDays": 30
+      },
+      "criticalLogs": {
+        "type": "File",
+        "fileName": "${logDirectory}\\${logFileNamePrefix}-Critical.log",
+        "maxArchiveDays": 30
+      }
+    },
+    "rules": [
+      {
+        "logger": "*",
+        "level": "Info",
+        "writeTo": "infoLogs"
+      },
+      {
+        "logger": "*",
+        "level": "Warn",
+        "writeTo": "warningLogs"
+      },
+      {
+        "logger": "*",
+        "level": "Error",
+        "writeTo": "errorLogs"
+      },
+      {
+        "logger": "*",
+        "level": "Fatal",
+        "writeTo": "criticalLogs"
+      }
+    ]
+  }
+}

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

@@ -0,0 +1,23 @@
+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 : RecActionDto
+    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

@@ -0,0 +1,43 @@
+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 : RecActionDto
+    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/ValidationBehavior.cs

@@ -0,0 +1,30 @@
+using FluentValidation;
+using MediatR;
+
+namespace ReC.Application.Common.Behaviors
+{
+    public class ValidationBehavior<TRequest, TResponse>(IEnumerable<IValidator<TRequest>> validators) : IPipelineBehavior<TRequest, TResponse>
+        where TRequest : notnull
+    {
+        public async Task<TResponse> Handle(TRequest request, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)
+        {
+            if (validators.Any())
+            {
+                var context = new ValidationContext<TRequest>(request);
+
+                var validationResults = await Task.WhenAll(
+                    validators.Select(v =>
+                        v.ValidateAsync(context, cancel)));
+
+                var failures = validationResults
+                    .SelectMany(r => r.Errors)
+                    .Where(f => f != null)
+                    .ToList();
+
+                if (failures.Count != 0)
+                    throw new ValidationException(failures);
+            }
+            return await next(cancel);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+using ReC.Domain.Entities;
+
+namespace ReC.Application.Common.Dto;
+
+public class DtoMappingProfile : AutoMapper.Profile
+{
+    public DtoMappingProfile()
+    {
+        CreateMap<RecActionView, RecActionDto>();
+        CreateMap<OutRes, OutResDto>();
+    }
+}

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

@@ -0,0 +1,20 @@
+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 AddedWho { get; set; } = null!;
+
+    public DateTime AddedWhen { get; set; }
+
+    public string? ChangedWho { get; set; }
+
+    public DateTime? ChangedWhen { get; set; }
+}

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

@@ -0,0 +1,76 @@
+namespace ReC.Application.Common.Dto;
+
+public record RecActionDto
+{
+    public required long Id { get; init; }
+
+    public long? ProfileId { get; init; }
+
+    public string? ProfileName { get; init; }
+
+    public string? ProfileType { get; init; }
+
+    public byte? ProfileSequence { get; init; }
+
+    public long? EndpointId { get; init; }
+
+    public string? EndpointUri { get; init; }
+
+    public long? EndpointAuthId { get; init; }
+
+    public string? EndpointAuthType { get; init; }
+
+    public string? EndpointAuthApiKey { get; init; }
+
+    public string? EndpointAuthApiValue { get; init; }
+
+    public string? EndpointAuthApiKeyAddTo { get; init; }
+
+    public string? EndpointAuthToken { get; init; }
+
+    public string? EndpointAuthUsername { get; init; }
+
+    public string? EndpointAuthPassword { get; init; }
+
+    public string? EndpointAuthDomain { get; init; }
+
+    public string? EndpointAuthWorkstation { get; init; }
+
+    public short? EndpointParamsId { get; init; }
+
+    public short? SqlConnectionId { get; init; }
+
+    public string? SqlConnectionServer { get; init; }
+
+    public string? SqlConnectionDb { get; init; }
+
+    public string? SqlConnectionUsername { get; init; }
+
+    public string? SqlConnectionPassword { get; init; }
+
+    public string? RestType { get; init; }
+
+    public string? PreprocessingQuery { get; init; }
+
+    public string? HeaderQuery { get; init; }
+
+    public Dictionary<string, string>? Headers { get; set; }
+
+    public string? BodyQuery { get; init; }
+
+    public string? Body { get; set; }
+
+    public string? PostprocessingQuery { get; init; }
+
+    public UriBuilder ToEndpointUriBuilder()
+    {
+        var builder = EndpointUri is null ? new UriBuilder() : new UriBuilder(EndpointUri);
+
+        builder.Port = -1;
+
+        if (ProfileType is not null)
+            builder.Scheme = ProfileType;
+
+        return builder;
+    }
+}

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

@@ -0,0 +1,8 @@
+namespace ReC.Application.Common.Exceptions;
+
+public class DataIntegrityException : Exception
+{
+    public DataIntegrityException() { }
+
+    public DataIntegrityException(string message) : base(message) { }
+}

src/ReC.Application/Common/HttpExtensions.cs

@@ -0,0 +1,26 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace ReC.Application.Common;
+
+public static class HttpExtensions
+{
+    private static readonly Dictionary<string, HttpMethod> _methods = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["GET"] = HttpMethod.Get,
+        ["POST"] = HttpMethod.Post,
+        ["PUT"] = HttpMethod.Put,
+        ["DELETE"] = HttpMethod.Delete,
+        ["PATCH"] = HttpMethod.Patch,
+        ["HEAD"] = HttpMethod.Head,
+        ["OPTIONS"] = HttpMethod.Options,
+        ["TRACE"] = HttpMethod.Trace,
+        ["CONNECT"] = HttpMethod.Connect
+    };
+
+    public static HttpMethod ToHttpMethod(this string method) => _methods.TryGetValue(method, out var httpMethod) 
+        ? httpMethod 
+        : new HttpMethod(method);
+
+    public static HttpRequestMessage ToHttpRequestMessage(this HttpMethod method, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri)
+        => new(method, requestUri);
+}

src/ReC.Application/Common/Interfaces/IRecDbContext.cs

@@ -0,0 +1,19 @@
+using Microsoft.EntityFrameworkCore;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.Common.Interfaces;
+
+public interface IRecDbContext
+{
+    public DbSet<EndpointParam> EndpointParams { get; }
+
+    public DbSet<RecActionView> Actions { get; }
+
+    public DbSet<OutRes> OutRes { get; }
+
+    public DbSet<HeaderQueryResult> HeaderQueryResults { get; }
+
+    public DbSet<BodyQueryResult> BodyQueryResults { get; }
+
+    public Task<int> SaveChangesAsync(CancellationToken cancel = default);
+}

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

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Options;
+
+public class RecActionOptions
+{
+    public int MaxConcurrentInvocations { get; set; } = 5;
+}

src/ReC.Application/DependencyInjection.cs

@@ -0,0 +1,115 @@
+using MediatR;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using ReC.Application.Common.Behaviors;
+using ReC.Application.Common.Options;
+using System.Reflection;
+using FluentValidation;
+
+namespace ReC.Application;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddRecServices(this IServiceCollection services, Action<ConfigurationOptions> options)
+    {
+        var configOpt = new ConfigurationOptions();
+        options.Invoke(configOpt);
+
+        configOpt.EnsureRequiredServices();
+
+        configOpt.ApplyConfigurations(services);
+
+        services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());
+
+        services.AddAutoMapper(cfg =>
+        {
+            cfg.AddMaps(Assembly.GetExecutingAssembly());
+            cfg.LicenseKey = configOpt.LuckyPennySoftwareLicenseKey;
+        });
+
+        services.AddMediatR(cfg =>
+        {
+            cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
+            cfg.AddOpenBehaviors([typeof(BodyQueryBehavior<,>), typeof(HeaderQueryBehavior<,>)]);
+            cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
+            cfg.LicenseKey = configOpt.LuckyPennySoftwareLicenseKey;
+        });
+
+        services.AddHttpClient();
+
+        return services;
+    }
+
+    public class ConfigurationOptions
+    {
+
+        #region Required Services
+        private readonly Dictionary<string, bool> _requiredServices = new()
+        {
+            { nameof(ConfigureRecActions), false },
+            { nameof(LuckyPennySoftwareLicenseKey), false }
+        };
+
+        internal void EnsureRequiredServices()
+        {
+            var missingServices = _requiredServices
+                .Where(kvp => !kvp.Value)
+                .Select(kvp => kvp.Key.Replace("Configure", string.Empty));
+            if (missingServices.Any())
+                throw new InvalidOperationException($"The following required services were not configured: {string.Join(", ", missingServices)}");
+        }
+        #endregion Required Services
+
+        #region Configuration
+        private readonly Queue<Action<IServiceCollection>> _configActions = new();
+
+        internal void ApplyConfigurations(IServiceCollection services)
+        {
+            while (_configActions.Count > 0)
+            {
+                var action = _configActions.Dequeue();
+                action(services);
+            }
+        }
+        #endregion Configuration
+
+        #region LuckyPennySoftwareLicenseKey
+        private string? _luckyPennySoftwareLicenseKey;
+
+        public string? LuckyPennySoftwareLicenseKey 
+        { 
+            get => _luckyPennySoftwareLicenseKey; 
+            set
+            {
+                _luckyPennySoftwareLicenseKey = value;
+                if (value is not null)
+                    _requiredServices[nameof(LuckyPennySoftwareLicenseKey)] = true;
+            }
+        }
+        #endregion LuckyPennySoftwareLicenseKey
+
+        #region ConfigureRecActions
+        public ConfigurationOptions ConfigureRecActions(Action<RecActionOptions> configure)
+        {
+            _configActions.Enqueue(services => services.Configure(configure));
+
+            if(_requiredServices[nameof(ConfigureRecActions)])
+                throw new InvalidOperationException("RecActionOptions have already been configured.");
+            _requiredServices[nameof(ConfigureRecActions)] = true;
+            
+            return this;
+        }
+
+        public ConfigurationOptions ConfigureRecActions(IConfiguration configuration)
+        {
+            _configActions.Enqueue(services => services.Configure<RecActionOptions>(configuration));
+
+            if (_requiredServices[nameof(ConfigureRecActions)])
+                throw new InvalidOperationException("RecActionOptions have already been configured.");
+            _requiredServices[nameof(ConfigureRecActions)] = true;
+
+            return this;
+        }
+        #endregion ConfigureRecActions
+    }
+}

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

@@ -0,0 +1,25 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public class ObtainEndpointCommand : IRequest<Endpoint>
+{
+    public string Uri { get; init; } = null!;
+}
+
+public class ObtainEndpointCommandHandler(IRepository<Endpoint> repo) : IRequestHandler<ObtainEndpointCommand, Endpoint>
+{
+    public async Task<Endpoint> Handle(ObtainEndpointCommand request, CancellationToken cancel)
+    {
+        var endpoint = await repo.Where(e => e.Uri == request.Uri).FirstOrDefaultAsync(cancel);
+
+        if (endpoint is not null)
+            return endpoint;
+
+        endpoint = await repo.CreateAsync(request, cancel);
+        return endpoint;
+    }
+}

src/ReC.Application/Endpoints/MappingProfile.cs

@@ -0,0 +1,16 @@
+using ReC.Application.Endpoints.Commands;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.Endpoints;
+
+// TODO: update to inject AddedWho from the current host/user contex
+public class MappingProfile : AutoMapper.Profile
+{
+    public MappingProfile()
+    {
+        CreateMap<ObtainEndpointCommand, Endpoint>()
+            .ForMember(e => e.Active, exp => exp.MapFrom(cmd => true))
+            .ForMember(e => e.AddedWhen, exp => exp.MapFrom(cmd => DateTime.UtcNow))
+            .ForMember(e => e.AddedWho, exp => exp.MapFrom(cmd => "ReC.API"));
+    }
+}

src/ReC.Application/OutResults/Commands/CreateOutResCommand.cs

@@ -0,0 +1,24 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using MediatR;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.OutResults.Commands;
+
+public class CreateOutResCommand : IRequest
+{
+    public required long ActionId { get; set; }
+
+    public string? Header { get; set; }
+
+    public string? Body { get; set; }
+
+    public string? AddedWho { get; set; }
+}
+
+public class CreateOutResCommandHandler(IRepository<OutRes> repo) : IRequestHandler<CreateOutResCommand>
+{
+    public Task Handle(CreateOutResCommand request, CancellationToken cancel)
+    {
+        return repo.CreateAsync(request, cancel);
+    }
+}

src/ReC.Application/OutResults/MappingProfiles.cs

@@ -0,0 +1,15 @@
+using ReC.Application.OutResults.Commands;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.OutResults;
+
+// TODO: update to inject AddedWho from the current host/user contex
+public class MappingProfiles : AutoMapper.Profile
+{
+    public MappingProfiles()
+    {
+        CreateMap<CreateOutResCommand, OutRes>()
+            .ForMember(e => e.AddedWhen, exp => exp.MapFrom(cmd => DateTime.UtcNow))
+            .ForMember(e => e.AddedWho, exp => exp.MapFrom(cmd => "ReC.API"));
+    }
+}

src/ReC.Application/OutResults/Queries/ReadOutResQuery.cs

@@ -0,0 +1,37 @@
+using AutoMapper;
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Application.Common.Dto;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.OutResults.Queries;
+
+public record ReadOutResQuery : IRequest<IEnumerable<OutResDto>>
+{
+    public long? ProfileId { get; init; }
+
+    public long? ActionId { get; init; }
+}
+
+public class ReadOutResHandler(IRepository<OutRes> repo, IMapper mapper) : IRequestHandler<ReadOutResQuery, IEnumerable<OutResDto>>
+{
+    public async Task<IEnumerable<OutResDto>> Handle(ReadOutResQuery request, CancellationToken cancel)
+    {
+        var q = repo.Query;
+
+        if(request.ActionId is long actionId)
+            q = q.Where(res => res.ActionId == actionId);
+
+        if(request.ProfileId is long profileId)
+            q = q.Where(res => res.Action!.ProfileId == profileId);
+
+        var resList = await q.ToListAsync(cancel);
+
+        if (resList.Count == 0)
+            throw new NotFoundException();
+
+        return mapper.Map<IEnumerable<OutResDto>>(resList);
+    }
+}

src/ReC.Application/OutResults/Queries/ReadOutResQueryValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+
+namespace ReC.Application.OutResults.Queries;
+
+public class ReadOutResQueryValidator : AbstractValidator<ReadOutResQuery>
+{
+    public ReadOutResQueryValidator()
+    {
+        RuleFor(x => x)
+            .Must(x => x.ActionId.HasValue || x.ProfileId.HasValue)
+            .WithMessage("At least one of ActionId or ProfileId must be provided.")
+            .WithName("Identifier");
+    }
+}

src/ReC.Application/ReC.Application.csproj

@@ -6,4 +6,21 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="15.1.0" />
+    <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.5.0" />
+    <PackageReference Include="DigitalData.Core.Application" Version="3.4.0" />
+    <PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.0" />
+    <PackageReference Include="FluentValidation" Version="12.1.0" />
+    <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.0" />
+    <PackageReference Include="MediatR" Version="13.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.11" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.11" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ReC.Domain\ReC.Domain.csproj" />
+  </ItemGroup>
+
 </Project>

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

@@ -0,0 +1,45 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using ReC.Application.Endpoints.Commands;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record CreateRecActionCommand : IRequest
+{
+    public long ProfileId { get; init; }
+
+    public bool Active { get; init; } = true;
+
+    public long? EndpointId { get; set; }
+
+    public string? EndpointUri { get; init; }
+
+    public string Type { get; init; } = null!;
+
+    public string? HeaderQuery { get; init; }
+
+    public string BodyQuery { get; init; } = null!;
+
+    public byte Sequence { get; set; } = 1;
+
+    public long? EndpointAuthId { get; set; }
+}
+
+public class CreateRecActionCommandHandler(ISender sender, IRepository<RecAction> repo) : IRequestHandler<CreateRecActionCommand>
+{
+    public async Task Handle(CreateRecActionCommand request, CancellationToken cancel)
+    {
+        if(request.EndpointId is null)
+            if(request.EndpointUri is string endpointUri)
+            {
+                var endpoint = await sender.Send(new ObtainEndpointCommand { Uri = endpointUri }, cancel);
+                request.EndpointId = endpoint.Id;
+            }
+            else
+                throw new BadRequestException("Either EndpointId or EndpointUri must be provided.");
+
+        await repo.CreateAsync(request, cancel);
+    }
+}

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

@@ -0,0 +1,24 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using Microsoft.EntityFrameworkCore;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.RecActions.Commands;
+
+public class DeleteRecActionsCommand : IRequest
+{
+    public required long ProfileId { get; init; }
+}
+
+public class DeleteRecActionsCommandHandler(IRepository<RecAction> repo) : IRequestHandler<DeleteRecActionsCommand>
+{
+    public async Task Handle(DeleteRecActionsCommand request, CancellationToken cancel)
+    {
+        // TODO: update DeleteAsync (in Core) to return number of deleted records
+        if (!await repo.Where(act => act.ProfileId == request.ProfileId).AnyAsync(cancel))
+            throw new NotFoundException();
+
+        await repo.DeleteAsync(act => act.ProfileId == request.ProfileId, cancel);
+    }
+}

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

@@ -0,0 +1,52 @@
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using ReC.Application.RecActions.Queries;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InvokeBatchRecActionsCommand : ReadRecActionQueryBase, IRequest;
+
+public static class InvokeBatchRecActionsCommandExtensions
+{
+    public static Task InvokeBatchRecAction(this ISender sender, long profileId, CancellationToken cancel = default)
+        => sender.Send(new InvokeBatchRecActionsCommand { ProfileId = profileId }, cancel);
+}
+
+public class InvokeRecActionsCommandHandler(ISender sender, IServiceScopeFactory scopeFactory, IHttpClientFactory clientFactory, ILogger<InvokeRecActionsCommandHandler>? logger = null) : IRequestHandler<InvokeBatchRecActionsCommand>
+{
+    public async Task Handle(InvokeBatchRecActionsCommand request, CancellationToken cancel)
+    {
+        var actions = await sender.Send(request.ToReadQuery(q => q.Invoked = false), cancel);
+
+        var http = clientFactory.CreateClient();
+
+        using var semaphore = new SemaphoreSlim(5);
+
+        var tasks = actions.Select(async action =>
+        {
+            await semaphore.WaitAsync(cancel);
+            try
+            {
+                using var scope = scopeFactory.CreateScope();
+                var sender = scope.ServiceProvider.GetRequiredService<ISender>();
+                await sender.Send(action.ToInvokeCommand(), cancel);
+            }
+            catch(Exception ex)
+            {
+                logger?.LogError(
+                    ex,
+                    "Error invoking Rec action. ProfileId: {ProfileId}, Id: {Id}",
+                    action.ProfileId,
+                    action.Id
+                );
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+    }
+}

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

@@ -0,0 +1,65 @@
+using MediatR;
+using Microsoft.Extensions.Configuration;
+using ReC.Application.Common;
+using ReC.Application.Common.Dto;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.OutResults.Commands;
+using System.Text.Json;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InvokeRecActionCommand : IRequest
+{
+    public RecActionDto Action { get; set; } = null!;
+}
+
+public static class InvokeRecActionCommandExtensions
+{
+    public static InvokeRecActionCommand ToInvokeCommand(this RecActionDto dto) => new() { Action = dto };
+}
+
+public class InvokeRecActionCommandHandler(
+    ISender sender,
+    IHttpClientFactory clientFactory,
+    IConfiguration? config = null
+    ) : IRequestHandler<InvokeRecActionCommand>
+{
+    public async Task Handle(InvokeRecActionCommand request, CancellationToken cancel)
+    {
+        var action = request.Action;
+        using var http = clientFactory.CreateClient();
+
+        if (action.RestType is null)
+            throw new DataIntegrityException(
+                $"Rec action could not be invoked because the RestType value is null. " +
+                $"ProfileId: {action.ProfileId}, " +
+                $"Id: {action.Id}"
+            );
+
+        using var httpReq = action.RestType
+            .ToHttpMethod()
+            .ToHttpRequestMessage(action.EndpointUri);
+
+        if(action.Body is not null)
+        {
+            using var reqBody = new StringContent(action.Body);
+            httpReq.Content = reqBody;
+        }
+
+        if (action.Headers is not null)
+            foreach (var header in action.Headers)
+                httpReq.Headers.Add(header.Key, header.Value);
+
+        using var response = await http.SendAsync(httpReq, cancel);
+        var resBody = await response.Content.ReadAsStringAsync(cancel);
+        var resHeaders = response.Headers.ToDictionary();
+
+        await sender.Send(new CreateOutResCommand
+        {
+            ActionId = action.Id,
+            Header = JsonSerializer.Serialize(resHeaders, options: new() { WriteIndented = false }),
+            Body = resBody,
+            AddedWho = config?["AddedWho"]
+        }, cancel);
+    }
+}

src/ReC.Application/RecActions/MappingProfile.cs

@@ -0,0 +1,16 @@
+using ReC.Application.RecActions.Commands;
+using ReC.Domain.Entities;
+
+namespace ReC.Application.RecActions;
+
+// TODO: update to inject AddedWho from the current host/user contex
+public class MappingProfile : AutoMapper.Profile
+{
+    public MappingProfile()
+    {
+        CreateMap<CreateRecActionCommand, RecAction>()
+            .ForMember(e => e.Active, exp => exp.MapFrom(cmd => true))
+            .ForMember(e => e.AddedWhen, exp => exp.MapFrom(cmd => DateTime.UtcNow))
+            .ForMember(e => e.AddedWho, exp => exp.MapFrom(cmd => "ReC.API"));
+    }
+}

src/ReC.Application/RecActions/Queries/ReadRecActionQuery.cs

@@ -0,0 +1,48 @@
+using MediatR;
+using DigitalData.Core.Abstraction.Application.Repository;
+using ReC.Domain.Entities;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using DigitalData.Core.Exceptions;
+using ReC.Application.Common.Dto;
+
+namespace ReC.Application.RecActions.Queries;
+
+public record ReadRecActionQueryBase
+{
+    public long ProfileId { get; init; }
+
+    public ReadRecActionQuery ToReadQuery(Action<ReadRecActionQuery> modify)
+    {
+        ReadRecActionQuery query = new(this);
+        modify(query);
+        return query;
+    }
+}
+
+public record ReadRecActionQuery : ReadRecActionQueryBase, IRequest<IEnumerable<RecActionDto>>
+{
+    public ReadRecActionQuery(ReadRecActionQueryBase root) : base(root) { }
+
+    public bool? Invoked { get; set; } = null;
+
+    public ReadRecActionQuery() { }
+}
+
+public class ReadRecActionQueryHandler(IRepository<RecActionView> repo, IMapper mapper) : IRequestHandler<ReadRecActionQuery, IEnumerable<RecActionDto>>
+{
+    public async Task<IEnumerable<RecActionDto>> Handle(ReadRecActionQuery request, CancellationToken cancel)
+    {
+        var query = repo.Where(act => act.ProfileId == request.ProfileId);
+
+        if (request.Invoked is bool invoked)
+            query = invoked ? query.Where(act => act.Root!.OutRes != null) : query.Where(act => act.Root!.OutRes == null);
+
+        var actions = await query.ToListAsync(cancel);
+
+        if(actions.Count == 0)
+            throw new NotFoundException($"No actions found for the profile {request.ProfileId}.");
+
+        return mapper.Map<IEnumerable<RecActionDto>>(actions);
+    }
+}

src/ReC.Client/DependencyInjection.cs

@@ -0,0 +1,41 @@
+using Microsoft.Extensions.DependencyInjection;
+#if NETFRAMEWORK
+using System;
+using System.Net.Http;
+#endif
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Provides extension methods for setting up the ReC client in an <see cref="IServiceCollection"/>.
+    /// </summary>
+    public static class DependencyInjection
+    {
+        /// <summary>
+        /// Adds and configures the <see cref="HttpClient"/> for the <see cref="ReCClient"/> to the specified <see cref="IServiceCollection"/>
+        /// </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>
+        /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri)
+        {
+            services.AddScoped<ReCClient>();
+            return services.AddHttpClient(ReCClient.ClientName, client =>
+            {
+                client.BaseAddress = new Uri(apiUri);
+            });
+        }
+
+        /// <summary>
+        /// Adds and configures the <see cref="HttpClient"/> for the <see cref="ReCClient"/> to the specified <see cref="IServiceCollection"/>
+        /// </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>
+        /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient)
+        {
+            services.AddScoped<ReCClient>();
+            return services.AddHttpClient(ReCClient.ClientName, configureClient);
+        }
+    }
+}

src/ReC.Client/ReC.Client.csproj

@@ -2,10 +2,36 @@
 
 	<PropertyGroup>
 		<TargetFrameworks>net462;net8.0</TargetFrameworks>
+		<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(MSBuildProjectName).xml</DocumentationFile>
+		<PackageId>ReC.Client</PackageId>
+		<Authors>Digital Data GmbH</Authors>
+		<Company>Digital Data GmbH</Company>
+		<Product>ReC.Client</Product>
+		<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>
+		<Description>Client-Bibliothek für die Interaktion mit der ReC.API, die typisierten HTTP-Zugriff und DI-Integration bietet.</Description>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(TargetFramework)' != 'net462'">
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 	</PropertyGroup>
+
+	<ItemGroup>
+	  <None Include="..\..\assets\icon.png">
+	    <Pack>True</Pack>
+	    <PackagePath>\</PackagePath>
+	  </None>
+	</ItemGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+	  <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
+	  <PackageReference Include="System.Net.Http" Version="4.3.4" />
+	</ItemGroup>
 </Project>

src/ReC.Client/ReCClient.cs

@@ -0,0 +1,124 @@
+using Microsoft.Extensions.DependencyInjection;
+
+#if NETFRAMEWORK
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// A client for interacting with the ReC API.
+    /// </summary>
+    public class ReCClient
+    {
+        private readonly HttpClient _http;
+
+        /// <summary>
+        /// A unique name for the HttpClient used by the ReCClient.
+        /// </summary>
+        public static readonly string ClientName = Guid.NewGuid().ToString();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReCClient"/> class.
+        /// </summary>
+        /// <param name="httpClientFactory">The factory to create HttpClients.</param>
+        public ReCClient(IHttpClientFactory httpClientFactory)
+        {
+            _http = httpClientFactory.CreateClient(ClientName);
+        }
+
+        /// <summary>
+        /// Asynchronously invokes a ReC action for a specific profile.
+        /// </summary>
+        /// <remarks>
+        /// This method sends a POST request to the <c>api/RecAction/invoke/{profileId}</c> endpoint.
+        /// </remarks>
+        /// <param name="profileId">The ID of the profile to invoke the action for.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation. The task result is <see langword="true"/> if the request was successful; otherwise, <see langword="false"/>.</returns>
+        public async Task<bool> InvokeRecActionAsync(int profileId, CancellationToken cancellationToken = default)
+        {
+            var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, cancellationToken);
+            return resp.IsSuccessStatusCode;
+        }
+
+        /// <summary>
+        /// Synchronously invokes a ReC action for a specific profile.
+        /// </summary>
+        /// <remarks>
+        /// This method sends a POST request to the <c>api/RecAction/invoke/{profileId}</c> endpoint.
+        /// This is the synchronous version of <see cref="InvokeRecActionAsync(int, CancellationToken)"/>.
+        /// </remarks>
+        /// <param name="profileId">The ID of the profile to invoke the action for.</param>
+        /// <returns><see langword="true"/> if the request was successful; otherwise, <see langword="false"/>.</returns>
+        [Obsolete("Use InvokeRecActionAsync instead to avoid potential deadlocks and improve performance.")]
+        public bool InvokeRecAction(int profileId)
+        {
+            var resp = _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null).GetAwaiter().GetResult();
+            return resp.IsSuccessStatusCode;
+        }
+
+        #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
+    }
+}

src/ReC.Domain/Entities/BodyQueryResult.cs.cs

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

src/ReC.Domain/Entities/Connection.cs

@@ -0,0 +1,52 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBDD_CONNECTION")]
+public class Connection
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("GUID")]
+    public short? Id { get; set; }
+
+    [Column("BEZEICHNUNG")]
+    public string? Bezeichnung { get; set; }
+
+    [Column("SQL_PROVIDER")]
+    public string? SqlProvider { get; set; }
+
+    [Column("SERVER")]
+    public string? Server { get; set; }
+
+    [Column("DATENBANK")]
+    public string? Datenbank { get; set; }
+
+    [Column("USERNAME")]
+    public string? Username { get; set; }
+
+    [Column("PASSWORD")]
+    public string? Password { get; set; }
+
+    [Column("BEMERKUNG")]
+    public string? Bemerkung { get; set; }
+
+    [Column("AKTIV")]
+    public bool? Aktiv { get; set; }
+
+    [Column("ERSTELLTWER")]
+    public string? ErstelltWer { get; set; }
+
+    [Column("ERSTELLTWANN")]
+    public DateTime? ErstelltWann { get; set; }
+
+    [Column("GEANDERTWER")]
+    public string? GeandertWer { get; set; }
+
+    [Column("GEAENDERTWANN")]
+    public DateTime? GeaendertWann { get; set; }
+
+    [Column("SYS_CONNECTION")]
+    public bool? SysConnection { get; set; }
+}

src/ReC.Domain/Entities/Endpoint.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBREC_CFG_ENDPOINT")]
+public class Endpoint
+{
+    [Key]
+    [Column("GUID")]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public long Id { get; set; }
+
+    [Column("ACTIVE")]
+    public bool? Active { get; set; }
+
+    [Column("DESCRIPTION")]
+    public string? Description { get; set; }
+
+    [Column("URI")]
+    public string? Uri { 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.Domain/Entities/EndpointAuth.cs

@@ -0,0 +1,58 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBREC_CFG_ENDPOINT_AUTH")]
+public class EndpointAuth
+{
+    [Key]
+    [Column("GUID")]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public long? Id { get; set; }
+
+    [Column("ACTIVE")]
+    public bool? Active { get; set; }
+
+    [Column("DESCRIPTION")]
+    public string? Description { get; set; }
+
+    [Column("TYPE")]
+    public string? Type { get; set; }
+
+    [Column("API_KEY")]
+    public string? ApiKey { get; set; }
+
+    [Column("API_VALUE")]
+    public string? ApiValue { get; set; }
+
+    [Column("API_KEY_ADD_TO")]
+    public string? ApiKeyAddTo { get; set; }
+
+    [Column("TOKEN")]
+    public string? Token { get; set; }
+
+    [Column("USERNAME")]
+    public string? Username { get; set; }
+
+    [Column("PASSWORD")]
+    public string? Password { get; set; }
+
+    [Column("DOMAIN")]
+    public string? Domain { get; set; }
+
+    [Column("WORKSTATION")]
+    public string? Workstation { 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.Domain/Entities/EndpointParam.cs

@@ -0,0 +1,47 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+/// <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>
+[Table("TBREC_CFG_ENDPOINT_PARAMS", Schema = "dbo")]
+public class EndpointParam
+{
+    [Key]
+    [Column("GUID")]
+    public long? Id { get; set; }
+
+    [Column("ACTIVE")]
+    public bool? Active { get; set; }
+
+    [Column("DESCRIPTION")]
+    public string? Description { get; set; }
+
+    [Column("GROUP_ID")]
+    public short? GroupId { get; set; }
+
+    [Column("SEQUENCE")]
+    public byte? Sequence { get; set; }
+
+    [Column("KEY")]
+    public string? Key { get; set; }
+
+    [Column("VALUE")]
+    public string? Value { 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.Domain/Entities/HeaderQueryResult.cs

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

src/ReC.Domain/Entities/OutRes.cs

@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBREC_OUT_RESULT", Schema = "dbo")]
+public class OutRes
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("GUID")]
+    public long? Id { get; set; }
+    
+    [Column("ACTION_ID")]
+    public long? ActionId { get; set; }
+
+    [ForeignKey("ActionId")]
+    public RecAction? Action { get; set; }
+
+    [Column("RESULT_HEADER")]
+    public string? Header { get; set; }
+
+    [Column("RESULT_BODY")]
+    public string? Body { 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.Domain/Entities/Profile.cs

@@ -0,0 +1,46 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBREC_CFG_PROFILE", Schema = "dbo")]
+public class Profile
+{
+    [Key]
+    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    [Column("GUID")]
+    public long Id { get; set; }
+
+    [Column("ACTIVE")]
+    public bool? Active { get; set; }
+
+    [Column("TYPE")]
+    public string? Type { get; set; }
+
+    [Column("MANDANTOR")]
+    public string? Mandantor { get; set; }
+
+    [Column("PROFILE_NAME")]
+    public string? Name { get; set; }
+
+    [Column("DESCRIPTION")]
+    public string? Description { get; set; }
+
+    [Column("LOG_LEVEL")]
+    public string? LogLevel { get; set; }
+
+    [Column("LANGUAGE")]
+    public string? Language { 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.Domain/Entities/RecAction.cs

@@ -0,0 +1,74 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+[Table("TBREC_CFG_ACTION")]
+public class RecAction
+{
+    [Key]
+    [Column("GUID")]
+    public long? Id { get; set; }
+
+    [Column("PROFILE_ID")]
+    public long? ProfileId { get; set; }
+
+    [ForeignKey("ProfileId")]
+    public Profile? Profile { get; set; }
+
+    [Column("ACTIVE")]
+    public bool? Active { get; set; }
+
+    [Column("SEQUENCE")]
+    public byte? Sequence { get; set; }
+
+    [Column("ENDPOINT_ID")]
+    public long? EndpointId { get; set; }
+
+    [ForeignKey("EndpointId")]
+    public Endpoint? Endpoint { get; set; }
+
+    [Column("ENDPOINT_AUTH_ID")]
+    public long? EndpointAuthId { get; set; }
+
+    [ForeignKey("EndpointAuthId")]
+    public EndpointAuth? EndpointAuth { get; set; }
+
+    [Column("ENDPOINT_PARAMS_ID")]
+    public short? EndpointParamsId { get; set; }
+
+    [Column("SQL_CONNECTION_ID")]
+    public short? SqlConnectionId { get; set; }
+
+    [ForeignKey("SqlConnectionId")]
+    public Connection? SqlConnection { get; set; }
+
+    [Column("TYPE")]
+    public string? Type { 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("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; }
+
+    public OutRes? OutRes { get; set; }
+}

src/ReC.Domain/Entities/RecActionView.cs

@@ -0,0 +1,123 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Domain.Entities;
+
+/// <summary>
+/// Represents the VWREC_ACTION view from the database.
+/// 
+/// All properties are defined as nullable to provide flexibility in case the underlying view
+/// changes in production (e.g., columns added, removed, or modified). This approach prevents
+/// runtime mapping errors and ensures the application can handle schema changes without
+/// requiring immediate code updates.
+/// </summary>
+[Table("VWREC_ACTION", Schema = "dbo")]
+public class RecActionView
+{
+    [Column("ACTION_ID")]
+    public required long Id { get; set; }
+
+    [ForeignKey("Id")]
+    public RecAction? Root { get; set; }
+
+    [Column("PROFILE_ID")]
+    public long? ProfileId { get; set; }
+
+    [ForeignKey("ProfileId")]
+    public Profile? Profile { get; set; }
+
+    [Column("PROFILE_NAME")]
+    [MaxLength(100)]
+    public string? ProfileName { get; set; }
+
+    [Column("PROFILE_TYPE")]
+    [MaxLength(20)]
+    public string? ProfileType { get; set; }
+
+    [Column("PROFILE_SEQUENCE")]
+    public byte? ProfileSequence { get; set; }
+
+    [Column("ENDPOINT_ID")]
+    public long? EndpointId { get; set; }
+
+    [Column("ENDPOINT_URI")]
+    [MaxLength(4000)]
+    public string? EndpointUri { get; set; }
+
+    [Column("ENDPOINT_AUTH_ID")]
+    public long? EndpointAuthId { get; set; }
+
+    [Column("ENDPOINT_AUTH_TYPE")]
+    [MaxLength(50)]
+    public string? EndpointAuthType { get; set; }
+
+    [Column("ENDPOINT_AUTH_API_KEY")]
+    [MaxLength(300)]
+    public string? EndpointAuthApiKey { get; set; }
+
+    [Column("ENDPOINT_AUTH_API_VALUE")]
+    [MaxLength(300)]
+    public string? EndpointAuthApiValue { get; set; }
+
+    [Column("ENDPOINT_AUTH_API_KEY_ADD_TO")]
+    [MaxLength(20)]
+    public string? EndpointAuthApiKeyAddTo { get; set; }
+
+    [Column("ENDPOINT_AUTH_TOKEN")]
+    [MaxLength(300)]
+    public string? EndpointAuthToken { get; set; }
+
+    [Column("ENDPOINT_AUTH_USERNAME")]
+    [MaxLength(200)]
+    public string? EndpointAuthUsername { get; set; }
+
+    [Column("ENDPOINT_AUTH_PASSWORD")]
+    [MaxLength(200)]
+    public string? EndpointAuthPassword { get; set; }
+
+    [Column("ENDPOINT_AUTH_DOMAIN")]
+    [MaxLength(100)]
+    public string? EndpointAuthDomain { get; set; }
+
+    [Column("ENDPOINT_AUTH_WORKSTATION")]
+    [MaxLength(100)]
+    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")]
+    [MaxLength(150)]
+    public string? SqlConnectionServer { get; set; }
+
+    [Column("SQL_CONNECTION_DB")]
+    [MaxLength(100)]
+    public string? SqlConnectionDb { get; set; }
+
+    [Column("SQL_CONNECTION_USERNAME")]
+    [MaxLength(100)]
+    public string? SqlConnectionUsername { get; set; }
+
+    [Column("SQL_CONNECTION_PASSWORD")]
+    [MaxLength(100)]
+    public string? SqlConnectionPassword { get; set; }
+
+    [Column("REST_TYPE")]
+    [MaxLength(20)]
+    public string? RestType { 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; }
+}

src/ReC.Infrastructure/DependencyInjection.cs

@@ -0,0 +1,42 @@
+using DigitalData.Core.Infrastructure;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using ReC.Application.Common.Interfaces;
+using ReC.Domain.Entities;
+
+namespace ReC.Infrastructure;
+
+public static class DependencyInjection
+{
+    public static IServiceCollection AddRecInfrastructure<TRecDbContext>(this IServiceCollection services, Action<ConfigurationOptions> options)
+        where TRecDbContext : RecDbContext
+    {
+        var configOpt = new ConfigurationOptions();
+        options.Invoke(configOpt);
+        
+        if(configOpt.DbContextOptionsAction is null)
+            throw new InvalidOperationException("DbContextOptionsAction must be configured.");
+
+        services.AddDbContext<TRecDbContext>(configOpt.DbContextOptionsAction);
+
+        services.AddScoped<IRecDbContext>(provider => provider.GetRequiredService<TRecDbContext>());
+
+        services.AddDbRepository(opt => opt.RegisterFromAssembly<TRecDbContext>(typeof(RecActionView).Assembly));
+
+        return services;
+    }
+
+    public static IServiceCollection AddRecInfrastructure(this IServiceCollection services, Action<ConfigurationOptions> options)
+        => services.AddRecInfrastructure<RecDbContext>(options);
+
+    public class ConfigurationOptions
+    {
+        internal Action<IServiceProvider, DbContextOptionsBuilder>? DbContextOptionsAction { get; private set; }
+
+        public ConfigurationOptions ConfigureDbContext(Action<IServiceProvider, DbContextOptionsBuilder> optionsAction)
+        {
+            DbContextOptionsAction = optionsAction;
+            return this;
+        }
+    }
+}

src/ReC.Infrastructure/ReC.Infrastructure.csproj

@@ -6,4 +6,15 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="DigitalData.Core.Infrastructure" Version="2.5.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.11" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ReC.Application\ReC.Application.csproj" />
+    <ProjectReference Include="..\ReC.Domain\ReC.Domain.csproj" />
+  </ItemGroup>
+
 </Project>

src/ReC.Infrastructure/RecDbContext.cs

@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore;
+using ReC.Application.Common.Interfaces;
+using ReC.Domain.Entities;
+
+namespace ReC.Infrastructure;
+
+public class RecDbContext(DbContextOptions<RecDbContext> options) : DbContext(options), IRecDbContext
+{
+    public DbSet<EndpointParam> EndpointParams { get; set; }
+
+    public DbSet<RecActionView> Actions { get; set; }
+
+    public DbSet<OutRes> OutRes { get; set; }
+
+    public DbSet<HeaderQueryResult> HeaderQueryResults { get; set; }
+
+    public DbSet<BodyQueryResult> BodyQueryResults { get; set; }
+
+    public DbSet<Connection> Connections { get; set; }
+
+    public DbSet<Endpoint> Endpoints { get; set; }
+
+    public DbSet<EndpointAuth> EndpointAuths { get; set; }
+
+    public DbSet<Profile> Profiles { get; set; }
+
+    public DbSet<RecAction> RecActions { get; set; }
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+
+        modelBuilder.Entity<RecActionView>().HasNoKey();
+
+        modelBuilder.Entity<HeaderQueryResult>().HasNoKey();
+
+        modelBuilder.Entity<BodyQueryResult>().HasNoKey();
+
+        modelBuilder.Entity<RecAction>()
+            .HasOne(act => act.OutRes)
+            .WithOne(res => res.Action)
+            .HasForeignKey<OutRes>(res => res.ActionId);
+    }
+}