Surfaced programme rules

PostFundManagement.Application/Services/Execution/ExecutionService.cs

@@ -1,6 +1,7 @@
 using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
+using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
@@ -8,7 +9,8 @@ using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Execution;
 
-public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IExecutionService
+public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
+    ITenantContextService tenantContext) : IExecutionService
 {
     public async Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
@@ -21,7 +23,7 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .Take(pagination.PageSize)
                 .ToListAsync(cancellationToken);
 
-            return Result.Ok(risks.Select(i => i.Map()).ToArray());
+            return Result.Ok(risks?.Select(i => i.Map()).ToArray() ?? []);
         }));
 
     public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
@@ -35,9 +37,9 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 .Take(pagination.PageSize)
                 .ToArrayAsync(cancellationToken);
 
-            return Result.Ok(disbursements.Select(i => i.Map()).ToArray());
+            return Result.Ok(disbursements?.Select(i => i.Map()).ToArray() ?? []);
         }));
-    
+
     public async Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result>>)(async () =>
         {
@@ -93,8 +95,8 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
             var changedTotal = await context.Disbursements.Where(d => d.Id == decodeResult.Value)
-                .ExecuteUpdateAsync(f =>
-                    f.SetProperty(f => f.Status, ApprovalStatus.Approved)
+                .ExecuteUpdateAsync(f => f
+                    .SetProperty(f => f.Status, ApprovalStatus.Approved)
                     .SetProperty(f => f.UpdatedBy, userId)
                     .SetProperty(f => f.UpdatedAt, DateTime.UtcNow), cancellationToken);
 
@@ -168,4 +170,82 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
 
             return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
+
+    public async Task<Result> CreateRuleAsync(CreateRuleRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Programmes.AnyAsync(p => p.Id == request.ProgrammeId, cancellationToken))
+                return Result.Fail(ValidationError.Create("Programme does not exist"));
+
+            var requestedName = request.Name.Humanize(LetterCasing.Title).Trim();
+
+            if (await context.Rules.AnyAsync(r => r.Name == requestedName && r.ProgrammeId == request.ProgrammeId, cancellationToken))
+                return Result.Fail(ValidationError.Create("A rule with the same name exists"));
+
+            context.Rules.Add(new Domain.Entities.Rule
+            {
+                CreatedAt = DateTime.UtcNow,
+                CreatedBy = userId,
+                Description = request.Description,
+                Name = requestedName,
+                ProgrammeId = request.ProgrammeId,
+                Status = ActivityStatus.Active,
+                Version = 1,
+                TenantId = tenantContext.TenantId
+            });
+
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create rule"));
+        }));
+
+    public async Task<Result> UpdateRuleAsync(UpdateRuleRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result>>)(async () =>
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var requestedName = request.Name.Humanize(LetterCasing.Title).Trim();
+
+            var changedTotal = await context.Rules
+                .Where(f => f.Id == request.RuleId)
+                .ExecuteUpdateAsync(f => f
+                    .SetProperty(u => u.Status, request.Status)
+                    .SetProperty(u => u.UpdatedAt, DateTime.UtcNow)
+                    .SetProperty(u => u.Name, requestedName)
+                    .SetProperty(u => u.Version, request.Version + 1)
+                    .SetProperty(u => u.Description, request.Description), cancellationToken);
+
+            return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update rule"));
+        }));
+
+    public async Task<Result<Rule>> GetRuleAsync(string ruleIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Rule>>>)(async () =>
+        {
+            var decodeResult = hashService.DecodeLongIdHash(ruleIdHash);
+
+            if (decodeResult.IsFailed)
+                return Result.Fail<Rule>(IdDecodeError.Create()
+                    .CausedBy(decodeResult.Errors));
+
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var rule = await context.Rules.AsNoTracking().FirstOrDefaultAsync(r => r.Id == decodeResult.Value, cancellationToken);
+
+            return Result.FailIf(rule is null, NotFoundError.New)
+                .ToResult(rule!.Map());
+        }));
+
+    public async Task<Result<Rule[]>> GetRulesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Rule[]>>>)(async () =>
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var rules = await context.Rules.AsNoTracking()
+                .OrderByDescending(d => d.Id)
+                .Skip((pagination.Page - 1) * pagination.PageSize)
+                .Take(pagination.PageSize)
+                .ToArrayAsync(cancellationToken);
+
+            return Result.Ok(rules?.Select(i => i.Map()).ToArray() ?? []);
+        }));
 }