Add logging to handle null RestType in RecActionCommand

Enhanced the `InvokeRecActionCommandHandler` class by adding
logging functionality using `ILogger`. Updated the constructor
to accept an optional logger parameter. Introduced a check for
`RestType` being `null` and added a warning log to handle such
cases gracefully. This prevents processing invalid actions and
improves system robustness.

src/ReC.Application/DependencyInjection.cs

@@ -22,6 +22,8 @@ public static class DependencyInjection
             cfg.LicenseKey = configOpt.LuckyPennySoftwareLicenseKey;
         });
 
+        services.AddHttpClient();
+
         return services;
     }
 

src/ReC.Application/ReC.Application.csproj

@@ -8,7 +8,12 @@
 
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="15.1.0" />
+    <PackageReference Include="DigitalData.Core.Abstraction.Application" Version="1.5.0" />
+    <PackageReference Include="DigitalData.Core.Application" Version="3.4.0" />
+    <PackageReference Include="DigitalData.Core.Exceptions" Version="1.1.0" />
     <PackageReference Include="MediatR" Version="13.1.0" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.11" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
   </ItemGroup>
 
   <ItemGroup>

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

@@ -1,14 +1,57 @@
 using MediatR;
+using Microsoft.Extensions.Logging;
+using ReC.Application.RecActions.Queries;
 
 namespace ReC.Application.RecActions.Commands;
 
-public class InvokeRecActionCommand : IRequest
+public class InvokeRecActionCommand : ReadRecActionQuery, IRequest
 {
-    public int ProfileId { get; init; }
 }
 
 public static class InvokeRecActionCommandExtensions
 {
     public static Task InvokeRecAction(this ISender sender, int profileId)
         => sender.Send(new InvokeRecActionCommand { ProfileId = profileId });
+}
+
+public class InvokeRecActionCommandHandler(ISender sender, IHttpClientFactory clientFactory, ILogger<InvokeRecActionCommandHandler>? logger = null) : IRequestHandler<InvokeRecActionCommand>
+{
+    public async Task Handle(InvokeRecActionCommand request, CancellationToken cancel)
+    {
+        var actions = await sender.Send(request as ReadRecActionQuery, cancel);
+
+        var http = clientFactory.CreateClient();
+
+        using var semaphore = new SemaphoreSlim(5);
+
+        var tasks = actions.Select(async action =>
+        {
+            await semaphore.WaitAsync(cancel);
+            try
+            {
+                if (action.RestType is null)
+                {
+                    logger?.LogWarning(
+                       "Rec action could not be invoked because the RestType value is null. ProfileId: {ProfileId}, ActionId: {ActionId}",
+                       action.ProfileId,
+                       action.ActionId
+                   );
+                    return;
+                }
+
+                var method = new HttpMethod(action.RestType.ToUpper());
+                var msg = new HttpRequestMessage(method, action.EndpointUri);
+
+                var response = await http.SendAsync(msg, cancel);
+                var body = await response.Content.ReadAsStringAsync(cancel);
+                var headers = response.Headers.ToDictionary();
+            }
+            finally
+            {
+                semaphore.Release();
+            }
+        });
+
+        await Task.WhenAll(tasks);
+    }
 }

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

@@ -1,9 +1,27 @@
 using MediatR;
 using ReC.Application.Dto;
+using DigitalData.Core.Abstraction.Application.Repository;
+using ReC.Domain.Entities;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using DigitalData.Core.Exceptions;
 
 namespace ReC.Application.RecActions.Queries;
 
 public class ReadRecActionQuery : IRequest<IEnumerable<RecActionDto>>
 {
     public int ProfileId { get; init; }
+}
+
+public class ReadRecActionQueryHandler(IRepository<RecAction> repo, IMapper mapper) : IRequestHandler<ReadRecActionQuery, IEnumerable<RecActionDto>>
+{
+    public async Task<IEnumerable<RecActionDto>> Handle(ReadRecActionQuery request, CancellationToken cancel)
+    {
+        var actions = await repo.Where(x => x.ProfileId == request.ProfileId).ToListAsync(cancel);
+
+        if(actions.Count != 0)
+            throw new NotFoundException($"No actions found for the profile {request.ProfileId}.");
+
+        return mapper.Map<IEnumerable<RecActionDto>>(actions);
+    }
 }