262 lines
13 KiB
C#
262 lines
13 KiB
C#
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;
|
|
using PostFundManagement.Infrastructure.Database;
|
|
|
|
namespace PostFundManagement.Application.Services.Execution;
|
|
|
|
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 () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var risks = await context.Risks.AsNoTracking()
|
|
.OrderByDescending(r => r.CreatedAt)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(risks?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Disbursement[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var disbursements = await context.Disbursements.AsNoTracking()
|
|
.OrderByDescending(d => d.CreatedAt)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToArrayAsync(cancellationToken);
|
|
|
|
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 () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Projects.AnyAsync(p => p.Id == request.ProjectId, cancellationToken))
|
|
return Result.Fail(NotFoundError.New);
|
|
|
|
context.Risks.Add(new Domain.Entities.Risk
|
|
{
|
|
ProjectId = request.ProjectId,
|
|
Likelihood = request.Likelihood,
|
|
Impact = request.Impact,
|
|
Name = request.Name,
|
|
Description = request.Description,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create risk."));
|
|
}));
|
|
|
|
public async Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Projects.AnyAsync(p => p.Id == request.ProjectId, cancellationToken))
|
|
return Result.Fail(NotFoundError.New);
|
|
|
|
context.Disbursements.Add(new Domain.Entities.Disbursement
|
|
{
|
|
ProjectId = request.ProjectId,
|
|
MilestoneId = request.MilestoneId,
|
|
Amount = request.Amount,
|
|
Status = ApprovalStatus.Pending,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create disbursement."));
|
|
}));
|
|
|
|
public async Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var disbursement = await context.Disbursements.AsNoTracking()
|
|
.FirstOrDefaultAsync(d => d.Id == decodeResult.Value, cancellationToken);
|
|
if (disbursement is null)
|
|
return Result.Fail(NotFoundError.Create("Disbursement not found."));
|
|
|
|
var isAwardApproved = await context.Awards
|
|
.AnyAsync(a => a.ProjectId == disbursement.ProjectId && a.Status == ApprovalStatus.Approved, cancellationToken);
|
|
if (!isAwardApproved)
|
|
return Result.Fail(ValidationError.Create("Cannot approve disbursement: The project's linked award is not approved or does not exist."));
|
|
|
|
var changedTotal = await context.Disbursements.Where(d => d.Id == decodeResult.Value)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(f => f.Status, ApprovalStatus.Approved)
|
|
.SetProperty(f => f.UpdatedBy, userId)
|
|
.SetProperty(f => f.UpdatedAt, DateTime.UtcNow), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to approve disbursement."));
|
|
}));
|
|
|
|
public async Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
|
|
await Result.Try((Func<Task<Result<Disbursement>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(disbursementIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Disbursement>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var disbursement = await context.Disbursements.AsNoTracking()
|
|
.FirstOrDefaultAsync(d => d.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(disbursement is null, NotFoundError.Create("Disbursement not found."))
|
|
.ToResult(disbursement?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Risk>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(riskIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Risk>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var risk = await context.Risks.AsNoTracking()
|
|
.FirstOrDefaultAsync(r => r.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(risk is null, NotFoundError.Create("Risk not found."))
|
|
.ToResult(risk?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var changedTotal = await context.Risks
|
|
.Where(r => r.Id == request.RiskId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name)
|
|
.SetProperty(u => u.Description, request.Description)
|
|
.SetProperty(u => u.Likelihood, request.Likelihood)
|
|
.SetProperty(u => u.Impact, request.Impact), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update risk."));
|
|
}));
|
|
|
|
public async Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var changedTotal = await context.Disbursements
|
|
.Where(f => f.Id == request.DisbursementId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(d => d.MilestoneId, request.MilestoneId)
|
|
.SetProperty(d => d.Amount, request.Amount)
|
|
.SetProperty(d => d.UpdatedAt, DateTime.UtcNow)
|
|
.SetProperty(d => d.UpdatedBy, userId), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update disbursement."));
|
|
}));
|
|
|
|
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.Create("Rule not found."))
|
|
.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() ?? []);
|
|
}));
|
|
}
|