Bump version to 2.2.1-beta

Updated Version, AssemblyVersion, and FileVersion in ReC.API.csproj from 2.2.0-beta/2.2.0.0 to 2.2.1-beta/2.2.1.0. No other changes made.

ReC.sln

@@ -20,6 +20,16 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		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
@@ -46,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([FromQuery] DeleteObjectProcedure procedure, CancellationToken cancel)
+    {
+        var result = await mediator.Send(procedure, cancel);
+        return Ok(result);
+    }
+}

src/ReC.API/Controllers/EndpointAuthController.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.EndpointAuth.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointAuthController(IMediator mediator) : 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] InsertEndpointAuthCommand procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates an endpoint authentication record via the ENDPOINT_AUTH update procedure.
+    /// </summary>
+    /// <param name="id">The identifier of the ENDPOINT_AUTH record to update.</param>
+    /// <param name="data">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] UpdateEndpointAuthDto data, CancellationToken cancel)
+    {
+        await mediator.Send(new UpdateEndpointAuthCommand() { Id = id, Data = data}, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoint authentication records via the ENDPOINT_AUTH delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="command">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([FromQuery] DeleteEndpointAuthCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/EndpointParamsController.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.EndpointParams.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointParamsController(IMediator mediator) : 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] InsertEndpointParamsCommand procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates endpoint parameter records via the ENDPOINT_PARAMS update procedure.
+    /// </summary>
+    /// <param name="id">The identifier of the ENDPOINT_PARAMS record to update.</param>
+    /// <param name="data">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] UpdateEndpointParamsDto data, CancellationToken cancel)
+    {
+        await mediator.Send(new UpdateEndpointParamsCommand() { Id = id, Data = data }, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoint parameter records via the ENDPOINT_PARAMS delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="command">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([FromQuery] DeleteEndpointParamsCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/EndpointsController.cs

@@ -0,0 +1,54 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Endpoints.Commands;
+
+namespace ReC.API.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class EndpointsController(IMediator mediator) : 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] InsertEndpointCommand procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, cancel);
+        return StatusCode(StatusCodes.Status201Created, id);
+    }
+
+    /// <summary>
+    /// Updates an endpoint via the ENDPOINT update procedure.
+    /// </summary>
+    /// <param name="id">The identifier of the ENDPOINT record to update.</param>
+    /// <param name="data">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] UpdateEndpointDto data, CancellationToken cancel)
+    {
+        await mediator.Send(new UpdateEndpointCommand() { Id = id, Data = data }, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes endpoints via the ENDPOINT delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="command">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([FromQuery] DeleteEndpointCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/OutResController.cs

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

src/ReC.API/Controllers/ProfileController.cs

@@ -0,0 +1,61 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+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] InsertProfileCommand procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, cancel);
+        return CreatedAtAction(nameof(Get), new { id }, id);
+    }
+
+    /// <summary>
+    /// Updates a profile via the PROFILE update procedure.
+    /// </summary>
+    /// <param name="id">The identifier of the PROFILE record to update.</param>
+    /// <param name="data">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] UpdateProfileDto data, CancellationToken cancel)
+    {
+        await mediator.Send(new UpdateProfileCommand() { Id = id, Data = data }, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes profile records via the PROFILE delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="command">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([FromQuery] DeleteProfileCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/RecActionController.cs

@@ -1,42 +1,31 @@
 using MediatR;
 using Microsoft.AspNetCore.Mvc;
-using ReC.API.Extensions;
-using ReC.API.Models;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
 using ReC.Application.RecActions.Commands;
-using ReC.Application.RecActionViews.Commands;
-using ReC.Application.RecActionViews.Queries;
-using System.Text.Json;
+using ReC.Application.RecActions.Queries;
 
 namespace ReC.API.Controllers;
 
 [Route("api/[controller]")]
 [ApiController]
-public class RecActionController(IMediator mediator, IConfiguration config) : ControllerBase
+public class RecActionController(IMediator mediator) : ControllerBase
 {
     /// <summary>
     /// Invokes a batch of RecActions for a given profile.
     /// </summary>
-    /// <param name="profileId">The ID of the profile.</param>
+    /// <param name="profileId">The identifier of the profile whose RecActions should be invoked.</param>
+    /// <param name="references">Optional reference values that are passed through to all result records.</param>
     /// <param name="cancel">A token to cancel the operation.</param>
     /// <returns>An HTTP 202 Accepted response indicating the process has been started.</returns>
     [HttpPost("invoke/{profileId}")]
     [ProducesResponseType(StatusCodes.Status202Accepted)]
-    public async Task<IActionResult> Invoke([FromRoute] int profileId, CancellationToken cancel)
+    public async Task<IActionResult> Invoke([FromRoute] long profileId, [FromBody] InvokeReferences references, CancellationToken cancel = default)
     {
-        await mediator.InvokeBatchRecActionView(profileId, cancel);
-        return Accepted();
-    }
-
-    /// <summary>
-    /// Invokes a batch of RecActions for a fake/test profile.
-    /// </summary>
-    /// <param name="cancel">A token to cancel the operation.</param>
-    /// <returns>An HTTP 202 Accepted response indicating the process has been started.</returns>
-    [HttpPost("invoke/fake")]
-    [ProducesResponseType(StatusCodes.Status202Accepted)]
-    public async Task<IActionResult> Invoke(CancellationToken cancel)
-    {
-        await mediator.InvokeBatchRecActionView(config.GetFakeProfileId(), cancel);
+        await mediator.Send(new InvokeBatchRecActionViewsCommand
+        {
+            ProfileId = profileId,
+            References = references
+        }, cancel);
         return Accepted();
     }
 
@@ -51,20 +40,6 @@ public class RecActionController(IMediator mediator, IConfiguration config) : Co
     [ProducesResponseType(StatusCodes.Status200OK)]
     public async Task<IActionResult> Get([FromQuery] ReadRecActionViewQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, cancel));
 
-    /// <summary>
-    /// Gets all RecActions for a fake/test profile.
-    /// </summary>
-    /// <param name="cancel">A token to cancel the operation.</param>
-    /// <param name="invoked"></param>
-    /// <returns>A list of RecActions for the fake profile.</returns>
-    [HttpGet("fake")]
-    [ProducesResponseType(StatusCodes.Status200OK)]
-    public async Task<IActionResult> Get(CancellationToken cancel, [FromQuery] bool invoked = false) => Ok(await mediator.Send(new ReadRecActionViewQuery()
-    {
-        ProfileId = config.GetFakeProfileId(),
-        Invoked = invoked
-    }, cancel));
-
     /// <summary>
     /// Creates a new RecAction.
     /// </summary>
@@ -73,79 +48,39 @@ public class RecActionController(IMediator mediator, IConfiguration config) : Co
     /// <returns>An HTTP 201 Created response.</returns>
     [HttpPost]
     [ProducesResponseType(StatusCodes.Status201Created)]
-    public async Task<IActionResult> CreateAction([FromBody] CreateRecActionCommand command, CancellationToken cancel)
+    public async Task<IActionResult> Create([FromBody] InsertActionCommand command, CancellationToken cancel)
     {
         await mediator.Send(command, cancel);
 
-        return CreatedAtAction(nameof(CreateAction), null);
+        return StatusCode(StatusCodes.Status201Created);
     }
 
     /// <summary>
-    /// Creates a new fake RecAction for testing purposes.
+    /// Updates a RecAction via the ACTION update procedure.
     /// </summary>
+    /// <param name="id">The identifier of the ACTION record to update.</param>
+    /// <param name="data">UpdateActionProcedure payload.</param>
     /// <param name="cancel">A token to cancel the operation.</param>
-    /// <param name="request">The optional request body and header for the fake action.</param>
-    /// <param name="endpointUri">The target endpoint URI.</param>
-    /// <param name="endpointPath">The optional path to append to the endpoint URI.</param>
-    /// <param name="type">The HTTP method type (e.g., GET, POST).</param>
-    /// <returns>An HTTP 201 Created response.</returns>
-    [HttpPost("fake")]
-    [ProducesResponseType(StatusCodes.Status201Created)]
-    public async Task<IActionResult> CreateFakeAction(
-        CancellationToken cancel,
-        [FromBody] FakeRequest? request = null,
-        [FromQuery] string endpointUri = "https://jsonplaceholder.typicode.com/posts",
-        [FromQuery] string? endpointPath = "1",
-        [FromQuery] string type = "GET")
+    /// <returns>No content on success.</returns>
+    [HttpPut("{id:long}")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    public async Task<IActionResult> Update([FromRoute] long id, [FromBody] UpdateActionDto data, 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 = config.GetFakeProfileId(),
-            EndpointUri = endpointUri,
-            Type = type,
-            BodyQuery = $@"SELECT '{bodyJson ?? "NULL"}' AS REQUEST_BODY;",
-            HeaderQuery = headerJson is not null ? $@"SELECT '{headerJson}' AS REQUEST_HEADER;" : null,
-            Active = true,
-            EndpointAuthId = 4
-        }, cancel);
-
-        return CreatedAtAction(nameof(CreateFakeAction), null);
+        await mediator.Send(new UpdateActionCommand() { Id = id, Data = data }, cancel);
+        return NoContent();
     }
 
     /// <summary>
-    /// Deletes all RecActions associated with a specific profile.
+    /// Deletes RecActions via the ACTION delete procedure for the specified id range.
     /// </summary>
-    /// <param name="cmd"></param>
+    /// <param name="command">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([FromQuery] DeleteRecActionsCommand cmd, CancellationToken cancel)
+    public async Task<IActionResult> Delete([FromQuery] DeleteActionCommand command, CancellationToken cancel)
     {
-        await mediator.Send(cmd, cancel);
-        return NoContent();
-    }
-
-    /// <summary>
-    /// Deletes all RecActions for a fake/test profile.
-    /// </summary>
-    /// <param name="cancel">A token to cancel the operation.</param>
-    /// <returns>An HTTP 204 No Content response upon successful deletion.</returns>
-    [HttpDelete("fake")]
-    [ProducesResponseType(StatusCodes.Status204NoContent)]
-    public async Task<IActionResult> Delete(CancellationToken cancel)
-    {
-        await mediator.Send(new DeleteRecActionsCommand()
-        {
-            ProfileId = config.GetFakeProfileId()
-        }, cancel);
-
+        await mediator.Send(command, cancel);
         return NoContent();
     }
     #endregion CRUD

src/ReC.API/Controllers/ResultController.cs

@@ -0,0 +1,65 @@
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+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] InsertResultCommand procedure, CancellationToken cancel)
+    {
+        var id = await mediator.Send(procedure, 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">The identifier of the RESULT record to update.</param>
+    /// <param name="data">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] UpdateResultDto data, CancellationToken cancel)
+    {
+        await mediator.Send(new UpdateResultCommand() { Id = id, Data = data }, cancel);
+        return NoContent();
+    }
+
+    /// <summary>
+    /// Deletes RESULT records via the delete procedure for the specified id range.
+    /// </summary>
+    /// <param name="command">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([FromQuery] DeleteResultCommand command, CancellationToken cancel)
+    {
+        await mediator.Send(command, cancel);
+        return NoContent();
+    }
+}

src/ReC.API/Controllers/ResultViewController.cs

@@ -1,40 +0,0 @@
-using MediatR;
-using Microsoft.AspNetCore.Mvc;
-using ReC.API.Extensions;
-using ReC.Application.ResultViews.Queries;
-
-namespace ReC.API.Controllers;
-
-[Route("api/[controller]")]
-[ApiController]
-public class ResultViewController(IMediator mediator, IConfiguration config) : ControllerBase
-{
-    [HttpGet]
-    [ProducesResponseType(StatusCodes.Status200OK)]
-    public async Task<IActionResult> Get([FromQuery] ReadResultViewQuery query, CancellationToken cancel) => Ok(await mediator.Send(query, cancel));
-
-    [HttpGet("fake")]
-    [ProducesResponseType(StatusCodes.Status200OK)]
-    public async Task<IActionResult> Get(CancellationToken cancel) => Ok(await mediator.Send(new ReadResultViewQuery()
-    {
-        ProfileId = config.GetFakeProfileId()
-    }, cancel));
-
-    [HttpGet("fake/{actionId}")]
-    [ProducesResponseType(StatusCodes.Status200OK)]
-    public async Task<IActionResult> Get([FromRoute] long actionId, CancellationToken cancel, ResultType resultType = ResultType.Full)
-    {
-        var res = (await mediator.Send(new ReadResultViewQuery()
-        {
-            ProfileId = config.GetFakeProfileId(),
-            ActionId = actionId
-        }, cancel)).First();
-
-        return resultType switch
-        {
-            ResultType.Body => res.Body is null ? Ok(new object { }) : Ok(res.Body.JsonToDynamic()),
-            ResultType.Header => res.Header is null ? Ok(new object { }) : Ok(res.Header.JsonToDynamic()),
-            _ => Ok(res),
-        };
-    }
-}

src/ReC.API/Extensions/ConfigExtensions.cs

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

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

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

src/ReC.API/Models/FakeRequest.cs

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

src/ReC.API/Program.cs

@@ -37,6 +37,7 @@ try
     {
         options.LuckyPennySoftwareLicenseKey = builder.Configuration["LuckyPennySoftwareLicenseKey"];
         options.ConfigureRecActions(config.GetSection("RecAction"));
+        options.ConfigureSqlException(config.GetSection("SqlException"));
     });
 
     builder.Services.AddRecInfrastructure(options =>
@@ -54,7 +55,10 @@ try
         });
     });
 
-    builder.Services.AddControllers();
+    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 =>
@@ -66,9 +70,7 @@ try
 
     var app = builder.Build();
 
-#pragma warning disable CS0618
     app.UseMiddleware<ExceptionHandlingMiddleware>();
-#pragma warning restore CS0618
 
     // Configure the HTTP request pipeline.
     if (app.Environment.IsDevelopment() || config.GetValue<bool>("UseSwagger"))

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

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

src/ReC.API/ReC.API.csproj

@@ -10,13 +10,14 @@
 	<Product>ReC.API</Product>
 	<PackageIcon>Assets\icon.ico</PackageIcon>
 	<PackageTags>digital data rest-caller rec api</PackageTags>
-	<Version>1.0.3-beta</Version>
-	<AssemblyVersion>1.0.3.0</AssemblyVersion>
-	<FileVersion>1.0.3.0</FileVersion>
-	<InformationalVersion>1.0.3-beta</InformationalVersion>
+	<Version>2.2.1-beta</Version>
+	<AssemblyVersion>2.2.1.0</AssemblyVersion>
+	<FileVersion>2.2.1.0</FileVersion>
+	<InformationalVersion>2.2.0-beta</InformationalVersion>
 	<Copyright>Copyright © 2025 Digital Data GmbH. All rights reserved.</Copyright>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591</NoWarn>
+    <UserSecretsId>cf893b96-c71a-4a96-a6a7-40004249e1a3</UserSecretsId>
   </PropertyGroup>
 		
   <ItemGroup>

src/ReC.API/appsettings.json

@@ -6,8 +6,12 @@
   "AllowedHosts": "*",
   "LuckyPennySoftwareLicenseKey": "eyJhbGciOiJSUzI1NiIsImtpZCI6Ikx1Y2t5UGVubnlTb2Z0d2FyZUxpY2Vuc2VLZXkvYmJiMTNhY2I1OTkwNGQ4OWI0Y2IxYzg1ZjA4OGNjZjkiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2x1Y2t5cGVubnlzb2Z0d2FyZS5jb20iLCJhdWQiOiJMdWNreVBlbm55U29mdHdhcmUiLCJleHAiOiIxNzg0ODUxMjAwIiwiaWF0IjoiMTc1MzM2MjQ5MSIsImFjY291bnRfaWQiOiIwMTk4M2M1OWU0YjM3MjhlYmZkMzEwM2MyYTQ4NmU4NSIsImN1c3RvbWVyX2lkIjoiY3RtXzAxazB5NmV3MmQ4YTk4Mzg3aDJnbTRuOWswIiwic3ViX2lkIjoiLSIsImVkaXRpb24iOiIwIiwidHlwZSI6IjIifQ.ZqsFG7kv_-xGfxS6ACk3i0iuNiVUXX2AvPI8iAcZ6-z2170lGv__aO32tWpQccD9LCv5931lBNLWSblKS0MT3gOt-5he2TEftwiSQGFwoIBgtOHWsNRMinUrg2trceSp3IhyS3UaMwnxZDrCvx4-0O-kpOzVpizeHUAZNr5U7oSCWO34bpKdae6grtM5e3f93Z1vs7BW_iPgItd-aLvPwApbaG9VhmBTKlQ7b4Jh64y7UXJ9mKP7Qb_Oa97oEg0oY5DPHOWTZWeE1EzORgVr2qkK2DELSHuZ_EIUhODojkClPNAKtvEl_qEjpq0HZCIvGwfCCRlKlSkQqIeZdFkiXg",
   "RecAction": {
-    "MaxConcurrentInvocations": 5
+    "AddedWho": "ReC.API",
+    "UseHttp1ForNtlm": false
   },
-  "AddedWho": "ReC.API",
-  "FakeProfileId": 2
+  // 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 ]
+  }
 }

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/Action/BodyQueryBehavior.cs

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

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+using MediatR;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Interfaces;
+using ReC.Application.RecActions.Commands;
+using ReC.Application.Results.Commands;
+using ReC.Domain.Constants;
+using System.Text.Json;
+
+namespace ReC.Application.Common.Behaviors.InvokeAction;
+
+public class PostprocessingBehavior(IRecDbContext context, ISender sender) : IPipelineBehavior<InvokeRecActionViewCommand, Unit>
+{
+    public async Task<Unit> Handle(InvokeRecActionViewCommand request, RequestHandlerDelegate<Unit> next, CancellationToken cancel)
+    {
+        await next(cancel);
+
+        try
+        {
+            if (request.Action.PostprocessingQuery is string query)
+            {
+                var result = await context.ExecuteDynamicSqlAsync(query, cancel);
+                var info = JsonSerializer.Serialize(result);
+
+                await sender.Send(new InsertResultCommand()
+                {
+                    Status = RecStatus.OK,
+                    ActionId = request.Action.Id,
+                    InfoDetail = info,
+                    Type = ResultType.Post,
+                    References = request.References
+                }, cancel);
+            }
+        }
+        catch (Exception ex)
+        {
+            var error = ex.ToString();
+
+            await sender.Send(new InsertResultCommand()
+            {
+                Status = RecStatus.Error,
+                ActionId = request.Action.Id,
+                Error = error,
+                Type = ResultType.Post,
+                References = request.References
+            }, cancel);
+
+            if (request.Action.ErrorAction == ErrorAction.Stop)
+                throw new RecActionException(request.Action.Id, request.Action.ProfileId, ex);
+        }
+
+        return Unit.Value;
+    }
+}

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

@@ -0,0 +1,48 @@
+using MediatR;
+using ReC.Application.Common.Exceptions;
+using ReC.Application.Common.Interfaces;
+using ReC.Application.RecActions.Commands;
+using ReC.Application.Results.Commands;
+using ReC.Domain.Constants;
+using System.Text.Json;
+
+namespace ReC.Application.Common.Behaviors.InvokeAction;
+
+public class PreprocessingBehavior(IRecDbContext context, ISender sender) : IPipelineBehavior<InvokeRecActionViewCommand, Unit>
+{
+    public async Task<Unit> Handle(InvokeRecActionViewCommand request, RequestHandlerDelegate<Unit> next, CancellationToken cancel)
+    {
+        try
+        {
+            if (request.Action.PreprocessingQuery is string query)
+            {
+                var result = await context.ExecuteDynamicSqlAsync(query, cancel);
+
+                await sender.Send(new InsertResultCommand()
+                {
+                    Status = RecStatus.OK,
+                    ActionId = request.Action.Id,
+                    InfoDetail = JsonSerializer.Serialize(result),
+                    Type = ResultType.Pre,
+                    References = request.References
+                }, cancel);
+            }
+        }
+        catch (Exception ex)
+        {
+            await sender.Send(new InsertResultCommand()
+            {
+                Status = RecStatus.Error,
+                ActionId = request.Action.Id,
+                Error = ex.ToString(),
+                Type = ResultType.Pre,
+                References = request.References
+            }, cancel);
+
+            if (request.Action.ErrorAction == ErrorAction.Stop)
+                throw new RecActionException(request.Action.Id, request.Action.ProfileId, ex);
+        }
+
+        return await next(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/Dto/ConnectionDto.cs

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

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

@@ -1,4 +1,4 @@
-using ReC.Domain.Entities;
+using ReC.Domain.Views;
 
 namespace ReC.Application.Common.Dto;
 
@@ -6,16 +6,11 @@ public class DtoMappingProfile : AutoMapper.Profile
 {
     public DtoMappingProfile()
     {
-        CreateMap<RecActionView, RecActionViewDto>();
-        CreateMap<OutRes, OutResDto>();
-
-
-        CreateMap<Connection, ConnectionDto>();
-        CreateMap<EndpointAuth, EndpointAuthDto>();
-        CreateMap<Endpoint, EndpointDto>();
-        CreateMap<EndpointParam, EndpointParamDto>();
-        CreateMap<Profile, ProfileDto>();
-        CreateMap<RecAction, RecActionDto>();
+        CreateMap<RecActionView, RecActionViewDto>()
+            .ForMember(dest => dest.PreprocessingQuery, opt => opt.MapFrom((src, _) =>
+                src.PreprocessingQuery?.ReplacePlaceholders(src)))
+            .ForMember(dest => dest.PostprocessingQuery, opt => opt.MapFrom((src, _) =>
+                src.PostprocessingQuery?.ReplacePlaceholders(src)));
 
         CreateMap<ResultView, ResultViewDto>();
         CreateMap<ProfileView, ProfileViewDto>();

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

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

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

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

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-using System.ComponentModel.DataAnnotations.Schema;
-
-namespace ReC.Application.Common.Dto;
-
-[Table("TBREC_CFG_PROFILE", Schema = "dbo")]
-public record ProfileDto
-{
-    public long Id { get; set; }
-
-    public bool? Active { get; set; }
-
-    public string? Type { get; set; }
-
-    public string? Mandantor { get; set; }
-
-    public string? Name { get; set; }
-
-    public string? Description { get; set; }
-
-    public string? LogLevel { get; set; }
-
-    public string? Language { get; set; }
-
-    public string? AddedWho { get; set; }
-
-    public DateTime? AddedWhen { get; set; }
-
-    public string? ChangedWho { get; set; }
-
-    public DateTime? ChangedWhen { get; set; }
-}

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

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

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

@@ -8,6 +8,8 @@ public record RecActionViewDto
 
     public long? ProfileId { get; init; }
 
+    public ProfileViewDto? Profile { get; init; }
+
     public string? ProfileName { get; init; }
 
     public ProfileType? ProfileType { get; init; }
@@ -20,7 +22,7 @@ public record RecActionViewDto
 
     public long? EndpointAuthId { get; init; }
 
-    public EndpointAuthType? EndpointAuthType { get; init; }
+    public EndpointAuthType EndpointAuthType { get; init; } = EndpointAuthType.NoAuth;
 
     public string? EndpointAuthTypeName { get; init; }
 

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

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

src/ReC.Application/Common/Exceptions/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/RecActionException.cs

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

src/ReC.Application/Common/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,29 +0,0 @@
-using ReC.Domain.Constants;
-using System.Diagnostics.CodeAnalysis;
-
-namespace ReC.Application.Common;
-
-public static class HttpExtensions
-{
-    private static readonly Dictionary<RestType, HttpMethod> _methods = new()
-    {
-        [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 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,29 +1,61 @@
 using Microsoft.EntityFrameworkCore;
-using ReC.Domain.Entities;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using ReC.Domain.QueryOutput;
+using ReC.Domain.Views;
+using System.Text.Json;
 
 namespace ReC.Application.Common.Interfaces;
 
 public interface IRecDbContext
 {
-    public DbSet<EndpointParam> EndpointParams { get; set; }
-
+    #region DbSets
     public DbSet<RecActionView> RecActionViews { get; set; }
 
-    public DbSet<OutRes> OutRes { get; set; }
+    public DbSet<ProfileView> ProfileViews { get; set; }
+
+    public DbSet<ResultView> RecResultViews { get; set; }
 
     public DbSet<HeaderQueryResult> HeaderQueryResults { get; set; }
 
     public DbSet<BodyQueryResult> BodyQueryResults { get; set; }
 
-    public DbSet<Connection> Connections { get; set; }
-
-    public DbSet<Endpoint> Endpoints { get; set; }
-
-    public DbSet<EndpointAuth> EndpointAuths { get; set; }
-
-    public DbSet<Profile> Profiles { get; set; }
-
-    public DbSet<RecAction> RecActions { get; set; }
+    public DbSet<InsertObjectResult> RecResults { get; set; }
+    #endregion DbSets
 
     public Task<int> SaveChangesAsync(CancellationToken cancel = default);
+
+    public DatabaseFacade Database { get; }
+}
+
+public static class RecDbContextSaveExtensions
+{
+    //TODO: Once it is finalized, move it to Common.Infrastructure
+    public static async Task<IEnumerable<Dictionary<string, object?>>> ExecuteDynamicSqlAsync(this IRecDbContext context, string sql, CancellationToken cancel = default)
+    {
+        var result = new List<Dictionary<string, object?>>();
+
+        using var command = context.Database.GetDbConnection().CreateCommand();
+
+        command.CommandText = sql;
+
+        await context.Database.OpenConnectionAsync(cancel);
+
+        using var reader = await command.ExecuteReaderAsync(cancel);
+        while (await reader.ReadAsync(cancel))
+        {
+            var row = new Dictionary<string, object?>();
+
+            for (int i = 0; i < reader.FieldCount; i++)
+            {
+                var columnName = reader.GetName(i);
+                var value = reader.IsDBNull(i) ? null : reader.GetValue(i);
+
+                row[columnName] = value;
+            }
+
+            result.Add(row);
+        }
+
+        return result;
+    }
 }

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

@@ -2,5 +2,5 @@
 
 public class RecActionOptions
 {
-    public int MaxConcurrentInvocations { get; set; } = 5;
-}
+    public bool UseHttp1ForNtlm { get; set; } = false;
+}

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,63 @@
+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 for the delete operation.
+    /// </summary>
+    public required EntityType Entity { get; set; }
+
+    /// <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 class DeleteObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<DeleteObjectProcedure, int>
+{
+    public async Task<int> Handle(DeleteObjectProcedure request, CancellationToken cancel)
+    {
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_DELETE_OBJECT]", "RC")
+            .Add("pENTITY", request.Entity)
+            .Add("pSTART", request.Start.ToString())
+            .Add("pEND", request.End.ToString())
+            .Add("pFORCE", request.Force);
+
+        try
+        {
+            var result = await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
+
+            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,7 @@
+using MediatR;
+
+namespace ReC.Application.Common.Procedures.DeleteProcedure;
+
+public interface IDeleteProcedure : IRequest<int>
+{
+}

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

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

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

@@ -0,0 +1,7 @@
+using MediatR;
+
+namespace ReC.Application.Common.Procedures.InsertProcedure;
+
+public interface IInsertProcedure : IRequest<long>
+{
+}

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

@@ -0,0 +1,122 @@
+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;
+using System.Data;
+
+namespace ReC.Application.Common.Procedures.InsertProcedure;
+
+public record InsertObjectProcedure : IRequest<long>
+{
+    /// <summary>
+    /// Target entity for the insert operation.
+    /// </summary>
+    public required EntityType Entity { get; set; }
+
+    //TODO: update to set in authentication middleware or similar, and remove from procedure properties
+    internal string? AddedWho { get; private set; } = "ReC.API";
+
+    public InsertActionCommand? Action { get; set; }
+    public InsertEndpointCommand? Endpoint { get; set; }
+    public InsertEndpointAuthCommand? EndpointAuth { get; set; }
+    public InsertProfileCommand? Profile { get; set; }
+    public InsertResultCommand? Result { get; set; }
+    public InsertEndpointParamsCommand? EndpointParams { get; set; }
+}
+
+public class InsertObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<InsertObjectProcedure, long>
+{
+    public async Task<long> Handle(InsertObjectProcedure request, CancellationToken cancel)
+    {
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_INSERT_OBJECT]")
+            .Add("pENTITY", request.Entity)
+            .Add("pADDED_WHO", request.AddedWho)
+            .Add("pADDED_WHEN", DateTime.UtcNow)
+            .Add("pACTION_PROFILE_ID", request.Action?.ProfileId)
+            .Add("pACTION_ACTIVE", request.Action?.Active)
+            .Add("pACTION_SEQUENCE", request.Action?.Sequence, SqlDbType.TinyInt)
+            .Add("pACTION_ENDPOINT_ID", request.Action?.EndpointId)
+            .Add("pACTION_ENDPOINT_AUTH_ID", request.Action?.EndpointAuthId)
+            .Add("pACTION_ENDPOINT_PARAMS_ID", request.Action?.EndpointParamsId, SqlDbType.SmallInt)
+            .Add("pACTION_SQL_CONNECTION_ID", request.Action?.SqlConnectionId, SqlDbType.SmallInt)
+            .Add("pACTION_TYPE_ID", request.Action?.TypeId is not null ? (byte)request.Action.TypeId : null, SqlDbType.TinyInt)
+            .Add("pACTION_PRE_SQL", request.Action?.PreSql)
+            .Add("pACTION_HEADER_SQL", request.Action?.HeaderSql)
+            .Add("pACTION_BODY_SQL", request.Action?.BodySql)
+            .Add("pACTION_POST_SQL", request.Action?.PostSql)
+            .Add("pACTION_ERROR_ACTION_ID", request.Action?.ErrorActionId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_ACTIVE", request.Endpoint?.Active)
+            .Add("pENDPOINT_DESCRIPTION", request.Endpoint?.Description)
+            .Add("pENDPOINT_URI", request.Endpoint?.Uri)
+            .Add("pENDPOINT_AUTH_ACTIVE", request.EndpointAuth?.Active)
+            .Add("pENDPOINT_AUTH_DESCRIPTION", request.EndpointAuth?.Description)
+            .Add("pENDPOINT_AUTH_TYPE_ID", request.EndpointAuth?.TypeId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_AUTH_API_KEY", request.EndpointAuth?.ApiKey)
+            .Add("pENDPOINT_AUTH_API_VALUE", request.EndpointAuth?.ApiValue)
+            .Add("pENDPOINT_AUTH_API_KEY_ADD_TO_ID", request.EndpointAuth?.ApiKeyAddToId)
+            .Add("pENDPOINT_AUTH_TOKEN", request.EndpointAuth?.Token)
+            .Add("pENDPOINT_AUTH_USERNAME", request.EndpointAuth?.Username)
+            .Add("pENDPOINT_AUTH_PASSWORD", request.EndpointAuth?.Password)
+            .Add("pENDPOINT_AUTH_DOMAIN", request.EndpointAuth?.Domain)
+            .Add("pENDPOINT_AUTH_WORKSTATION", request.EndpointAuth?.Workstation)
+            .Add("pPROFILE_ACTIVE", request.Profile?.Active)
+            .Add("pPROFILE_TYPE_ID", request.Profile?.TypeId, SqlDbType.TinyInt)
+            .Add("pPROFILE_MANDANTOR", request.Profile?.Mandantor)
+            .Add("pPROFILE_NAME", request.Profile?.Name)
+            .Add("pPROFILE_DESCRIPTION", request.Profile?.Description)
+            .Add("pPROFILE_LOG_LEVEL_ID", request.Profile?.LogLevelId, SqlDbType.TinyInt)
+            .Add("pPROFILE_LANGUAGE_ID", request.Profile?.LanguageId, SqlDbType.SmallInt)
+            .Add("pRESULT_ACTION_ID", request.Result?.ActionId)
+            .Add("pRESULT_STATUS_ID", request.Result?.Status, SqlDbType.TinyInt)
+            .Add("pRESULT_TYPE_ID", request.Result?.Type is not null ? (byte)request.Result.Type : null, SqlDbType.TinyInt)
+            .Add("pRESULT_HEADER", request.Result?.Header)
+            .Add("pRESULT_BODY", request.Result?.Body)
+            .Add("pRESULT_INFO_ID", request.Result?.Info, SqlDbType.SmallInt)
+            .Add("pRESULT_INFO_DETAIL", request.Result?.InfoDetail)
+            .Add("pRESULT_ERROR", request.Result?.Error)
+            .Add("pRESULT_BATCH_ID", request.Result?.References?.BatchId)
+            .Add("pRESULT_REFERENCE1", request.Result?.References?.Reference1)
+            .Add("pRESULT_REFERENCE2", request.Result?.References?.Reference2)
+            .Add("pRESULT_REFERENCE3", request.Result?.References?.Reference3)
+            .Add("pRESULT_REFERENCE4", request.Result?.References?.Reference4)
+            .Add("pRESULT_REFERENCE5", request.Result?.References?.Reference5)
+            .Add("pENDPOINT_PARAMS_ACTIVE", request.EndpointParams?.Active)
+            .Add("pENDPOINT_PARAMS_DESCRIPTION", request.EndpointParams?.Description)
+            .Add("pENDPOINT_PARAMS_GROUP_ID", request.EndpointParams?.GroupId, SqlDbType.SmallInt)
+            .Add("pENDPOINT_PARAMS_SEQUENCE", request.EndpointParams?.Sequence, SqlDbType.TinyInt)
+            .Add("pENDPOINT_PARAMS_KEY", request.EndpointParams?.Key)
+            .Add("pENDPOINT_PARAMS_VALUE", request.EndpointParams?.Value)
+            .AddOutput("oGUID", SqlDbType.BigInt);
+
+        try
+        {
+            await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
+        }
+        catch (SqlException ex)
+        {
+            if (sqlExOpt.CurrentValue.BadRequestSqlExceptionNumbers.Contains(ex.Number))
+                throw new BadRequestException(ex.Message, ex);
+            else
+                throw;
+        }
+
+        var guidParam = sp.GetParameter("oGUID");
+
+        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/StoredProcedureBuilder.cs

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

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

@@ -0,0 +1,18 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+public record UpdateActionDto
+{
+    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; }
+}

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

@@ -0,0 +1,16 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+public record UpdateEndpointAuthDto
+{
+    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; }
+}

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

@@ -0,0 +1,8 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+public record UpdateEndpointDto
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public string? Uri { get; set; }
+}

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

@@ -0,0 +1,11 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+public record UpdateEndpointParamsDto
+{
+    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; }
+}

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

@@ -0,0 +1,15 @@
+namespace ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+
+public record UpdateProfileDto
+{
+    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; }
+}

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

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

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

@@ -0,0 +1,10 @@
+using MediatR;
+
+namespace ReC.Application.Common.Procedures.UpdateProcedure;
+
+public interface IUpdateProcedure<T> : IRequest<int>
+{
+    public long Id { get; set; }
+
+    public T Data { get; set; }
+}

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

@@ -0,0 +1,121 @@
+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.Common.Procedures.UpdateProcedure.Dto;
+using System.Data;
+
+namespace ReC.Application.Common.Procedures.UpdateProcedure;
+
+public record UpdateObjectProcedure : IRequest<int>
+{
+    /// <summary>
+    /// Target entity for the update operation.
+    /// </summary>
+    public required EntityType Entity { get; set; }
+
+    /// <summary>
+    /// Target GUID to update (required)
+    /// </summary>
+    public long Id { get; set; }
+
+    //TODO: update to set in authentication middleware or similar, and remove from procedure properties
+    internal string? ChangedWho { get; private set; } = "ReC.API";
+
+    public UpdateActionDto Action { get; set; } = new();
+    public UpdateEndpointDto Endpoint { get; set; } = new();
+    public UpdateEndpointAuthDto EndpointAuth { get; set; } = new();
+    public UpdateProfileDto Profile { get; set; } = new();
+    public UpdateResultDto Result { get; set; } = new();
+    public UpdateEndpointParamsDto EndpointParams { get; set; } = new();
+}
+
+public class UpdateObjectProcedureHandler(IRepository repo, IOptionsMonitor<SqlExceptionOptions> sqlExOpt) : IRequestHandler<UpdateObjectProcedure, int>
+{
+    public async Task<int> Handle(UpdateObjectProcedure request, CancellationToken cancel)
+    {
+        var sp = new StoredProcedureBuilder("[dbo].[PRREC_UPDATE_OBJECT]", "RC")
+            .Add("pENTITY", request.Entity)
+            .Add("pGUID", request.Id)
+            .Add("pCHANGED_WHO", request.ChangedWho)
+            .Add("pCHANGED_WHEN", DateTime.UtcNow)
+            .Add("pACTION_PROFILE_ID", request.Action.ProfileId)
+            .Add("pACTION_ACTIVE", request.Action.Active)
+            .Add("pACTION_SEQUENCE", request.Action.Sequence, SqlDbType.TinyInt)
+            .Add("pACTION_ENDPOINT_ID", request.Action.EndpointId)
+            .Add("pACTION_ENDPOINT_AUTH_ID", request.Action.EndpointAuthId)
+            .Add("pACTION_ENDPOINT_PARAMS_ID", request.Action.EndpointParamsId, SqlDbType.SmallInt)
+            .Add("pACTION_SQL_CONNECTION_ID", request.Action.SqlConnectionId, SqlDbType.SmallInt)
+            .Add("pACTION_TYPE_ID", request.Action.TypeId, SqlDbType.TinyInt)
+            .Add("pACTION_PRE_SQL", request.Action.PreSql)
+            .Add("pACTION_HEADER_SQL", request.Action.HeaderSql)
+            .Add("pACTION_BODY_SQL", request.Action.BodySql)
+            .Add("pACTION_POST_SQL", request.Action.PostSql)
+            .Add("pACTION_ERROR_ACTION_ID", request.Action.ErrorActionId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_ACTIVE", request.Endpoint.Active)
+            .Add("pENDPOINT_DESCRIPTION", request.Endpoint.Description)
+            .Add("pENDPOINT_URI", request.Endpoint.Uri)
+            .Add("pENDPOINT_AUTH_ACTIVE", request.EndpointAuth.Active)
+            .Add("pENDPOINT_AUTH_DESCRIPTION", request.EndpointAuth.Description)
+            .Add("pENDPOINT_AUTH_TYPE_ID", request.EndpointAuth.TypeId, SqlDbType.TinyInt)
+            .Add("pENDPOINT_AUTH_API_KEY", request.EndpointAuth.ApiKey)
+            .Add("pENDPOINT_AUTH_API_VALUE", request.EndpointAuth.ApiValue)
+            .Add("pENDPOINT_AUTH_API_KEY_ADD_TO_ID", request.EndpointAuth.ApiKeyAddToId)
+            .Add("pENDPOINT_AUTH_TOKEN", request.EndpointAuth.Token)
+            .Add("pENDPOINT_AUTH_USERNAME", request.EndpointAuth.Username)
+            .Add("pENDPOINT_AUTH_PASSWORD", request.EndpointAuth.Password)
+            .Add("pENDPOINT_AUTH_DOMAIN", request.EndpointAuth.Domain)
+            .Add("pENDPOINT_AUTH_WORKSTATION", request.EndpointAuth.Workstation)
+            .Add("pENDPOINT_PARAMS_ACTIVE", request.EndpointParams.Active)
+            .Add("pENDPOINT_PARAMS_DESCRIPTION", request.EndpointParams.Description)
+            .Add("pENDPOINT_PARAMS_GROUP_ID", request.EndpointParams.GroupId, SqlDbType.SmallInt)
+            .Add("pENDPOINT_PARAMS_SEQUENCE", request.EndpointParams.Sequence, SqlDbType.TinyInt)
+            .Add("pENDPOINT_PARAMS_KEY", request.EndpointParams.Key)
+            .Add("pENDPOINT_PARAMS_VALUE", request.EndpointParams.Value)
+            .Add("pPROFILE_ACTIVE", request.Profile.Active)
+            .Add("pPROFILE_TYPE_ID", request.Profile.TypeId, SqlDbType.TinyInt)
+            .Add("pPROFILE_MANDANTOR", request.Profile.Mandantor)
+            .Add("pPROFILE_NAME", request.Profile.Name)
+            .Add("pPROFILE_DESCRIPTION", request.Profile.Description)
+            .Add("pPROFILE_LOG_LEVEL_ID", request.Profile.LogLevelId, SqlDbType.TinyInt)
+            .Add("pPROFILE_LANGUAGE_ID", request.Profile.LanguageId, SqlDbType.SmallInt)
+            .Add("pPROFILE_FIRST_RUN", request.Profile.FirstRun)
+            .Add("pPROFILE_LAST_RUN", request.Profile.LastRun)
+            .Add("pPROFILE_LAST_RESULT", request.Profile.LastResult)
+            .Add("pRESULT_ACTION_ID", request.Result.ActionId)
+            .Add("pRESULT_STATUS_ID", request.Result.StatusId, SqlDbType.TinyInt)
+            .Add("pRESULT_HEADER", request.Result.Header)
+            .Add("pRESULT_BODY", request.Result.Body)
+            .Add("pRESULT_INFO_ID", request.Result.Info, SqlDbType.SmallInt)
+            .Add("pRESULT_INFO_DETAIL", request.Result.InfoDetail)
+            .Add("pRESULT_ERROR", request.Result.Error)
+            .Add("pRESULT_BATCH_ID", request.Result.References?.BatchId)
+            .Add("pRESULT_REFERENCE1", request.Result.References?.Reference1)
+            .Add("pRESULT_REFERENCE2", request.Result.References?.Reference2)
+            .Add("pRESULT_REFERENCE3", request.Result.References?.Reference3)
+            .Add("pRESULT_REFERENCE4", request.Result.References?.Reference4)
+            .Add("pRESULT_REFERENCE5", request.Result.References?.Reference5);
+
+        try
+        {
+            var result = await repo.ExecuteQueryRawAsync(sp.BuildSql(), sp.BuildParameters(), cancel);
+
+            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/DeleteObjectProcedureValidator.cs

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

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

@@ -0,0 +1,81 @@
+using FluentValidation;
+using ReC.Application.Common.Procedures.InsertProcedure;
+
+namespace ReC.Application.Common.Validations;
+
+public class InsertObjectProcedureValidator : AbstractValidator<InsertObjectProcedure>
+{
+    public InsertObjectProcedureValidator()
+    {
+        RuleFor(x => x.Entity)
+            .IsInEnum()
+            .WithMessage("ENTITY must be a valid EntityType value.");
+
+        // ACTION validation
+        When(x => x.Action != null, () =>
+        {
+            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.Endpoint != null, () =>
+        {
+            RuleFor(x => x.Endpoint!.Uri)
+                .NotEmpty()
+                .WithMessage("ENDPOINT requires EndpointUri (maps to @pENDPOINT_URI).")
+                .MaximumLength(2000);
+        });
+
+        // PROFILE validation
+        When(x => x.Profile != null, () =>
+        {
+            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.Result != null, () =>
+        {
+            RuleFor(x => x.Result!.ActionId)
+                .NotNull()
+                .WithMessage("RESULT requires ResultActionId (maps to @pRESULT_ACTION_ID).");
+        });
+
+        // ENDPOINT_PARAMS validation
+        When(x => x.EndpointParams != null, () =>
+        {
+            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 is { Description: not null });
+
+        RuleFor(x => x.EndpointAuth!.Description)
+            .MaximumLength(250)
+            .When(x => x.EndpointAuth is { Description: not null });
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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

src/ReC.Application/DependencyInjection.cs

@@ -3,8 +3,11 @@ using MediatR;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using ReC.Application.Common.Behaviors;
+using ReC.Application.Common.Behaviors.Action;
+using ReC.Application.Common.Behaviors.InvokeAction;
 using ReC.Application.Common.Constants;
 using ReC.Application.Common.Options;
+using ReC.Application.RecActions.Commands;
 using System.Reflection;
 
 namespace ReC.Application;
@@ -33,6 +36,8 @@ public static class DependencyInjection
             cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly());
             cfg.AddOpenBehaviors([typeof(BodyQueryBehavior<,>), typeof(HeaderQueryBehavior<,>)]);
             cfg.AddBehavior(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
+            cfg.AddBehavior(typeof(IPipelineBehavior<InvokeRecActionViewCommand, Unit>), typeof(PostprocessingBehavior));
+            cfg.AddBehavior(typeof(IPipelineBehavior<InvokeRecActionViewCommand, Unit>), typeof(PreprocessingBehavior));
             cfg.LicenseKey = configOpt.LuckyPennySoftwareLicenseKey;
         });
 
@@ -116,5 +121,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/DeleteEndpointAuthCommand.cs

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record DeleteEndpointAuthCommand : 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 class DeleteEndpointAuthProcedureHandler(ISender sender) : IRequestHandler<DeleteEndpointAuthCommand, int>
+{
+    public async Task<int> Handle(DeleteEndpointAuthCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new DeleteObjectProcedure
+        {
+            Entity = EntityType.EndpointAuth,
+            Start = request.Start,
+            End = request.End,
+            Force = request.Force
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,32 @@
+using MediatR;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record InsertEndpointAuthCommand : 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 class InsertEndpointAuthProcedureHandler(ISender sender) : IRequestHandler<InsertEndpointAuthCommand, long>
+{
+    public async Task<long> Handle(InsertEndpointAuthCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new InsertObjectProcedure
+        {
+            Entity = EntityType.EndpointAuth,
+            EndpointAuth = request
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,26 @@
+using MediatR;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointAuth.Commands;
+
+public record UpdateEndpointAuthCommand : IUpdateProcedure<UpdateEndpointAuthDto>
+{
+    public long Id { get; set; }
+
+    public UpdateEndpointAuthDto Data { get; set; } = null!;
+}
+
+public class UpdateEndpointAuthProcedureHandler(ISender sender) : IRequestHandler<UpdateEndpointAuthCommand, int>
+{
+    public async Task<int> Handle(UpdateEndpointAuthCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new UpdateObjectProcedure
+        {
+            Entity = EntityType.EndpointAuth,
+            Id = request.Id,
+            EndpointAuth = request.Data
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record DeleteEndpointParamsCommand : 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 class DeleteEndpointParamsProcedureHandler(ISender sender) : IRequestHandler<DeleteEndpointParamsCommand, int>
+{
+    public async Task<int> Handle(DeleteEndpointParamsCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new DeleteObjectProcedure
+        {
+            Entity = EntityType.EndpointParams,
+            Start = request.Start,
+            End = request.End,
+            Force = request.Force
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,27 @@
+using MediatR;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record InsertEndpointParamsCommand : 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 class InsertEndpointParamsProcedureHandler(ISender sender) : IRequestHandler<InsertEndpointParamsCommand, long>
+{
+    public async Task<long> Handle(InsertEndpointParamsCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new InsertObjectProcedure
+        {
+            Entity = EntityType.EndpointParams,
+            EndpointParams = request
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,26 @@
+using MediatR;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.EndpointParams.Commands;
+
+public record UpdateEndpointParamsCommand : IUpdateProcedure<UpdateEndpointParamsDto>
+{
+    public long Id { get; set; }
+
+    public UpdateEndpointParamsDto Data { get; set; } = null!;
+}
+
+public class UpdateEndpointParamsProcedureHandler(ISender sender) : IRequestHandler<UpdateEndpointParamsCommand, int>
+{
+    public async Task<int> Handle(UpdateEndpointParamsCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new UpdateObjectProcedure
+        {
+            Entity = EntityType.EndpointParams,
+            Id = request.Id,
+            EndpointParams = request.Data
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record DeleteEndpointCommand : 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 class DeleteEndpointProcedureHandler(ISender sender) : IRequestHandler<DeleteEndpointCommand, int>
+{
+    public async Task<int> Handle(DeleteEndpointCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new DeleteObjectProcedure
+        {
+            Entity = EntityType.Endpoint,
+            Start = request.Start,
+            End = request.End,
+            Force = request.Force
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,24 @@
+using MediatR;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record InsertEndpointCommand : IInsertProcedure
+{
+    public bool? Active { get; set; }
+    public string? Description { get; set; }
+    public string? Uri { get; set; }
+}
+
+public class InsertEndpointProcedureHandler(ISender sender) : IRequestHandler<InsertEndpointCommand, long>
+{
+    public async Task<long> Handle(InsertEndpointCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new InsertObjectProcedure
+        {
+            Entity = EntityType.Endpoint,
+            Endpoint = request
+        }, cancel);
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+using MediatR;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Endpoints.Commands;
+
+public record UpdateEndpointCommand : IUpdateProcedure<UpdateEndpointDto>
+{
+    public long Id { get; set; }
+
+    public UpdateEndpointDto Data { get; set; } = null!;
+}
+
+public class UpdateEndpointProcedureHandler(ISender sender) : IRequestHandler<UpdateEndpointCommand, int>
+{
+    public async Task<int> Handle(UpdateEndpointCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new UpdateObjectProcedure
+        {
+            Entity = EntityType.Endpoint,
+            Id = request.Id,
+            Endpoint = request.Data
+        }, cancel);
+    }
+}

src/ReC.Application/Endpoints/MappingProfile.cs

@@ -1,16 +0,0 @@
-using ReC.Application.Endpoints.Commands;
-using ReC.Application.Common.Dto;
-
-namespace ReC.Application.Endpoints;
-
-// TODO: update to inject AddedWho from the current host/user contex
-public class MappingProfile : AutoMapper.Profile
-{
-    public MappingProfile()
-    {
-        CreateMap<ObtainEndpointCommand, EndpointDto>()
-            .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,28 +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 short? Status { get; set; }
-
-    public string? Message { 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/Commands/DeleteOutResCommand.cs

@@ -1,46 +0,0 @@
-using DigitalData.Core.Abstraction.Application.Repository;
-using MediatR;
-using ReC.Domain.Entities;
-
-namespace ReC.Application.OutResults.Commands;
-
-/// <summary>
-/// Represents the command to delete output results based on specified criteria.
-/// </summary>
-/// <remarks>
-/// Deletion can be performed by providing either an <see cref="ActionId"/> or a <see cref="ProfileId"/>.
-/// At least one of these properties must be set for the operation to proceed.
-/// </remarks>
-public record DeleteOutResCommand : IRequest
-{
-    /// <summary>
-    /// Gets the unique identifier for the action whose output results should be deleted.
-    /// </summary>
-    public long? ActionId { get; init; }
-
-    /// <summary>
-    /// Gets the unique identifier for the profile whose associated action's output results should be deleted.
-    /// </summary>
-    public long? ProfileId { get; init; }
-}
-
-/// <summary>
-/// Handles the execution of the <see cref="DeleteOutResCommand"/>.
-/// </summary>
-public class DeleteOutResCommandHandler(IRepository<OutRes> repo) : IRequestHandler<DeleteOutResCommand>
-{
-    /// <summary>
-    /// Processes the delete command by removing matching <see cref="OutRes"/> entities from the repository.
-    /// </summary>
-    /// <param name="request">The command containing the deletion criteria.</param>
-    /// <param name="cancel">A cancellation token that can be used to cancel the work.</param>
-    /// <returns>A task that represents the asynchronous delete operation.</returns>
-    /// <remarks>
-    /// The handler deletes records where <c>OutRes.ActionId</c> matches <see cref="DeleteOutResCommand.ActionId"/>
-    /// or where the associated <c>Action.ProfileId</c> matches <see cref="DeleteOutResCommand.ProfileId"/>.
-    /// </remarks>
-    public Task Handle(DeleteOutResCommand request, CancellationToken cancel)
-    {
-        return repo.DeleteAsync(x => x.ActionId == request.ActionId || x.Action!.ProfileId == request.ProfileId, cancel);
-    }
-}

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

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

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

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

@@ -1,14 +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.")
-            .WithName("Identifier");
-    }
-}

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

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Profile.Commands;
+
+public record DeleteProfileCommand : 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 class DeleteProfileProcedureHandler(ISender sender) : IRequestHandler<DeleteProfileCommand, int>
+{
+    public async Task<int> Handle(DeleteProfileCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new DeleteObjectProcedure
+        {
+            Entity = EntityType.Profile,
+            Start = request.Start,
+            End = request.End,
+            Force = request.Force
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,28 @@
+using MediatR;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Profile.Commands;
+
+public record InsertProfileCommand : 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 class InsertProfileProcedureHandler(ISender sender) : IRequestHandler<InsertProfileCommand, long>
+{
+    public async Task<long> Handle(InsertProfileCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new InsertObjectProcedure
+        {
+            Entity = EntityType.Profile,
+            Profile = request
+        }, cancel);
+    }
+}

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

@@ -0,0 +1,26 @@
+using MediatR;
+using ReC.Application.Common.Procedures.UpdateProcedure;
+using ReC.Application.Common.Procedures.UpdateProcedure.Dto;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.Profile.Commands;
+
+public record UpdateProfileCommand : IUpdateProcedure<UpdateProfileDto>
+{
+    public long Id { get; set; }
+
+    public UpdateProfileDto Data { get; set; } = null!;
+}
+
+public class UpdateProfileProcedureHandler(ISender sender) : IRequestHandler<UpdateProfileCommand, int>
+{
+    public async Task<int> Handle(UpdateProfileCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new UpdateObjectProcedure
+        {
+            Entity = EntityType.Profile,
+            Id = request.Id,
+            Profile = request.Data
+        }, cancel);
+    }
+}

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

@@ -7,10 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="AutoMapper" Version="15.1.0" />
-    <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.5.0" />
+    <PackageReference Include="AutoMapper" Version="16.1.1" />
+    <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.6.0" />
     <PackageReference Include="DigitalData.Core.Application" Version="3.4.0" />
-    <PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.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/RecActionViews/Commands/InvokeBatchRecActionViewsCommand.cs

@@ -1,37 +0,0 @@
-using MediatR;
-using ReC.Application.RecActionViews.Queries;
-using ReC.Domain.Constants;
-
-namespace ReC.Application.RecActionViews.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/RecActionViews/Commands/InvokeRecActionViewCommand.cs

@@ -1,147 +0,0 @@
-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.OutResults.Commands;
-using ReC.Domain.Constants;
-using System.Net;
-using System.Net.Http.Headers;
-using System.Text;
-using System.Text.Json;
-
-namespace ReC.Application.RecActionViews.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.Send(new CreateOutResCommand
-        {
-            Status = statusCode,
-            ActionId = action.Id,
-            Header = JsonSerializer.Serialize(resHeaders, options: new() { WriteIndented = false }),
-            Body = resBody,
-            AddedWho = config?["AddedWho"]
-        }, cancel);
-
-        return response.IsSuccessStatusCode;
-    }
-}

src/ReC.Application/RecActionViews/MappingProfile.cs

@@ -1,16 +0,0 @@
-using ReC.Application.Common.Dto;
-using ReC.Application.RecActions.Commands;
-
-namespace ReC.Application.RecActionViews;
-
-// TODO: update to inject AddedWho from the current host/user contex
-public class MappingProfile : AutoMapper.Profile
-{
-    public MappingProfile()
-    {
-        CreateMap<CreateRecActionCommand, RecActionDto>()
-            .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/Commands/CreateRecActionCommand.cs

@@ -1,45 +0,0 @@
-using DigitalData.Core.Abstraction.Application.Repository;
-using DigitalData.Core.Exceptions;
-using MediatR;
-using ReC.Domain.Entities;
-using ReC.Application.Endpoints.Commands;
-
-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/DeleteActionCommand.cs

@@ -0,0 +1,37 @@
+using MediatR;
+using ReC.Application.Common.Procedures.DeleteProcedure;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record DeleteActionCommand : 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 class DeleteActionProcedureHandler(ISender sender) : IRequestHandler<DeleteActionCommand, int>
+{
+    public async Task<int> Handle(DeleteActionCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new DeleteObjectProcedure
+        {
+            Entity = EntityType.Action,
+            Start = request.Start,
+            End = request.End,
+            Force = request.Force
+        }, cancel);
+    }
+}

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 required long ProfileId { get; init; }
-}
-
-public class DeleteRecActionsCommandHandler(IRepository<RecAction> repo) : IRequestHandler<DeleteRecActionsCommand>
-{
-    public async Task Handle(DeleteRecActionsCommand request, CancellationToken cancel)
-    {
-        // TODO: update DeleteAsync (in Core) to return number of deleted records
-        if (!await repo.Where(act => act.ProfileId == request.ProfileId).AnyAsync(cancel))
-            throw new NotFoundException();
-
-        await repo.DeleteAsync(act => act.ProfileId == request.ProfileId, cancel);
-    }
-}

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

@@ -0,0 +1,35 @@
+using MediatR;
+using ReC.Application.Common.Procedures.InsertProcedure;
+using ReC.Domain.Constants;
+using ReC.Application.Common.Procedures;
+
+namespace ReC.Application.RecActions.Commands;
+
+public record InsertActionCommand : 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 class InsertActionProcedureHandler(ISender sender) : IRequestHandler<InsertActionCommand, long>
+{
+    public async Task<long> Handle(InsertActionCommand request, CancellationToken cancel)
+    {
+        return await sender.Send(new InsertObjectProcedure
+        {
+            Entity = EntityType.Action,
+            Action = request
+        }, cancel);
+    }
+}