Bump version to 2.0.0-beta in ReC.API.csproj

Updated <Version>, <AssemblyVersion>, <FileVersion>, and <InformationalVersion> fields from 1.0.3-beta to 2.0.0-beta to reflect a major version change, indicating significant updates or breaking changes in the project.

ReC.sln

@@ -15,6 +15,21 @@ 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
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "infrastructure", "infrastructure", "{3F88DACC-CEC0-4D9A-8BAA-37F67B02DC04}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "presentation", "presentation", "{3D6EF9B9-D00D-432A-8477-067902B5CE8E}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "core", "core", "{2CEF945E-94D6-4273-9BE1-20B628CD0A57}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{8353C9B1-CC4A-4097-A936-C06D4C618415}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReC.Tests", "tests\ReC.Tests\ReC.Tests.csproj", "{457ED5AC-F4A0-41C3-9758-4A3C272EDC11}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -41,16 +56,24 @@ Global
 		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}.Debug|Any CPU.Build.0 = Debug|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
+		{457ED5AC-F4A0-41C3-9758-4A3C272EDC11}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{457ED5AC-F4A0-41C3-9758-4A3C272EDC11}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{457ED5AC-F4A0-41C3-9758-4A3C272EDC11}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
-		{420218AD-3C27-4003-9A84-36C92352F175} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{2917BEA4-6C70-40CD-BD46-57D4ADB40296} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{587A4D14-EFDA-4BE3-8912-D3AF84743079} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{109645F5-441D-476B-B7D2-FBEAA8EBAE14} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
-		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{420218AD-3C27-4003-9A84-36C92352F175} = {3D6EF9B9-D00D-432A-8477-067902B5CE8E}
+		{2917BEA4-6C70-40CD-BD46-57D4ADB40296} = {2CEF945E-94D6-4273-9BE1-20B628CD0A57}
+		{587A4D14-EFDA-4BE3-8912-D3AF84743079} = {3F88DACC-CEC0-4D9A-8BAA-37F67B02DC04}
+		{109645F5-441D-476B-B7D2-FBEAA8EBAE14} = {2CEF945E-94D6-4273-9BE1-20B628CD0A57}
+		{DA3A6BDD-8045-478F-860B-D1F0EB97F02B} = {3D6EF9B9-D00D-432A-8477-067902B5CE8E}
+		{3F88DACC-CEC0-4D9A-8BAA-37F67B02DC04} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{3D6EF9B9-D00D-432A-8477-067902B5CE8E} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{2CEF945E-94D6-4273-9BE1-20B628CD0A57} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{457ED5AC-F4A0-41C3-9758-4A3C272EDC11} = {8353C9B1-CC4A-4097-A936-C06D4C618415}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {F7B09104-4072-4635-9492-9C7C68D96ABD}

src/ReC.API/Controllers/CommonController.cs

@@ -0,0 +1,33 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class CommonController(IMediator mediator) : ControllerBase
+{
+    [HttpPost]
+    public async Task<IActionResult> CreateObject([FromBody] InsertObjectProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    [HttpPut]
+    public async Task<IActionResult> UpdateObject([FromBody] UpdateObjectProcedure procedure, CancellationToken cancel)
+    {
+        var result = await mediator.Send(procedure, cancel);
+        return Ok(result);
+    }
+
+    [HttpDelete]
+    public async Task<IActionResult> DeleteObject([FromBody] DeleteObjectProcedure procedure, CancellationToken cancel)
+    {
+        var result = await mediator.Send(procedure, cancel);
+        return Ok(result);
+    }
+}

src/ReC.API/Controllers/EndpointAuthController.cs

@@ -0,0 +1,56 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.EndpointAuth.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointAuthController(IMediator mediator, IConfiguration config) : ControllerBase
+{
+    /// <summary>
+    /// Inserts an endpoint authentication record via the ENDPOINT_AUTH insert procedure.
+    /// </summary>
+    /// <param name="procedure">InsertEndpointAuthProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>The created ENDPOINT_AUTH identifier.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Post([FromBody] InsertEndpointAuthProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.ExecuteInsertProcedure(procedure, config["AddedWho"], cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates an endpoint authentication record via the ENDPOINT_AUTH update procedure.
+    /// </summary>
+    /// <param name="id">ENDPOINT_AUTH identifier to update.</param>
+    /// <param name="procedure">UpdateEndpointAuthProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Put([FromRoute] long id, [FromBody] UpdateEndpointAuthProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoint authentication records via the ENDPOINT_AUTH delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteEndpointAuthProcedure payload (Start, End, Force).</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromBody] DeleteEndpointAuthProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/EndpointParamsController.cs

@@ -0,0 +1,56 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.EndpointParams.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointParamsController(IMediator mediator, IConfiguration config) : ControllerBase
+{
+    /// <summary>
+    /// Inserts endpoint parameter records via the ENDPOINT_PARAMS insert procedure.
+    /// </summary>
+    /// <param name="procedure">InsertEndpointParamsProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>The created ENDPOINT_PARAMS identifier.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Post([FromBody] InsertEndpointParamsProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.ExecuteInsertProcedure(procedure, config["AddedWho"], cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates endpoint parameter records via the ENDPOINT_PARAMS update procedure.
+    /// </summary>
+    /// <param name="id">ENDPOINT_PARAMS identifier to update.</param>
+    /// <param name="procedure">UpdateEndpointParamsProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Put([FromRoute] long id, [FromBody] UpdateEndpointParamsProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoint parameter records via the ENDPOINT_PARAMS delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteEndpointParamsProcedure payload (Start, End, Force).</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromBody] DeleteEndpointParamsProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/EndpointsController.cs

@@ -0,0 +1,56 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Endpoints.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointsController(IMediator mediator, IConfiguration config) : ControllerBase
+{
+    /// <summary>
+    /// Inserts an endpoint via the ENDPOINT insert procedure.
+    /// </summary>
+    /// <param name="procedure">InsertEndpointProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>The created ENDPOINT identifier.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Post([FromBody] InsertEndpointProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.ExecuteInsertProcedure(procedure, config["AddedWho"], cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates an endpoint via the ENDPOINT update procedure.
+    /// </summary>
+    /// <param name="id">ENDPOINT identifier to update.</param>
+    /// <param name="procedure">UpdateEndpointProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Put([FromRoute] long id, [FromBody] UpdateEndpointProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoints via the ENDPOINT delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteEndpointProcedure payload (Start, End, Force).</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromBody] DeleteEndpointProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/ProfileController.cs

@@ -0,0 +1,63 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Profile.Commands;
+using ReC.Application.Profile.Queries;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class ProfileController(IMediator mediator) : ControllerBase
+{
+    [HttpGet]
+    public async Task<IActionResult> Get([FromQuery] ReadProfileViewQuery query, CancellationToken cancel)
+    {
+        return Ok(await mediator.Send(query, cancel));
+    }
+
+    /// <summary>
+    /// Inserts a profile via the PROFILE insert procedure.
+    /// </summary>
+    /// <param name="procedure">InsertProfileProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>The created profile identifier.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Post([FromBody] InsertProfileProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.ExecuteInsertProcedure(procedure, cancel: cancel);
+        return CreatedAtAction(nameof(Get), new { id }, id);
+    }
+
+    /// <summary>
+    /// Updates a profile via the PROFILE update procedure.
+    /// </summary>
+    /// <param name="id">Profile identifier to update.</param>
+    /// <param name="procedure">UpdateProfileProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Put([FromRoute] long id, [FromBody] UpdateProfileProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes profile records via the PROFILE delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteProfileProcedure payload (Start, End, Force).</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromBody] DeleteProfileProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/RecActionController.cs

@@ -1,100 +1,83 @@
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
-using ReC.API.Models;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
 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) : ControllerBase
+public class RecActionController(IMediator mediator, IConfiguration config) : ControllerBase
 {
-    private const long FakeProfileId = 2;
-
+    /// <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/{profileId}")]
+    [ProducesResponseType(StatusCodes.Status202Accepted)]
     public async Task<IActionResult> Invoke([FromRoute] int profileId, CancellationToken cancel)
     {
-        await mediator.InvokeBatchRecAction(profileId, cancel);
-        return Accepted();
-    }
-
-    [HttpPost("invoke/fake")]
-    public async Task<IActionResult> Invoke(CancellationToken cancel)
-    {
-        await mediator.InvokeBatchRecAction(FakeProfileId, cancel);
+        await mediator.InvokeBatchRecActionView(profileId, cancel);
         return Accepted();
     }
 
     #region CRUD
+    /// <summary>
+    /// Gets all RecActions for a given profile.
+    /// </summary>
+    /// <param name="query"></param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>A list of RecActions for the specified profile.</returns>
     [HttpGet]
-    public async Task<IActionResult> Get([FromQuery] long profileId, CancellationToken cancel) => Ok(await mediator.Send(new ReadRecActionQuery()
-    {
-        ProfileId = profileId
-    }, cancel));
-
-    [HttpGet("fake")]
-    public async Task<IActionResult> Get(CancellationToken cancel) => Ok(await mediator.Send(new ReadRecActionQuery()
-    {
-        ProfileId = FakeProfileId
-    }, cancel));
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    public async Task<IActionResult> Get([FromQuery] ReadRecActionViewQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, 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]
-    public async Task<IActionResult> CreateAction([FromBody] CreateRecActionCommand command, CancellationToken cancel)
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Create([FromBody] InsertActionProcedure command, CancellationToken cancel)
     {
-        await mediator.Send(command, cancel);
+        await mediator.ExecuteInsertProcedure(command, config["AddedWho"], cancel);
 
-        return CreatedAtAction(nameof(CreateAction), null);
+        return StatusCode(StatusCodes.Status201Created);
     }
 
-    [HttpPost("fake")]
-    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")
+    /// <summary>
+    /// Updates a RecAction via the ACTION update procedure.
+    /// </summary>
+    /// <param name="id">RecAction identifier to update.</param>
+    /// <param name="procedure">UpdateActionProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Update([FromRoute] long id, [FromBody] UpdateActionProcedure procedure, CancellationToken cancel)
     {
-        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 = FakeProfileId,
-            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);
-    }
-
-    [HttpDelete]
-    public async Task<IActionResult> Delete([FromQuery] int profileId, CancellationToken cancel)
-    {
-        await mediator.Send(new DeleteRecActionsCommand()
-        {
-            ProfileId = FakeProfileId
-        }, cancel);
-
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
         return NoContent();
     }
 
-    [HttpDelete("fake")]
-    public async Task<IActionResult> Delete(CancellationToken cancel)
+    /// <summary>
+    /// Deletes RecActions via the ACTION delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteActionProcedure payload (Start, End, Force).</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([FromBody] DeleteActionProcedure procedure, CancellationToken cancel)
     {
-        await mediator.Send(new DeleteRecActionsCommand()
-        {
-            ProfileId = FakeProfileId
-        }, cancel);
-
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
         return NoContent();
     }
     #endregion CRUD

src/ReC.API/Controllers/ResultController.cs

@@ -0,0 +1,69 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.API.Extensions;
+using ReC.API.Models;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Results.Commands;
+using ReC.Application.Results.Queries;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class ResultController(IMediator mediator) : 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] ReadResultViewQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, cancel));
+
+    /// <summary>
+    /// Inserts a RESULT record via the insert procedure.
+    /// </summary>
+    /// <param name="procedure">InsertResultProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>The created RESULT identifier.</returns>
+    [HttpPost]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    public async Task<IActionResult> Post([FromBody] InsertResultProcedure procedure, CancellationToken cancel)
+    {
+        var id = await mediator.ExecuteInsertProcedure(procedure, cancel: cancel);
+        return CreatedAtAction(nameof(Get), new { actionId = procedure.ActionId }, new { id, procedure.ActionId });
+    }
+
+    /// <summary>
+    /// Updates a RESULT record via the update procedure.
+    /// </summary>
+    /// <param name="id">RESULT identifier to update.</param>
+    /// <param name="procedure">UpdateResultProcedure payload.</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Put([FromRoute] long id, [FromBody] UpdateResultProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteUpdateProcedure(procedure, id, cancel: cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes RESULT records via the delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="procedure">DeleteResultProcedure payload (Start, End, Force).</param>
+    /// <param name="cancel">A token to cancel the operation.</param>
+    /// <returns>No content on success.</returns>
+    [HttpDelete]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Delete([FromBody] DeleteResultProcedure procedure, CancellationToken cancel)
+    {
+        await mediator.ExecuteDeleteProcedure(procedure, cancel);
+        return NoContent();
+    }
+}

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/AuthScopedFilter.cs

@@ -0,0 +1,18 @@
+using Microsoft.AspNetCore.Mvc.Filters;
+using ReC.Application.Common.Interfaces;
+
+namespace ReC.API.Middleware;
+
+public class AuthScopedFilter(IConfiguration config) : IAsyncActionFilter
+{
+    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
+    {
+        if (context.ActionArguments.TryGetValue("command", out var command) && command is IAuthScoped authScopedCommand)
+        {
+            var addedWho = config["AddedWho"] ?? throw new InvalidOperationException("The required 'AddedWho' configuration is missing. Please contact a system administrator.");
+            authScopedCommand.Scope.AddedWho = addedWho;
+        }
+
+        await next();
+    }
+}

src/ReC.API/Middleware/ExceptionHandlingMiddleware.cs

@@ -63,10 +63,17 @@ public class ExceptionHandlingMiddleware
         switch (exception)
         {
             case BadRequestException badRequestEx:
+                if (badRequestEx.InnerException is not null)
+                {
+                    logger.LogError(
+                        badRequestEx.InnerException,
+                        "BadRequestException inner exception captured.");
+                }
+
                 context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
                 details = new() 
                 { 
-                    Title = "Bad Request", 
+                    Title = "Bad Procedure", 
                     Detail = badRequestEx.Message 
                 };
                 break;
@@ -106,6 +113,57 @@ public class ExceptionHandlingMiddleware
                 };
                 break;
 
+            case InsertObjectFailedException insertFailedEx:
+                logger.LogError(
+                    insertFailedEx,
+                    "Insert operation failed during request processing. {procedure}",
+                    JsonSerializer.Serialize(
+                        insertFailedEx.Procedure,
+                        options: new() { WriteIndented = true }
+                    ));
+
+                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                details = new() 
+                {
+                    Title = "Insert Operation Failed",
+                    Detail = insertFailedEx.Message
+                };
+                break;
+
+            case UpdateObjectFailedException updateFailedEx:
+                logger.LogError(
+                    updateFailedEx,
+                    "Update operation failed during request processing. {procedure}",
+                    JsonSerializer.Serialize(
+                        updateFailedEx.Procedure,
+                        options: new() { WriteIndented = true }
+                    ));
+
+                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                details = new() 
+                {
+                    Title = "Update Operation Failed",
+                    Detail = updateFailedEx.Message
+                };
+                break;
+
+            case DeleteObjectFailedException deleteFailedEx:
+                logger.LogError(
+                    deleteFailedEx,
+                    "Delete operation failed during request processing. {procedure}",
+                    JsonSerializer.Serialize(
+                        deleteFailedEx.Procedure,
+                        options: new() { WriteIndented = true }
+                    ));
+
+                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
+                details = new() 
+                {
+                    Title = "Delete Operation Failed",
+                    Detail = deleteFailedEx.Message
+                };
+                break;
+
             default:
                 logger.LogError(exception, "Unhandled exception occurred.");
                 context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
@@ -120,4 +178,4 @@ public class ExceptionHandlingMiddleware
         if (details is not null)
             await context.Response.WriteAsJsonAsync(details);
     }
-}
+}

src/ReC.API/Models/ResultType.cs

@@ -0,0 +1,17 @@
+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

@@ -1,56 +1,99 @@
+using Microsoft.AspNetCore.Rewrite;
 using Microsoft.EntityFrameworkCore;
+using NLog;
+using NLog.Web;
 using ReC.API.Middleware;
 using ReC.Application;
 using ReC.Infrastructure;
+using System.Reflection;
+using LogLevel = Microsoft.Extensions.Logging.LogLevel;
 
-var builder = WebApplication.CreateBuilder(args);
+var logger = LogManager.Setup().LoadConfigurationFromAppSettings().GetCurrentClassLogger();
+logger.Info("Logging initialized!");
 
-var config = builder.Configuration;
-
-// Add services to the container.
-builder.Services.AddRecServices(options =>
+try
 {
-    options.LuckyPennySoftwareLicenseKey = builder.Configuration["LuckyPennySoftwareLicenseKey"];
-    options.ConfigureRecActions(config.GetSection("RecAction"));
-});
+    var builder = WebApplication.CreateBuilder(args);
 
-builder.Services.AddRecInfrastructure(options =>
-{
-    options.ConfigureDbContext((provider, opt) =>
+    builder.Logging.SetMinimumLevel(LogLevel.Trace);
+
+    if (!builder.Environment.IsDevelopment())
     {
-        var cnnStr = builder.Configuration.GetConnectionString("Default") 
-                               ?? throw new InvalidOperationException("Connection string is not found.");
+        builder.Logging.ClearProviders();
+        builder.Host.UseNLog();
+    }
 
-        var logger = provider.GetRequiredService<ILogger<RecDbContext>>();
-        opt.UseSqlServer(cnnStr)
-                .LogTo(log => logger.LogInformation("{log}", log), LogLevel.Trace)
-                .EnableSensitiveDataLogging()
-                .EnableDetailedErrors();
+    var config = builder.Configuration;
+
+    Directory
+        .GetFiles(builder.Environment.ContentRootPath, "appsettings.*.json", SearchOption.TopDirectoryOnly)
+        .Where(file => Path.GetFileName(file) != $"appsettings.Development.json")
+        .Where(file => Path.GetFileName(file) != $"appsettings.migration.json")
+        .ToList()
+        .ForEach(file => config.AddJsonFile(file, true, true));
+
+    // Add services to the container.
+    builder.Services.AddRecServices(options =>
+    {
+        options.LuckyPennySoftwareLicenseKey = builder.Configuration["LuckyPennySoftwareLicenseKey"];
+        options.ConfigureRecActions(config.GetSection("RecAction"));
+        options.ConfigureSqlException(config.GetSection("SqlException"));
     });
-});
 
-builder.Services.AddControllers();
-// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+    builder.Services.AddRecInfrastructure(options =>
+    {
+        options.ConfigureDbContext((provider, opt) =>
+        {
+            var cnnStr = builder.Configuration.GetConnectionString("Default")
+                                   ?? throw new InvalidOperationException("Connection string is not found.");
 
-var app = builder.Build();
+            var logger = provider.GetRequiredService<ILogger<RecDbContext>>();
+            opt.UseSqlServer(cnnStr)
+                    .LogTo(log => logger.LogInformation("{log}", log), LogLevel.Trace)
+                    .EnableSensitiveDataLogging()
+                    .EnableDetailedErrors();
+        });
+    });
+
+    builder.Services.AddControllers(options =>
+    {
+        options.Filters.Add<AuthScopedFilter>();
+    });
+    // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
+    builder.Services.AddEndpointsApiExplorer();
+    builder.Services.AddSwaggerGen(c =>
+    {
+        var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
+        var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
+        c.IncludeXmlComments(xmlPath);
+    });
+
+    var app = builder.Build();
 
 #pragma warning disable CS0618
-app.UseMiddleware<ExceptionHandlingMiddleware>();
+    app.UseMiddleware<ExceptionHandlingMiddleware>();
 #pragma warning restore CS0618
 
-// Configure the HTTP request pipeline.
-if (app.Environment.IsDevelopment())
-{
-    app.UseSwagger();
-    app.UseSwaggerUI();
+    // Configure the HTTP request pipeline.
+    if (app.Environment.IsDevelopment() || config.GetValue<bool>("UseSwagger"))
+    {
+        app.UseSwagger();
+        app.UseSwaggerUI();
+
+        var rewriteOptions = new RewriteOptions().AddRedirect("^$", "swagger");
+        app.UseRewriter(rewriteOptions);
+    }
+
+    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,14 +1,29 @@
 <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>2.0.0-beta</Version>
+	<AssemblyVersion>2.0.0.0</AssemblyVersion>
+	<FileVersion>2.0.0.0</FileVersion>
+	<InformationalVersion>2.0.0-beta</InformationalVersion>
+	<Copyright>Copyright © 2025 Digital Data GmbH. All rights reserved.</Copyright>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <NoWarn>$(NoWarn);1591</NoWarn>
   </PropertyGroup>
-
+		
   <ItemGroup>
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.11" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.6.2" />
+    <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>

src/ReC.API/appsettings.Logging.json

@@ -0,0 +1,59 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "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.API/appsettings.json

@@ -1,10 +1,5 @@
 {
-  "Logging": {
-    "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
-    }
-  },
+  "UseSwagger": true,
   "ConnectionStrings": {
     "Default": "Server=SDD-VMP04-SQL19\\DD_DEVELOP01;Database=DD_ECM;User Id=sa;Password=dd;Encrypt=false;TrustServerCertificate=True;"
   },
@@ -13,5 +8,11 @@
   "RecAction": {
     "MaxConcurrentInvocations": 5
   },
-  "AddedWho": "ReC.API"
+  // Bad request SqlException numbers numbers can be updated at runtime; no restart required.
+  "SqlException": {
+    // https://learn.microsoft.com/en-us/dotnet/api/system.data.sqlclient.sqlexception.number
+    "BadRequestSqlExceptionNumbers": [ 515, 547, 2601, 2627, 50000 ]
+  },
+  "AddedWho": "ReC.API",
+  "FakeProfileId": 2
 }

src/ReC.Abstractions.Application/ReC.Abstractions.Application.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

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

@@ -6,7 +6,7 @@ using Microsoft.EntityFrameworkCore;
 namespace ReC.Application.Common.Behaviors;
 
 public class BodyQueryBehavior<TRequest, TResponse>(IRecDbContext dbContext) : IPipelineBehavior<TRequest, TResponse>
-    where TRequest : RecActionDto
+    where TRequest : RecActionViewDto
     where TResponse : notnull
 {
     public async Task<TResponse> Handle(TRequest action, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)

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

@@ -8,7 +8,7 @@ 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 TRequest : RecActionViewDto
     where TResponse : notnull
 {
     public async Task<TResponse> Handle(TRequest action, RequestHandlerDelegate<TResponse> next, CancellationToken cancel)

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

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

src/ReC.Application/Common/Constants/Http.cs

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Constants;
+
+public static class Http
+{
+    public static readonly string ClientName = "HttpClient-" + Guid.NewGuid().ToString();
+}

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

@@ -0,0 +1,32 @@
+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,5 +1,4 @@
-using AutoMapper;
-using ReC.Domain.Entities;
+using ReC.Domain.Views;
 
 namespace ReC.Application.Common.Dto;
 
@@ -7,6 +6,8 @@ public class DtoMappingProfile : AutoMapper.Profile
 {
     public DtoMappingProfile()
     {
-        CreateMap<RecActionView, RecActionDto>();
+        CreateMap<RecActionView, RecActionViewDto>();
+        CreateMap<ResultView, ResultViewDto>();
+        CreateMap<ProfileView, ProfileViewDto>();
     }
 }

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,22 @@
+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,47 +1,33 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
+using System.ComponentModel.DataAnnotations.Schema;
 
-namespace ReC.Domain.Entities;
+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>
-[Table("TBREC_CFG_ENDPOINT_PARAMS", Schema = "dbo")]
-public class EndpointParam
+public record EndpointParamDto
 {
-    [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.Application/Common/Dto/ProfileDto.cs

@@ -0,0 +1,30 @@
+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/ProfileViewDto.cs

@@ -0,0 +1,42 @@
+namespace ReC.Application.Common.Dto;
+
+public class ProfileViewDto
+{
+    public long Id { get; init; }
+
+    public IEnumerable<RecActionViewDto>? RecActions { get; set; }
+
+    public bool Active { get; init; }
+
+    public byte TypeId { get; init; }
+
+    public string? Type { get; init; }
+
+    public string? Mandantor { get; init; }
+
+    public string? ProfileName { get; init; }
+
+    public string? Description { get; init; }
+
+    public byte LogLevelId { get; init; }
+
+    public string? LogLevel { get; init; }
+
+    public short LanguageId { get; init; }
+
+    public string? Language { get; init; }
+
+    public string? AddedWho { get; init; }
+
+    public DateTime AddedWhen { get; init; }
+
+    public string? ChangedWho { get; init; }
+
+    public DateTime? ChangedWhen { get; init; }
+
+    public DateTime? FirstRun { get; init; }
+
+    public DateTime? LastRun { get; init; }
+
+    public string? LastResult { get; init; }
+}

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

@@ -1,76 +1,53 @@
-namespace ReC.Application.Common.Dto;
+using ReC.Domain.Constants;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace ReC.Application.Common.Dto;
 
 public record RecActionDto
 {
-    public required long Id { get; init; }
+    public long? Id { get; set; }
 
-    public long? ProfileId { get; init; }
+    public long? ProfileId { get; set; }
 
-    public string? ProfileName { get; init; }
+    public ProfileDto? Profile { get; set; }
 
-    public string? ProfileType { get; init; }
+    public bool? Active { get; set; }
 
-    public byte? ProfileSequence { get; init; }
+    public byte? Sequence { get; set; }
 
-    public long? EndpointId { get; init; }
+    public long? EndpointId { get; set; }
 
-    public string? EndpointUri { get; init; }
+    public EndpointDto? Endpoint { get; set; }
 
-    public long? EndpointAuthId { get; init; }
+    public long? EndpointAuthId { get; set; }
 
-    public string? EndpointAuthType { get; init; }
+    public EndpointAuthDto? EndpointAuth { get; set; }
 
-    public string? EndpointAuthApiKey { get; init; }
+    public short? EndpointParamsId { get; set; }
 
-    public string? EndpointAuthApiValue { get; init; }
+    public short? SqlConnectionId { get; set; }
 
-    public string? EndpointAuthApiKeyAddTo { get; init; }
+    public ConnectionDto? SqlConnection { get; set; }
 
-    public string? EndpointAuthToken { get; init; }
+    public string? Type { get; set; }
 
-    public string? EndpointAuthUsername { get; init; }
+    public string? PreprocessingQuery { get; set; }
 
-    public string? EndpointAuthPassword { get; init; }
+    public string? HeaderQuery { get; set; }
 
-    public string? EndpointAuthDomain { get; init; }
+    public string? BodyQuery { get; set; }
 
-    public string? EndpointAuthWorkstation { get; init; }
+    public string? PostprocessingQuery { get; set; }
 
-    public short? EndpointParamsId { get; init; }
+    public ErrorAction? ErrorAction { get; set; }
 
-    public short? SqlConnectionId { get; init; }
+    public string? AddedWho { get; set; }
 
-    public string? SqlConnectionServer { get; init; }
+    public DateTime? AddedWhen { get; set; }
 
-    public string? SqlConnectionDb { get; init; }
+    public string? ChangedWho { get; set; }
 
-    public string? SqlConnectionUsername { get; init; }
+    public DateTime? ChangedWhen { get; set; }
 
-    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;
-    }
+    public OutResDto? OutRes { get; set; }
 }

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

@@ -0,0 +1,88 @@
+using ReC.Domain.Constants;
+
+namespace ReC.Application.Common.Dto;
+
+public record RecActionViewDto
+{
+    public required long Id { get; init; }
+
+    public long? ProfileId { get; init; }
+
+    public string? ProfileName { get; init; }
+
+    public ProfileType? ProfileType { get; init; }
+
+    public byte? Sequence { get; init; }
+
+    public long? EndpointId { get; init; }
+
+    public string? EndpointUri { get; init; }
+
+    public long? EndpointAuthId { get; init; }
+
+    public EndpointAuthType EndpointAuthType { get; init; } = EndpointAuthType.NoAuth;
+
+    public string? EndpointAuthTypeName { get; init; }
+
+    public string? EndpointAuthApiKey { get; init; }
+
+    public string? EndpointAuthApiValue { get; init; }
+
+    public ApiKeyLocation? EndpointAuthApiKeyAddTo { get; init; }
+
+    public string? EndpointAuthApiKeyAddToName { 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 RestType? RestType { get; init; }
+
+    public string? RestTypeName { 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 ErrorAction? ErrorAction { get; init; }
+
+    public string? ErrorActionName { get; init; }
+
+    public UriBuilder ToEndpointUriBuilder()
+    {
+        var builder = EndpointUri is null ? new UriBuilder() : new UriBuilder(EndpointUri);
+
+        builder.Port = -1;
+
+        if (ProfileType is ProfileType type)
+            builder.Scheme = type.ToUriBuilderScheme();
+
+        return builder;
+    }
+}

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

@@ -0,0 +1,34 @@
+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; }
+
+    public long? ProfileId { get; init; }
+
+    public ProfileViewDto? Profile { get; init; }
+
+    public string? ProfileName { get; init; }
+
+    public short? StatusCode { get; init; }
+
+    public string? StatusName { get; init; }
+
+    public string? Header { get; init; }
+
+    public string? Body { get; init; }
+
+    public string? AddedWho { get; init; }
+
+    public DateTime? AddedWhen { get; init; }
+
+    public string? ChangedWho { get; init; }
+
+    public DateTime? ChangedWhen { get; init; }
+}

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

@@ -0,0 +1,23 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.Common.Exceptions;
+
+public class DeleteObjectFailedException : Exception
+{
+    public DeleteObjectProcedure Procedure { get; }
+
+    public DeleteObjectFailedException(DeleteObjectProcedure procedure) : base()
+    {
+        Procedure = procedure;
+    }
+
+    public DeleteObjectFailedException(DeleteObjectProcedure procedure, string? message) : base(message)
+    {
+        Procedure = procedure;
+    }
+
+    public DeleteObjectFailedException(DeleteObjectProcedure procedure, string? message, Exception? innerException) : base(message, innerException)
+    {
+        Procedure = procedure;
+    }
+}

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

@@ -0,0 +1,23 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Common.Exceptions;
+
+public class InsertObjectFailedException : Exception
+{
+    public InsertObjectProcedure Procedure { get; }
+
+    public InsertObjectFailedException(InsertObjectProcedure procedure) : base()
+    {
+        Procedure = procedure;
+    }
+
+    public InsertObjectFailedException(InsertObjectProcedure procedure, string? message) : base(message)
+    {
+        Procedure = procedure;
+    }
+
+    public InsertObjectFailedException(InsertObjectProcedure procedure, string? message, Exception? innerException) : base(message, innerException)
+    {
+        Procedure = procedure;
+    }
+}

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

@@ -0,0 +1,23 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.Common.Exceptions;
+
+public class UpdateObjectFailedException : Exception
+{
+    public UpdateObjectProcedure Procedure { get; }
+
+    public UpdateObjectFailedException(UpdateObjectProcedure procedure) : base()
+    {
+        Procedure = procedure;
+    }
+
+    public UpdateObjectFailedException(UpdateObjectProcedure procedure, string? message) : base(message)
+    {
+        Procedure = procedure;
+    }
+
+    public UpdateObjectFailedException(UpdateObjectProcedure procedure, string? message, Exception? innerException) : base(message, innerException)
+    {
+        Procedure = procedure;
+    }
+}

src/ReC.Application/Common/HttpExtensions.cs

@@ -1,25 +1,28 @@
-using System.Diagnostics.CodeAnalysis;
+using ReC.Domain.Constants;
+using System.Diagnostics.CodeAnalysis;
 
 namespace ReC.Application.Common;
 
 public static class HttpExtensions
 {
-    private static readonly Dictionary<string, HttpMethod> _methods = new(StringComparer.OrdinalIgnoreCase)
+    private static readonly Dictionary<RestType, HttpMethod> _methods = new()
     {
-        ["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
+        [RestType.Get] = HttpMethod.Get,
+        [RestType.Post] = HttpMethod.Post,
+        [RestType.Put] = HttpMethod.Put,
+        [RestType.Delete] = HttpMethod.Delete,
+        [RestType.Patch] = HttpMethod.Patch,
+        [RestType.Head] = HttpMethod.Head,
+        [RestType.Options] = HttpMethod.Options,
+        [RestType.Trace] = HttpMethod.Trace,
+        [RestType.Connect] = HttpMethod.Connect
     };
 
-    public static HttpMethod ToHttpMethod(this string method) => _methods.TryGetValue(method, out var httpMethod) 
-        ? httpMethod 
-        : new HttpMethod(method);
+    public static HttpMethod ToHttpMethod(this RestType method) => !method.IsValid()
+            ? throw new ArgumentOutOfRangeException(nameof(method), $"The RestType value '{method}' is not valid.")
+            : _methods.TryGetValue(method, out var httpMethod)
+                ? httpMethod
+                : new HttpMethod(method.ToHttpMethodName());
 
     public static HttpRequestMessage ToHttpRequestMessage(this HttpMethod method, [StringSyntax(StringSyntaxAttribute.Uri)] string? requestUri)
         => new(method, requestUri);

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

@@ -0,0 +1,13 @@
+using System.Text.Json.Serialization;
+
+namespace ReC.Application.Common.Interfaces;
+
+public record AuthScope
+{
+    public string? AddedWho { get; set; }
+}
+
+public interface IAuthScoped : IScoped<AuthScope>
+{
+    public string? AddedWho => Scope.AddedWho;
+}

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

@@ -1,19 +1,24 @@
 using Microsoft.EntityFrameworkCore;
-using ReC.Domain.Entities;
+using ReC.Domain.QueryOutput;
+using ReC.Domain.Views;
 
 namespace ReC.Application.Common.Interfaces;
 
 public interface IRecDbContext
 {
-    public DbSet<EndpointParam> EndpointParams { get; }
+    #region DbSets
+    public DbSet<RecActionView> RecActionViews { get; set; }
 
-    public DbSet<RecActionView> Actions { get; }
+    public DbSet<ProfileView> ProfileViews { get; set; }
 
-    public DbSet<OutRes> OutRes { get; }
+    public DbSet<ResultView> RecResultViews { get; set; }
 
-    public DbSet<HeaderQueryResult> HeaderQueryResults { get; }
+    public DbSet<HeaderQueryResult> HeaderQueryResults { get; set; }
 
-    public DbSet<BodyQueryResult> BodyQueryResults { get; }
+    public DbSet<BodyQueryResult> BodyQueryResults { get; set; }
+
+    public DbSet<InsertObjectResult> RecResults { get; set; }
+    #endregion DbSets
 
     public Task<int> SaveChangesAsync(CancellationToken cancel = default);
 }

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

@@ -0,0 +1,10 @@
+using MediatR;
+using System.Text.Json.Serialization;
+
+namespace ReC.Application.Common.Interfaces;
+
+public interface IScoped<TScope> where TScope : notnull
+{
+    [JsonIgnore]
+    public TScope Scope { get; }
+}

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

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Options;
+
+public class SqlExceptionOptions
+{
+    public HashSet<int> BadRequestSqlExceptionNumbers { get; set; } = [];
+}

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

@@ -0,0 +1,91 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Options;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Options;
+
+namespace ReC.Application.Common.Procedures.DeleteProcedure;
+
+public record DeleteObjectProcedure : IRequest<int>
+{
+    /// <summary>
+    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// </summary>
+    public string Entity { get; set; } = null!;
+
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent data exists
+    /// </summary>
+    public bool Force { get; set; }
+}
+
+public static class DeleteObjectProcedureExtensions
+{
+    public static Task<int> ExecuteDeleteProcedure(this ISender sender, IDeleteProcedure procedure, CancellationToken cancel = default)
+    {
+        return sender.Send(procedure.ToObjectProcedure(), cancel);
+    }
+
+    public static Task<int> ExecuteDeleteProcedure(this ISender sender, string entity, long start, long end = 0, bool force = false, CancellationToken cancel = default)
+    {
+        return sender.Send(new DeleteObjectProcedure
+        {
+            Entity = entity,
+            Start = start,
+            End = end,
+            Force = force
+        }, cancel);
+    }
+}
+
+public class DeleteObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<DeleteObjectProcedure, int>
+{
+    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)
+        };
+
+        try
+        {
+            var result = await repo.ExecuteQueryRawAsync(
+                "DECLARE @RC SMALLINT = 0; " +
+                "EXEC @RC = [dbo].[PRREC_DELETE_OBJECT] " +
+                "@pENTITY, @pSTART, @pEND, @pFORCE; " +
+                "SELECT @RC;",
+                parameters,
+                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}");
+            }
+
+            return result;
+        }
+        catch (SqlException ex)
+        {
+            if (sqlExOpt.CurrentValue.BadRequestSqlExceptionNumbers.Contains(ex.Number))
+                throw new BadRequestException(ex.Message, ex);
+            else
+                throw;
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Procedures.DeleteProcedure;
+
+public interface IDeleteProcedure
+{
+    public DeleteObjectProcedure ToObjectProcedure();
+}

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

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Procedures.InsertProcedure;
+
+public interface IInsertProcedure
+{
+    public InsertObjectProcedure ToObjectProcedure(string? addedWho = null);
+}

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

@@ -0,0 +1,150 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Options;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Options;
+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;
+
+namespace ReC.Application.Common.Procedures.InsertProcedure;
+
+public record InsertObjectProcedure : IRequest<long>
+{
+    /// <summary>
+    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// </summary>
+    public string Entity { get; set; } = null!;
+
+    internal string? AddedWho { get; private set; }
+
+    public InsertObjectProcedure AddedBy(string? addedWho = null)
+    {
+        AddedWho = addedWho ?? "ReC.API";
+        return this;
+    }
+
+    public InsertActionProcedure Action { get; set; } = new();
+    public InsertEndpointProcedure Endpoint { get; set; } = new();
+    public InsertEndpointAuthProcedure EndpointAuth { get; set; } = new();
+    public InsertProfileProcedure Profile { get; set; } = new();
+    public InsertResultProcedure Result { get; set; } = new();
+    public InsertEndpointParamsProcedure EndpointParams { get; set; } = new();
+}
+
+public static class InsertObjectProcedureExtensions
+{
+    public static Task<long> ExecuteInsertProcedure(this ISender sender, IInsertProcedure procedure, string? addedWho = null, CancellationToken cancel = default)
+    {
+        return sender.Send(procedure.ToObjectProcedure(addedWho ?? "Rec.API"), cancel);
+    }
+}
+
+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("@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
+            }
+        };
+
+        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);
+        }
+        catch (SqlException ex)
+        {
+            if (sqlExOpt.CurrentValue.BadRequestSqlExceptionNumbers.Contains(ex.Number))
+                throw new BadRequestException(ex.Message, ex);
+            else
+                throw;
+        }
+
+        var guidParam = parameters.Last();
+
+        if (guidParam.Value != DBNull.Value)
+            if (guidParam.Value is long longValue)
+                return longValue;
+            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/UpdateProcedure/IUpdateProcedure.cs

@@ -0,0 +1,6 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure;
+
+public interface IUpdateProcedure
+{
+    public UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null);
+}

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

@@ -0,0 +1,151 @@
+using DigitalData.Core.Abstraction.Application.Repository;
+using DigitalData.Core.Exceptions;
+using MediatR;
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.Options;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Options;
+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;
+
+namespace ReC.Application.Common.Procedures.UpdateProcedure;
+
+public record UpdateObjectProcedure : IRequest<int>
+{
+    /// <summary>
+    /// Target entity: ACTION, ENDPOINT, ENDPOINT_AUTH, ENDPOINT_PARAMS, PROFILE, RESULT
+    /// </summary>
+    public string Entity { get; set; } = null!;
+
+    /// <summary>
+    /// Target GUID to update (required)
+    /// </summary>
+    public long Id { get; set; }
+
+    internal string? ChangedWho { get; private set; }
+
+    public UpdateObjectProcedure ChangedBy(string? changedWho = null)
+    {
+        ChangedWho = changedWho ?? "ReC.API";
+        return this;
+    }
+
+    public UpdateActionProcedure Action { get; set; } = new();
+    public UpdateEndpointProcedure Endpoint { get; set; } = new();
+    public UpdateEndpointAuthProcedure EndpointAuth { get; set; } = new();
+    public UpdateProfileProcedure Profile { get; set; } = new();
+    public UpdateResultProcedure Result { get; set; } = new();
+    public UpdateEndpointParamsProcedure EndpointParams { get; set; } = new();
+}
+
+public static class UpdateObjectProcedureExtensions
+{
+    public static Task<int> ExecuteUpdateProcedure(this ISender sender, IUpdateProcedure procedure, long id, string? changedWho = null, CancellationToken cancel = default)
+    {
+        return sender.Send(procedure.ToObjectProcedure(id, changedWho ?? "ReC.API"), cancel);
+    }
+}
+
+public class UpdateObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<UpdateObjectProcedure, int>
+{
+    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)
+        };
+
+        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);
+
+            // 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}");
+            }
+
+            return result;
+        }
+        catch (SqlException ex)
+        {
+            if (sqlExOpt.CurrentValue.BadRequestSqlExceptionNumbers.Contains(ex.Number))
+                throw new BadRequestException(ex.Message, ex);
+            else
+                throw;
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+using FluentValidation;
+using ReC.Application.Common.Interfaces;
+
+namespace ReC.Application.Common.Validations;
+
+public class AuthScopedValidator : AbstractValidator<IAuthScoped>
+{
+    public AuthScopedValidator()
+    {
+        RuleFor(x => x.AddedWho)
+            .NotEmpty()
+            .WithMessage("The 'AddedWho' field is required. A missing value may indicate an API configuration issue. Please contact your system administrator for assistance.");
+    }
+}

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

@@ -0,0 +1,87 @@
+using FluentValidation;
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Common.Validations;
+
+public class InsertObjectProcedureValidator : AbstractValidator<InsertObjectProcedure>
+{
+    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.");
+
+        // ACTION validation
+        When(x => x.Entity == "ACTION", () =>
+        {
+            RuleFor(x => x.Action.ProfileId)
+                .NotNull()
+                .WithMessage("ACTION requires ActionProfileId (maps to @pACTION_PROFILE_ID).");
+
+            RuleFor(x => x.Action.EndpointId)
+                .NotNull()
+                .WithMessage("ACTION requires ActionEndpointId (maps to @pACTION_ENDPOINT_ID).");
+        });
+
+        // ENDPOINT validation
+        When(x => x.Entity == "ENDPOINT", () =>
+        {
+            RuleFor(x => x.Endpoint.Uri)
+                .NotEmpty()
+                .WithMessage("ENDPOINT requires EndpointUri (maps to @pENDPOINT_URI).")
+                .MaximumLength(2000);
+        });
+
+        // PROFILE validation
+        When(x => x.Entity == "PROFILE", () =>
+        {
+            RuleFor(x => x.Profile.Name)
+                .NotEmpty()
+                .WithMessage("PROFILE requires ProfileName (maps to @pPROFILE_NAME).")
+                .MaximumLength(50);
+
+            RuleFor(x => x.Profile.Mandantor)
+                .MaximumLength(50)
+                .When(x => x.Profile.Mandantor != null);
+
+            RuleFor(x => x.Profile.Description)
+                .MaximumLength(250)
+                .When(x => x.Profile.Description != null);
+        });
+
+        // RESULT validation
+        When(x => x.Entity == "RESULT", () =>
+        {
+            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", () =>
+        {
+            RuleFor(x => x.EndpointParams.GroupId)
+                .NotNull()
+                .WithMessage("ENDPOINT_PARAMS requires EndpointParamsGroupId (maps to @pENDPOINT_PARAMS_GROUP_ID).");
+        });
+
+        // Simple length guards for some string fields (optional but cheap)
+        RuleFor(x => x.AddedWho)
+            .MaximumLength(50)
+            .When(x => x.AddedWho != null);
+
+        RuleFor(x => x.Endpoint.Description)
+            .MaximumLength(250)
+            .When(x => x.Endpoint.Description != null);
+
+        RuleFor(x => x.EndpointAuth.Description)
+            .MaximumLength(250)
+            .When(x => x.EndpointAuth.Description != null);
+    }
+}

src/ReC.Application/DependencyInjection.cs

@@ -1,10 +1,13 @@
-using MediatR;
+using FluentValidation;
+using MediatR;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using ReC.Application.Common.Behaviors;
+using ReC.Application.Common.Constants;
 using ReC.Application.Common.Options;
+using ReC.Application.Common.Procedures;
 using System.Reflection;
-using FluentValidation;
 
 namespace ReC.Application;
 
@@ -35,7 +38,11 @@ public static class DependencyInjection
             cfg.LicenseKey = configOpt.LuckyPennySoftwareLicenseKey;
         });
 
-        services.AddHttpClient();
+        services.AddHttpClient(Http.ClientName)
+            .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler
+            {
+                UseDefaultCredentials = false
+            });
 
         return services;
     }
@@ -111,5 +118,23 @@ public static class DependencyInjection
             return this;
         }
         #endregion ConfigureRecActions
+
+        #region ConfigureSqlException
+        public ConfigurationOptions ConfigureSqlException(Action<SqlExceptionOptions> configure)
+        {
+            _configActions.Enqueue(services => services.Configure(configure));
+            return this;
+        }
+
+        public ConfigurationOptions ConfigureSqlException(IConfiguration configuration)
+        {
+            _configActions.Enqueue(services =>
+            {
+                services.Configure<SqlExceptionOptions>(configuration);
+            });
+
+            return this;
+        }
+        #endregion ConfigureSqlException
     }
 }

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

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record DeleteEndpointAuthProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent ACTION data exists
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "ENDPOINT_AUTH",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -0,0 +1,27 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record InsertEndpointAuthProcedure : IInsertProcedure
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public byte? TypeId { get; set; }
+    public string? ApiKey { get; set; }
+    public string? ApiValue { get; set; }
+    public bool? ApiKeyAddToId { 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 InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "ENDPOINT_AUTH",
+            EndpointAuth = this
+        }.AddedBy(addedWho);
+    }
+}

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

@@ -0,0 +1,28 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record UpdateEndpointAuthProcedure : IUpdateProcedure
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public byte? TypeId { get; set; }
+    public string? ApiKey { get; set; }
+    public string? ApiValue { get; set; }
+    public bool? ApiKeyAddToId { 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 UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "ENDPOINT_AUTH",
+            Id = id,
+            EndpointAuth = this
+        }.ChangedBy(changedWho);
+    }
+}

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

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record DeleteEndpointParamsProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent ACTION data exists
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "ENDPOINT_PARAMS",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -0,0 +1,22 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record InsertEndpointParamsProcedure : IInsertProcedure
+{
+    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 InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "ENDPOINT_PARAMS",
+            EndpointParams = this
+        }.AddedBy(addedWho);
+    }
+}

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

@@ -0,0 +1,23 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record UpdateEndpointParamsProcedure : IUpdateProcedure
+{
+    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 UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "ENDPOINT_PARAMS",
+            Id = id,
+            EndpointParams = this
+        }.ChangedBy(changedWho);
+    }
+}

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

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record DeleteEndpointProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent ACTION data exists
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "ENDPOINT",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -0,0 +1,19 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record InsertEndpointProcedure : IInsertProcedure
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public string? Uri { get; set; }
+
+    public InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "ENDPOINT",
+            Endpoint = this
+        }.AddedBy(addedWho);
+    }
+}

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

@@ -1,25 +0,0 @@
-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/Commands/UpdateEndpointProcedure.cs

@@ -0,0 +1,20 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record UpdateEndpointProcedure : IUpdateProcedure
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public string? Uri { get; set; }
+
+    public UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "ENDPOINT",
+            Id = id,
+            Endpoint = this
+        }.ChangedBy(changedWho);
+    }
+}

src/ReC.Application/Endpoints/MappingProfile.cs

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,8 +0,0 @@
-namespace ReC.Application.OutResults.Queries;
-
-public class ReadOutResQuery
-{
-    public long? ProfileId { get; set; }
-
-    public long? ActionId { get; set; }
-}

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

@@ -1,13 +0,0 @@
-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.");
-    }
-}

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

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.Profile.Commands;
+
+public record DeleteProfileProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent ACTION data exists
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "PROFILE",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -0,0 +1,23 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Profile.Commands;
+
+public record InsertProfileProcedure : IInsertProcedure
+{
+    public bool? Active { get; set; }
+    public byte? TypeId { get; set; }
+    public string? Mandantor { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public byte? LogLevelId { get; set; }
+    public short? LanguageId { get; set; }
+
+    public InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "PROFILE",
+            Profile = this
+        }.AddedBy(addedWho);
+    }
+}

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

@@ -0,0 +1,27 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.Profile.Commands;
+
+public record UpdateProfileProcedure : IUpdateProcedure
+{
+    public bool? Active { get; set; }
+    public byte? TypeId { get; set; }
+    public string? Mandantor { get; set; }
+    public string? Name { get; set; }
+    public string? Description { get; set; }
+    public byte? LogLevelId { get; set; }
+    public short? LanguageId { get; set; }
+    public DateTime? FirstRun { get; set; }
+    public DateTime? LastRun { get; set; }
+    public string? LastResult { get; set; }
+
+    public UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "PROFILE",
+            Id = id,
+            Profile = this
+        }.ChangedBy(changedWho);
+    }
+}

src/ReC.Application/Profile/Queries/ReadProfileViewQuery.cs

@@ -0,0 +1,36 @@
+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.Views;
+
+namespace ReC.Application.Profile.Queries;
+
+public record ReadProfileViewQuery : IRequest<IEnumerable<ProfileViewDto>>
+{
+    public long? Id { get; init; } = null;
+
+    public bool IncludeActions { get; init; } = true;
+}
+
+public class ReadProfileViewQueryHandler(IRepository<ProfileView> repo, IMapper mapper)
+    : IRequestHandler<ReadProfileViewQuery, IEnumerable<ProfileViewDto>>
+{
+    public async Task<IEnumerable<ProfileViewDto>> Handle(ReadProfileViewQuery request, CancellationToken cancel)
+    {
+        var query = request.IncludeActions
+            ? repo.Query.Include(p => p.Actions)
+            : repo.Query;
+
+        if (request.Id is long id)
+            query = query.Where(p => p.Id == id);
+
+        var profiles = await query.ToListAsync(cancel);
+
+        return profiles is null || profiles.Count == 0
+            ? throw new NotFoundException($"Profile {request.Id} not found.")
+            : mapper.Map<IEnumerable<ProfileViewDto>>(profiles);
+    }
+}

src/ReC.Application/ReC.Application.csproj

@@ -8,9 +8,9 @@
 
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="15.1.0" />
-    <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.5.0" />
+    <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.0" />
+    <PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.1" />
     <PackageReference Include="FluentValidation" Version="12.1.0" />
     <PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.1.0" />
     <PackageReference Include="MediatR" Version="13.1.0" />

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

@@ -1,45 +0,0 @@
-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/DeleteActionProcedure.cs

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record DeleteActionProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// If true, delete even if dependent RESULT data exists
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "ACTION",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -1,24 +0,0 @@
-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 long ProfileId { get; init; } = 2;
-}
-
-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/InsertActionProcedure.cs

@@ -0,0 +1,30 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Domain.Constants;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InsertActionProcedure : IInsertProcedure
+{
+    public long? ProfileId { get; set; }
+    public bool? Active { get; set; }
+    public byte? Sequence { get; set; }
+    public long? EndpointId { get; set; }
+    public long? EndpointAuthId { get; set; }
+    public short? EndpointParamsId { get; set; }
+    public short? SqlConnectionId { get; set; }
+    public RestType? TypeId { get; set; }
+    public string? PreSql { get; set; }
+    public string? HeaderSql { get; set; }
+    public string? BodySql { get; set; }
+    public string? PostSql { get; set; }
+    public byte? ErrorActionId { get; set; }
+
+    public InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "ACTION",
+            Action = this
+        }.AddedBy(addedWho);
+    }
+}

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

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.RecActions.Queries;
+using ReC.Domain.Constants;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InvokeBatchRecActionViewsCommand : IRequest
+{
+    public long ProfileId { 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 async Task Handle(InvokeBatchRecActionViewsCommand request, CancellationToken cancel)
+    {
+        var actions = await sender.Send(new ReadRecActionViewQuery() { ProfileId = request.ProfileId, Invoked = false }, cancel);
+
+        foreach (var action in actions)
+        {
+            var ok = await sender.Send(action.ToInvokeCommand(), cancel);
+            if (!ok)
+                switch (action.ErrorAction)
+                {
+                    case ErrorAction.Continue:
+                        break;
+                    default:
+                        return;
+                }
+        }
+    }
+}

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

@@ -1,49 +0,0 @@
-using MediatR;
-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, IHttpClientFactory clientFactory, ILogger<InvokeRecActionsCommandHandler>? logger = null) : IRequestHandler<InvokeBatchRecActionsCommand>
-{
-    public async Task Handle(InvokeBatchRecActionsCommand request, CancellationToken cancel)
-    {
-        var actions = await sender.Send(request.ToReadQuery(), cancel);
-
-        var http = clientFactory.CreateClient();
-
-        using var semaphore = new SemaphoreSlim(5);
-
-        var tasks = actions.Select(async action =>
-        {
-            await semaphore.WaitAsync(cancel);
-            try
-            {
-              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

@@ -1,65 +0,0 @@
-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/Commands/InvokeRecActionViewCommand.cs

@@ -0,0 +1,147 @@
+using MediatR;
+using Microsoft.Extensions.Configuration;
+using ReC.Application.Common;
+using ReC.Application.Common.Constants;
+using ReC.Application.Common.Dto;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Results.Commands;
+using ReC.Domain.Constants;
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InvokeRecActionViewCommand : IRequest<bool>
+{
+    public RecActionViewDto Action { get; set; } = null!;
+}
+
+public static class InvokeRecActionViewCommandExtensions
+{
+    public static InvokeRecActionViewCommand ToInvokeCommand(this RecActionViewDto dto) => new() { Action = dto };
+}
+
+public class InvokeRecActionViewCommandHandler(
+    ISender sender,
+    IHttpClientFactory clientFactory,
+    IConfiguration? config = null
+    ) : IRequestHandler<InvokeRecActionViewCommand, bool>
+{
+    public async Task<bool> Handle(InvokeRecActionViewCommand request, CancellationToken cancel)
+    {
+        var action = request.Action;
+
+        using var http = clientFactory.CreateClient(Http.ClientName);
+
+        if (action.RestType is not RestType restType)
+            throw new DataIntegrityException(
+                $"Rec action could not be invoked because the RestType value is null. " +
+                $"ProfileId: {action.ProfileId}, " +
+                $"Id: {action.Id}"
+            );
+
+        using var httpReq = 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);
+
+        switch (action.EndpointAuthType)
+        {
+            case EndpointAuthType.NoAuth:
+                break;
+
+            case EndpointAuthType.ApiKey:
+                if (action.EndpointAuthApiKey is string apiKey && action.EndpointAuthApiValue is string apiValue)
+                {
+                    switch (action.EndpointAuthApiKeyAddTo)
+                    {
+                        case ApiKeyLocation.Header:
+                            httpReq.Headers.Add(apiKey, apiValue);
+                            break;                        
+                        case ApiKeyLocation.Query:                        
+                            var uriBuilder = new UriBuilder(httpReq.RequestUri!);
+                            var query = System.Web.HttpUtility.ParseQueryString(uriBuilder.Query);
+                            query[apiKey] = apiValue;
+                            uriBuilder.Query = query.ToString();
+                            httpReq.RequestUri = uriBuilder.Uri;
+                            break;
+                        default:
+                            throw new DataIntegrityException(
+                                $"The API key location '{action.EndpointAuthApiKeyAddTo}' is not supported. " +
+                                $"ProfileId: {action.ProfileId}, " +
+                                $"Id: {action.Id}"
+                            );
+                    }
+                }
+                break;
+
+            case EndpointAuthType.BearerToken:
+            case EndpointAuthType.JwtBearer:
+            case EndpointAuthType.OAuth2:
+                if (action.EndpointAuthToken is string authToken)
+                    httpReq.Headers.Authorization = new AuthenticationHeaderValue("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);
+                }
+                break;
+
+            case EndpointAuthType.NtlmAuth:
+                if (!string.IsNullOrWhiteSpace(action.EndpointAuthUsername))
+                {
+                    var credentials = new NetworkCredential(
+                        action.EndpointAuthUsername,
+                        action.EndpointAuthPassword,
+                        action.EndpointAuthDomain);
+                    var credentialCache = new CredentialCache { { httpReq.RequestUri!, "NTLM", credentials } };
+                    httpReq.Options.Set(new HttpRequestOptionsKey<CredentialCache>("Credentials"), credentialCache);
+                }
+                break;
+
+            case EndpointAuthType.DigestAuth:
+            case EndpointAuthType.OAuth1:
+            case EndpointAuthType.AwsSignature:
+            // These authentication methods require more complex implementations,
+            // often involving multi-step handshakes or specialized libraries.
+            // They are left as placeholders for future implementation.
+            default:
+                throw new NotImplementedException(
+                    $"The authentication type '{action.EndpointAuthType}' is not supported yet. " +
+                    $"ProfileId: {action.ProfileId}, " +
+                    $"Id: {action.Id}"
+                );
+        }
+
+        using var response = await http.SendAsync(httpReq, cancel);
+        var resBody = await response.Content.ReadAsStringAsync(cancel);
+        var resHeaders = response.Headers.ToDictionary();
+
+        var statusCode = (short)response.StatusCode;
+
+        await sender.ExecuteInsertProcedure(new InsertResultProcedure()
+        {
+            StatusId = statusCode,
+            ActionId = action.Id,
+            Header = JsonSerializer.Serialize(resHeaders, options: new() { WriteIndented = false }),
+            Body = resBody
+        }, config?["AddedWho"], cancel);
+
+        return response.IsSuccessStatusCode;
+    }
+}

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

@@ -0,0 +1,30 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record UpdateActionProcedure : IUpdateProcedure
+{
+    public long? ProfileId { get; set; }
+    public bool? Active { get; set; }
+    public byte? Sequence { get; set; }
+    public long? EndpointId { get; set; }
+    public long? EndpointAuthId { get; set; }
+    public short? EndpointParamsId { get; set; }
+    public short? SqlConnectionId { get; set; }
+    public byte? TypeId { get; set; }
+    public string? PreSql { get; set; }
+    public string? HeaderSql { get; set; }
+    public string? BodySql { get; set; }
+    public string? PostSql { get; set; }
+    public byte? ErrorActionId { get; set; }
+
+    public UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "ACTION",
+            Id = id,
+            Action = this
+        }.ChangedBy(changedWho);
+    }
+}

src/ReC.Application/RecActions/MappingProfile.cs

@@ -1,16 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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() => new(this);
-}
-
-public record ReadRecActionQuery : ReadRecActionQueryBase, IRequest<IEnumerable<RecActionDto>>
-{
-    public ReadRecActionQuery(ReadRecActionQueryBase root) : base(root) { }
-
-    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 actions = await repo.Where(x => x.ProfileId == request.ProfileId).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.Application/RecActions/Queries/ReadRecActionViewQuery.cs

@@ -0,0 +1,39 @@
+using MediatR;
+using DigitalData.Core.Abstraction.Application.Repository;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using DigitalData.Core.Exceptions;
+using ReC.Application.Common.Dto;
+using ReC.Domain.Views;
+
+namespace ReC.Application.RecActions.Queries;
+
+public record ReadRecActionViewQuery : IRequest<IEnumerable<RecActionViewDto>>
+{
+    public long? ProfileId { get; init; } = null;
+
+    public bool? Invoked { get; set; } = null;
+}
+
+public class ReadRecActionViewQueryHandler(IRepository<RecActionView> repo, IMapper mapper) : IRequestHandler<ReadRecActionViewQuery, IEnumerable<RecActionViewDto>>
+{
+    public async Task<IEnumerable<RecActionViewDto>> Handle(ReadRecActionViewQuery request, CancellationToken cancel)
+    {
+        var query = repo.Query;
+
+        if (request.ProfileId is long profileId)
+            query = repo.Where(act => act.ProfileId == profileId);
+
+        if (request.Invoked is bool invoked)
+            query = invoked
+                ? query.Where(act => act.Results!.Any())
+                : query.Where(act => !act.Results!.Any());
+
+        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<RecActionViewDto>>(actions);
+    }
+}

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

@@ -0,0 +1,32 @@
+using ReC.Application.Common.Procedures.DeleteProcedure;
+
+namespace ReC.Application.Results.Commands;
+
+public record DeleteResultProcedure : IDeleteProcedure
+{
+    /// <summary>
+    /// Start GUID/ID (inclusive)
+    /// </summary>
+    public long Start { get; set; }
+
+    /// <summary>
+    /// End GUID/ID (inclusive). If 0, will be set to Start value.
+    /// </summary>
+    public long End { get; set; }
+
+    /// <summary>
+    /// Force parameter (not used for RESULT entity as it has no dependencies)
+    /// </summary>
+    public bool Force { get; set; }
+
+    public DeleteObjectProcedure ToObjectProcedure()
+    {
+        return new DeleteObjectProcedure
+        {
+            Entity = "RESULT",
+            Start = Start,
+            End = End,
+            Force = Force
+        };
+    }
+}

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

@@ -0,0 +1,20 @@
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Results.Commands;
+
+public record InsertResultProcedure : IInsertProcedure
+{
+    public long? ActionId { get; set; }
+    public short? StatusId { get; set; }
+    public string? Header { get; set; }
+    public string? Body { get; set; }
+
+    public InsertObjectProcedure ToObjectProcedure(string? addedWho = null)
+    {
+        return new InsertObjectProcedure
+        {
+            Entity = "RESULT",
+            Result = this
+        }.AddedBy(addedWho ?? "Rec.API");
+    }
+}

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

@@ -0,0 +1,21 @@
+using ReC.Application.Common.Procedures.UpdateProcedure;
+
+namespace ReC.Application.Results.Commands;
+
+public record UpdateResultProcedure : IUpdateProcedure
+{
+    public long? ActionId { get; set; }
+    public short? StatusId { get; set; }
+    public string? Header { get; set; }
+    public string? Body { get; set; }
+
+    public UpdateObjectProcedure ToObjectProcedure(long id, string? changedWho = null)
+    {
+        return new UpdateObjectProcedure
+        {
+            Entity = "RESULT",
+            Id = id,
+            Result = this
+        }.ChangedBy(changedWho);
+    }
+}

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

@@ -0,0 +1,49 @@
+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.Views;
+using System.Text.Json;
+
+namespace ReC.Application.Results.Queries;
+
+public record ReadResultViewQuery : IRequest<IEnumerable<ResultViewDto>>
+{
+    public long? Id { get; init; } = null;
+
+    public long? ActionId { get; init; } = null;
+
+    public long? ProfileId { get; init; } = null;
+}
+
+public class ReadResultViewQueryHandler(IRepository<ResultView> repo, IMapper mapper) : IRequestHandler<ReadResultViewQuery, IEnumerable<ResultViewDto>>
+{
+    public async Task<IEnumerable<ResultViewDto>> Handle(ReadResultViewQuery 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);
+
+        var entities = await q.ToListAsync(cancel);
+
+        if (entities.Count == 0)
+            throw new NotFoundException($"No result views found for the given criteria. Criteria: {
+                JsonSerializer.Serialize(request, options: new()
+                {
+                    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+                    WriteIndented = true
+                })}"
+            );
+
+        return mapper.Map<IEnumerable<ResultViewDto>>(entities);
+    }
+}

src/ReC.Client/Api/BaseCrudApi.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides shared CRUD operations for API resources.
+    /// </summary>
+    public abstract class BaseCrudApi
+    {
+        /// <summary>
+        /// The HTTP client used to send requests.
+        /// </summary>
+        protected readonly HttpClient Http;
+
+        /// <summary>
+        /// The base resource path for the API endpoint.
+        /// </summary>
+        protected readonly string ResourcePath;
+
+        /// <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)
+        {
+            Http = http ?? throw new ArgumentNullException(nameof(http));
+            ResourcePath = resourcePath ?? throw new ArgumentNullException(nameof(resourcePath));
+        }
+
+        /// <summary>
+        /// Creates a resource.
+        /// </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>
+        /// <returns>The HTTP response message.</returns>
+        public Task<HttpResponseMessage> CreateAsync<T>(T payload, CancellationToken cancel = default)
+            => Http.PostAsync(ResourcePath, ReCClientHelpers.ToJsonContent(payload), cancel);
+
+        /// <summary>
+        /// Updates a resource by identifier.
+        /// </summary>
+        /// <typeparam name="T">The payload type.</typeparam>
+        /// <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);
+
+        /// <summary>
+        /// Deletes resources with identifiers supplied in the payload.
+        /// </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)
+        {
+            var request = new HttpRequestMessage(HttpMethod.Delete, ResourcePath)
+            {
+                Content = ReCClientHelpers.ToJsonContent(payload)
+            };
+            return Http.SendAsync(request, cancel);
+        }
+    }
+}

src/ReC.Client/Api/CommonApi.cs

@@ -0,0 +1,20 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to common object endpoints.
+    /// </summary>
+    public class CommonApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+    }
+}

src/ReC.Client/Api/EndpointAuthApi.cs

@@ -0,0 +1,20 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to endpoint authentication endpoints.
+    /// </summary>
+    public class EndpointAuthApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+    }
+}

src/ReC.Client/Api/EndpointParamsApi.cs

@@ -0,0 +1,20 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to endpoint parameter endpoints.
+    /// </summary>
+    public class EndpointParamsApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+    }
+}

src/ReC.Client/Api/EndpointsApi.cs

@@ -0,0 +1,20 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to endpoint definitions.
+    /// </summary>
+    public class EndpointsApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+    }
+}

src/ReC.Client/Api/ProfileApi.cs

@@ -0,0 +1,33 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to profile endpoints.
+    /// </summary>
+    public class ProfileApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+
+        /// <summary>
+        /// Retrieves a profile by identifier.
+        /// </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)
+        {
+            var query = ReCClientHelpers.BuildQuery(("Id", id), ("IncludeActions", includeActions));
+            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+        }
+    }
+}

src/ReC.Client/Api/RecActionApi.cs

@@ -0,0 +1,45 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to RecAction endpoints.
+    /// </summary>
+    public class RecActionApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+
+        /// <summary>
+        /// Invokes a ReC action for the specified profile.
+        /// </summary>
+        /// <param name="profileId">The profile identifier.</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)
+        {
+            var resp = await Http.PostAsync($"{ResourcePath}/invoke/{profileId}", content: null, cancellationToken);
+            return resp.IsSuccessStatusCode;
+        }
+
+        /// <summary>
+        /// Retrieves Rec actions.
+        /// </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)
+        {
+            var query = ReCClientHelpers.BuildQuery(("ProfileId", profileId), ("Invoked", invoked));
+            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+        }
+    }
+}

src/ReC.Client/Api/ResultApi.cs

@@ -0,0 +1,34 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace ReC.Client.Api
+{
+    /// <summary>
+    /// Provides access to output result endpoints.
+    /// </summary>
+    public class ResultApi : BaseCrudApi
+    {
+        /// <summary>
+        /// 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")
+        {
+        }
+
+        /// <summary>
+        /// Retrieves results with optional filters.
+        /// </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)
+        {
+            var query = ReCClientHelpers.BuildQuery(("Id", id), ("ActionId", actionId), ("ProfileId", profileId));
+            return Http.GetAsync($"{ResourcePath}{query}", cancel);
+        }
+    }
+}

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,37 @@
 
 	<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" />
+    <PackageReference Include="System.Net.Http.Json" Version="8.0.0" />
+  </ItemGroup>
 </Project>

src/ReC.Client/ReCClient.cs

@@ -0,0 +1,150 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Net.Http;
+using ReC.Client.Api;
+
+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>
+        /// Provides access to RecAction endpoints.
+        /// </summary>
+        public RecActionApi RecActions { get; }
+
+        /// <summary>
+        /// Provides access to Result endpoints.
+        /// </summary>
+        public ResultApi Results { get; }
+
+        /// <summary>
+        /// Provides access to Profile endpoints.
+        /// </summary>
+        public ProfileApi Profiles { get; }
+
+        /// <summary>
+        /// Provides access to EndpointAuth endpoints.
+        /// </summary>
+        public EndpointAuthApi EndpointAuth { get; }
+
+        /// <summary>
+        /// Provides access to EndpointParams endpoints.
+        /// </summary>
+        public EndpointParamsApi EndpointParams { get; }
+
+        /// <summary>
+        /// Provides access to Endpoints endpoints.
+        /// </summary>
+        public EndpointsApi Endpoints { get; }
+
+        /// <summary>
+        /// Provides access to Common endpoints.
+        /// </summary>
+        public CommonApi Common { get; }
+
+        /// <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);
+            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);
+        }
+
+        #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>
+    /// Specifies which part of the result to return for result view endpoints.
+    /// </summary>
+    public enum ResultType
+    {
+        /// <summary>
+        /// Returns both header and body.
+        /// </summary>
+        Full,
+        /// <summary>
+        /// Returns only the header portion of the result.
+        /// </summary>
+        OnlyHeader,
+        /// <summary>
+        /// Returns only the body portion of the result.
+        /// </summary>
+        OnlyBody
+    }
+}

src/ReC.Client/ReCClientHelpers.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Net.Http.Json;
+
+#if NETFRAMEWORK
+using System.Net.Http;
+#endif
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Provides shared helpers for composing requests.
+    /// </summary>
+    internal static class ReCClientHelpers
+    {
+#if NETFRAMEWORK
+        /// <summary>
+        /// Builds a query string from the provided key/value pairs, skipping null values.
+        /// </summary>
+        /// <param name="parameters">The key/value pairs to include in the query string.</param>
+        /// <returns>A query string beginning with '?', or an empty string if no values are provided.</returns>
+        public static string BuildQuery(params (string Key, object Value)[] parameters)
+#else
+        /// <summary>
+        /// Builds a query string from the provided key/value pairs, skipping null values.
+        /// </summary>
+        /// <param name="parameters">The key/value pairs to include in the query string.</param>
+        /// <returns>A query string beginning with '?', or an empty string if no values are provided.</returns>
+        public static string BuildQuery(params (string Key, object? Value)[] parameters)
+#endif
+        {
+            var parts = parameters
+                .Where(p => p.Value != null)
+                .Select(p => $"{Uri.EscapeDataString(p.Key)}={Uri.EscapeDataString(Convert.ToString(p.Value, CultureInfo.InvariantCulture) ?? string.Empty)}");
+
+            var query = string.Join("&", parts);
+            return string.IsNullOrWhiteSpace(query) ? string.Empty : $"?{query}";
+        }
+
+        /// <summary>
+        /// Creates a JSON content payload from the provided object.
+        /// </summary>
+        /// <typeparam name="T">The type of the payload.</typeparam>
+        /// <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);
+    }
+}

src/ReC.Client/TaskSyncExtensions.cs

@@ -0,0 +1,26 @@
+#if NETFRAMEWORK
+using System.Threading.Tasks;
+#endif
+
+namespace ReC.Client
+{
+    /// <summary>
+    /// Provides synchronous wrappers for Task-based operations.
+    /// </summary>
+    public static class TaskSyncExtensions
+    {
+        /// <summary>
+        /// Blocks until the task completes and propagates any exception.
+        /// </summary>
+        /// <param name="task">The task to wait for.</param>
+        public static void Sync(this Task task) => task.ConfigureAwait(false).GetAwaiter().GetResult();
+
+        /// <summary>
+        /// Blocks until the task completes and returns its result, propagating any exception.
+        /// </summary>
+        /// <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>
+        public static TResult Sync<TResult>(this Task<TResult> task) => task.ConfigureAwait(false).GetAwaiter().GetResult();
+    }
+}