925 lines
46 KiB
C#
925 lines
46 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.Projects;
|
|
|
|
public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
|
|
ITenantContextService tenantContext) : IProjectService
|
|
{
|
|
public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Users.AnyAsync(u => u.Id == userId, cancellationToken))
|
|
return Result.Fail(NotFoundError.New);
|
|
|
|
if (request.Status == ApprovalStatus.Approved)
|
|
{
|
|
var hasUnmetCompliance = await context.ComplianceItems
|
|
.AnyAsync(c => c.ProjectId == request.ProjectId && c.Status == ComplianceStatus.NotMet, cancellationToken);
|
|
if (hasUnmetCompliance)
|
|
return Result.Fail(ValidationError.Create("Project cannot be approved because some compliance items are not met."));
|
|
|
|
var projectBeneficiaryIds = await context.Beneficiaries
|
|
.Where(b => b.ProjectId == request.ProjectId)
|
|
.Select(b => b.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
if (projectBeneficiaryIds.Count > 0)
|
|
{
|
|
var hasUnmetOutcomes = await context.Outcomes
|
|
.AnyAsync(o => projectBeneficiaryIds.Contains(o.BeneficiaryId) && o.Status == ComplianceStatus.NotMet, cancellationToken);
|
|
if (hasUnmetOutcomes)
|
|
return Result.Fail(ValidationError.Create("Project cannot be approved because some beneficiary outcomes are not met."));
|
|
}
|
|
}
|
|
|
|
var changedTotal = await context.Projects
|
|
.Where(f => f.Id == request.ProjectId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(p => p.Status, request.Status)
|
|
.SetProperty(p => p.UpdatedBy, userId)
|
|
.SetProperty(p => p.UpdatedAt, DateTime.UtcNow), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var projects = await context.Projects.AsNoTracking().OrderByDescending(p => p.CreatedAt)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(projects?.Select(p => p.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Project>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Project>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var project = await context.Projects.AsNoTracking()
|
|
.FirstOrDefaultAsync(p => p.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(project is null, NotFoundError.Create("Project not found"))
|
|
.ToResult(project?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Domain.Models.Activity[]>(IdDecodeError.Create().CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var activities = await context.Activities.AsNoTracking()
|
|
.Where(a => a.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(a => a.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(activities?.Select(a => a.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var name = request.Name.Humanize(LetterCasing.Title).Trim();
|
|
|
|
if (await context.Projects.AnyAsync(p => p.Name == name && p.Sector == request.Sector && p.ProjectType == request.ProjectType, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("A similarly named project exists of the same project type and sector"));
|
|
|
|
if (!await context.Programmes.AnyAsync(p => p.Id == request.ProgrammeId, cancellationToken))
|
|
return Result.Fail(NotFoundError.New);
|
|
|
|
var description = request.Description.Humanize(LetterCasing.Sentence).Trim();
|
|
|
|
context.Projects.Add(new Domain.Entities.Project
|
|
{
|
|
ProgrammeId = request.ProgrammeId,
|
|
Name = name,
|
|
Description = description,
|
|
Sector = request.Sector,
|
|
ProjectType = request.ProjectType,
|
|
Status = ApprovalStatus.Pending,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow,
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result> CreateActivityAsync(CreateActivityRequest 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);
|
|
|
|
if (request.MilestoneId.HasValue)
|
|
if (!await context.Milestones.AnyAsync(m => m.Id == request.MilestoneId.Value, cancellationToken))
|
|
return Result.Fail(NotFoundError.New);
|
|
|
|
var approvedBudget = await context.Budgets
|
|
.Where(b => b.ProjectId == request.ProjectId && (b.Status == ApprovalStatus.Approved || b.Status == ApprovalStatus.Pending))
|
|
.SumAsync(b => b.Amount, cancellationToken);
|
|
|
|
if (approvedBudget == 0)
|
|
{
|
|
approvedBudget = await context.Awards
|
|
.Where(a => a.ProjectId == request.ProjectId)
|
|
.SumAsync(a => a.Amount, cancellationToken);
|
|
}
|
|
|
|
if (approvedBudget > 0)
|
|
{
|
|
var existingTotal = await context.Activities
|
|
.Where(a => a.ProjectId == request.ProjectId)
|
|
.SumAsync(a => a.Amount, cancellationToken);
|
|
|
|
if (existingTotal + request.Amount > approvedBudget)
|
|
{
|
|
return Result.Fail(CreateError.Create($"Activity budget R {request.Amount:N2} exceeds the available project budget. Approved budget: R {approvedBudget:N2}, already allocated: R {existingTotal:N2}, remaining: R {(approvedBudget - existingTotal):N2}."));
|
|
}
|
|
}
|
|
|
|
context.Activities.Add(new Domain.Entities.Activity
|
|
{
|
|
ProjectId = request.ProjectId,
|
|
MilestoneId = request.MilestoneId,
|
|
Category = request.Category.Humanize(LetterCasing.Title).Trim(),
|
|
Amount = request.Amount,
|
|
Title = request.Title.Humanize(LetterCasing.Title).Trim(),
|
|
Description = request.Description,
|
|
PerformedAt = request.PerformedAt,
|
|
Status = ApprovalStatus.Pending,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("No record was created."));
|
|
}));
|
|
|
|
public async Task<Result> UpdateActivityAsync(UpdateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var activity = await context.Activities.FirstOrDefaultAsync(a => a.Id == request.ActivityId, cancellationToken);
|
|
if (activity is null)
|
|
return Result.Fail(NotFoundError.Create("Activity not found"));
|
|
|
|
if (request.MilestoneId.HasValue && !await context.Milestones.AnyAsync(m => m.Id == request.MilestoneId.Value, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Milestone not found"));
|
|
|
|
var approvedBudget = await context.Budgets
|
|
.Where(b => b.ProjectId == request.ProjectId && (b.Status == ApprovalStatus.Approved || b.Status == ApprovalStatus.Pending))
|
|
.SumAsync(b => b.Amount, cancellationToken);
|
|
|
|
if (approvedBudget == 0)
|
|
{
|
|
approvedBudget = await context.Awards
|
|
.Where(a => a.ProjectId == request.ProjectId)
|
|
.SumAsync(a => a.Amount, cancellationToken);
|
|
}
|
|
|
|
if (approvedBudget > 0)
|
|
{
|
|
var otherTotal = await context.Activities
|
|
.Where(a => a.ProjectId == request.ProjectId && a.Id != request.ActivityId)
|
|
.SumAsync(a => a.Amount, cancellationToken);
|
|
|
|
if (otherTotal + request.Amount > approvedBudget)
|
|
{
|
|
return Result.Fail(UpdateError.Create($"Updated activity budget R {request.Amount:N2} exceeds the available project budget. Approved budget: R {approvedBudget:N2}, other allocated: R {otherTotal:N2}, remaining: R {(approvedBudget - otherTotal):N2}."));
|
|
}
|
|
}
|
|
|
|
activity.Title = request.Title.Humanize(LetterCasing.Title).Trim();
|
|
activity.Description = request.Description;
|
|
activity.Category = request.Category.Humanize(LetterCasing.Title).Trim();
|
|
activity.Amount = request.Amount;
|
|
activity.MilestoneId = request.MilestoneId;
|
|
activity.PerformedAt = request.PerformedAt;
|
|
activity.UpdatedBy = userId;
|
|
activity.UpdatedAt = DateTime.UtcNow;
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
UpdateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Milestone[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var milestones = await context.Milestones.AsNoTracking()
|
|
.Where(m => m.ProjectId == decodeResult.Value)
|
|
.OrderBy(m => m.DueAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(milestones?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken) =>
|
|
await Result.Try((Func<Task<Result<Indicator[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Indicator[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var evidences = await context.Indicators.AsNoTracking()
|
|
.Where(e => e.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(evidences?.Select(e => e.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(milestoneIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Milestone>(IdDecodeError.Create().CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var milestone = await context.Milestones.AsNoTracking()
|
|
.FirstOrDefaultAsync(m => m.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(milestone is null, NotFoundError.Create("Milestone not found"))
|
|
.ToResult(milestone?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Milestone[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var milestones = await context.Milestones.AsNoTracking()
|
|
.OrderByDescending(m => m.CreatedAt)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(milestones?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Users.AnyAsync(u => u.Id == userId, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("User not found"));
|
|
|
|
var changedTotal = await context.Milestones.Where(m => m.Id == request.MilestoneId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.DueAt, request.DueAt)
|
|
.SetProperty(u => u.Priority, request.Priority)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.UpdatedBy, userId)
|
|
.SetProperty(u => u.UpdatedAt, DateTime.UtcNow), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result> UpdateProjectAsync(UpdateProjectRequest 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.Projects.Where(p => p.Id == request.ProjectId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Description, request.Description.Humanize(LetterCasing.Sentence).Trim())
|
|
.SetProperty(u => u.StartedAt, request.StartedAt)
|
|
.SetProperty(u => u.EndedAt, request.EndedAt)
|
|
.SetProperty(u => u.UpdatedBy, userId)
|
|
.SetProperty(u => u.UpdatedAt, DateTime.UtcNow)
|
|
.SetProperty(u => u.Sector, request.Sector)
|
|
.SetProperty(u => u.ProjectType, request.ProjectType), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Domain.Models.Activity>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(activityIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Domain.Models.Activity>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var activity = await context.Activities.AsNoTracking()
|
|
.FirstOrDefaultAsync(a => a.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(activity is null, NotFoundError.Create("Activity not found"))
|
|
.ToResult(activity?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Risk[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Risk[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var risks = await context.Risks.AsNoTracking()
|
|
.Where(r => r.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(r => r.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(risks?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var name = request.Name.Humanize(LetterCasing.Title).Trim();
|
|
|
|
if (!await context.Portfolios.AnyAsync(p => p.Id == request.PortfolioId, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Portfolio does not exist."));
|
|
|
|
if (await context.Programmes.AnyAsync(p => p.Name == name, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Programme of the same name exists"));
|
|
|
|
context.Programmes.Add(new Domain.Entities.Programme
|
|
{
|
|
PortfolioId = request.PortfolioId,
|
|
OwnedBy = request.OwnerId,
|
|
Name = name,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow,
|
|
Status = ApprovalStatus.Pending,
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create programme."));
|
|
}));
|
|
|
|
public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Users.AnyAsync(u => u.Id == userId, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("User not found"));
|
|
|
|
var changedTotal = await context.Programmes.Where(p => p.Id == request.ProgrammeId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.OwnedBy, request.OwnerId)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.UpdatedBy, userId)
|
|
.SetProperty(u => u.UpdatedAt, DateTime.UtcNow), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No changes detected, update cancelled."));
|
|
}));
|
|
|
|
public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Programme>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
|
|
|
|
if (decodeResult.IsFailed) return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var programme = await context.Programmes.FirstOrDefaultAsync(p => p.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(programme is null, NotFoundError.Create("Programme not found"))
|
|
.ToResult(programme?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var programmes = await context.Programmes.AsNoTracking()
|
|
.OrderByDescending(m => m.CreatedAt)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(programmes?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Project[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(programmeIdHash);
|
|
|
|
if (decodeResult.IsFailed) return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Programmes.AnyAsync(p => p.Id == decodeResult.Value, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Programme not found"));
|
|
|
|
var projects = await context.Projects.AsNoTracking()
|
|
.Where(p => p.ProgrammeId == decodeResult.Value)
|
|
.OrderByDescending(o => o.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(projects?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result> CreateChangeRequestAsync(CreateChangeRequest 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(ValidationError.Create("Project does not exist"));
|
|
|
|
context.ChangeRequests.Add(new Domain.Entities.ChangeRequest
|
|
{
|
|
ProjectId = request.ProjectId,
|
|
Title = request.Title,
|
|
Justification = request.Justification,
|
|
RevisedBudget = request.RevisedBudget,
|
|
RevisedEndedAt = request.RevisionDate,
|
|
Status = ApprovalStatus.Pending,
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
TenantId = tenantContext.TenantId,
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("Failed to create change request"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateChangeRequestAsync(UpdateChangeRequest 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.ChangeRequests
|
|
.Where(c => c.Id == request.ChangeRequestId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.RevisedBudget, request.RevisedBudget)
|
|
.SetProperty(u => u.RevisedEndedAt, DateTime.UtcNow)
|
|
.SetProperty(u => u.Title, request.Title.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Justification, request.Justification), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records were changed"));
|
|
}));
|
|
|
|
public async Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ChangeRequest[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<ChangeRequest[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var changeRequests = await context.ChangeRequests.AsNoTracking()
|
|
.Where(c => c.ProjectId == decodeResult.Value)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(changeRequests?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ChangeRequest>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(changeRequestIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<ChangeRequest>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var changeRequest = await context.ChangeRequests.AsNoTracking().FirstOrDefaultAsync(c => c.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(changeRequest is null, NotFoundError.Create("Change request not found"))
|
|
.ToResult(changeRequest?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateComplianceItemAsync(CreateComplianceItemRequest 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(ValidationError.Create("Project does not exist"));
|
|
|
|
context.ComplianceItems.Add(new Domain.Entities.ComplianceItem
|
|
{
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
ProjectId = request.ProjectId,
|
|
BeneficiaryId = request.BeneficiaryId,
|
|
Requirements = request.Requirements,
|
|
Status = request.Status,
|
|
TenantId = tenantContext.TenantId,
|
|
Title = request.Title.Humanize(LetterCasing.Title).Trim()
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create compliance item"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateComplianceItemAsync(UpdateComplianceItemRequest 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.ComplianceItems
|
|
.Where(f => f.Id == request.ComplianceItemId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Title, request.Title.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Requirements, request.Requirements)
|
|
.SetProperty(u => u.BeneficiaryId, request.BeneficiaryId)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.UpdatedAt, DateTime.UtcNow)
|
|
.SetProperty(u => u.VerifiedBy, userId), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records changed"));
|
|
}));
|
|
|
|
public async Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ComplianceItem[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<ComplianceItem[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var complianceItems = await context.ComplianceItems.AsNoTracking()
|
|
.Where(c => c.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(complianceItems?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<ComplianceItem>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(complianceItemIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<ComplianceItem>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var compliancItem = await context.ComplianceItems.AsNoTracking().FirstOrDefaultAsync(c => c.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(compliancItem is null, NotFoundError.Create("Compliance item not found"))
|
|
.ToResult(compliancItem?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateBeneficiaryAsync(CreateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
context.Beneficiaries.Add(new Domain.Entities.Beneficiary
|
|
{
|
|
Category = request.Category,
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
Location = request.Location,
|
|
Name = request.Name.Humanize(LetterCasing.Title).Trim(),
|
|
ProjectId = request.ProjectId,
|
|
ReachedCount = request.ReachedCount,
|
|
TargetCount = request.TargetCount,
|
|
UserId = userId,
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("Failed to create beneficiary"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateBeneficiaryAsync(UpdateBeneficiaryRequest 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.Beneficiaries
|
|
.Where(f => f.Id == request.BeneficiaryId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.ReachedCount, request.ReachedCount)
|
|
.SetProperty(u => u.TargetCount, request.TargetCount)
|
|
.SetProperty(u => u.Location, request.Location)
|
|
.SetProperty(u => u.Category, request.Category.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim()), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records changed"));
|
|
}));
|
|
|
|
public async Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Beneficiary[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Beneficiary[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var beneficiaries = await context.Beneficiaries.AsNoTracking()
|
|
.Where(b => b.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(beneficiaries?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Beneficiary>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(beneficiaryIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Beneficiary>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var beneficiary = await context.Beneficiaries.AsNoTracking()
|
|
.FirstOrDefaultAsync(b => b.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(beneficiary is null, NotFoundError.Create("Beneficiary not found"))
|
|
.ToResult(beneficiary?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateIssueAsync(CreateIssueRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
context.Issues.Add(new Domain.Entities.Issue
|
|
{
|
|
AssignedTo = request.AssignedTo,
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
Description = request.Description,
|
|
Priority = request.Priority,
|
|
ProjectId = request.ProjectId,
|
|
Status = ActivityStatus.Active,
|
|
TenantId = tenantContext.TenantId,
|
|
Title = request.Title.Humanize(LetterCasing.Title).Trim()
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create issue"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateIssueAsync(UpdateIssueRequest 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.Issues
|
|
.Where(i => i.Id == request.IssueId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Title, request.Title.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Description, request.Description)
|
|
.SetProperty(u => u.Resolution, request.Resolution)
|
|
.SetProperty(u => u.ResolvedAt, DateTime.UtcNow)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.AssignedTo, request.AssignedTo), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records changes"));
|
|
}));
|
|
|
|
public async Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Issue[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Issue[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var issues = await context.Issues.AsNoTracking()
|
|
.Where(i => i.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(issues?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Issue>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(issueIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Issue>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var issue = await context.Issues.AsNoTracking().FirstOrDefaultAsync(i => i.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(issue is null, NotFoundError.Create("Issue not found"))
|
|
.ToResult(issue?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateOutcomeAsync(CreateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
context.Outcomes.Add(new Domain.Entities.Outcome
|
|
{
|
|
BeneficiaryId = request.BeneficiaryId,
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
Description = request.Description,
|
|
Name = request.Name.Humanize(LetterCasing.Title).Trim(),
|
|
Status = request.Status,
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create outcome"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateOutcomeAsync(UpdateOutcomeRequest 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.Outcomes
|
|
.Where(o => o.Id == request.OutcomeId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Description, request.Description)
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Status, request.Status), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records changed"));
|
|
}));
|
|
|
|
public async Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Outcome[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(beneficiaryIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Outcome[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var outcomes = await context.Outcomes.AsNoTracking()
|
|
.Where(o => o.BeneficiaryId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(outcomes?.Select(o => o.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Outcome>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(outcomeIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<Outcome>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var outcome = await context.Outcomes.AsNoTracking()
|
|
.FirstOrDefaultAsync(o => o.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(outcome is null, NotFoundError.Create("Outcome not found"))
|
|
.ToResult(outcome?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateSiteVisitAsync(CreateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
context.SiteVisits.Add(new Domain.Entities.SiteVisit
|
|
{
|
|
CreatedAt = DateTime.UtcNow,
|
|
ProjectId = request.ProjectId,
|
|
CreatedBy = userId,
|
|
InspectorName = request.InspectorName.Humanize(LetterCasing.Title).Trim(),
|
|
Findings = request.Findings,
|
|
VisitedAt = request.VisitedAt
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create site visit"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateSiteVisitAsync(UpdateSiteVisitRequest 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.SiteVisits
|
|
.Where(v => v.Id == request.SiteVisitId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.InspectorName, request.InspectorName.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Findings, request.Findings)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.VisitedAt, request.VisitedAt), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update site visit"));
|
|
}));
|
|
|
|
public async Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<SiteVisit[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(projectIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<SiteVisit[]>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var visits = await context.SiteVisits.AsNoTracking()
|
|
.Where(v => v.ProjectId == decodeResult.Value)
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(visits?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<SiteVisit>> GetSiteVisitAsync(string siteVisitIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<SiteVisit>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(siteVisitIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail<SiteVisit>(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var visit = await context.SiteVisits.AsNoTracking().FirstOrDefaultAsync(v => v.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(visit is null, NotFoundError.Create("Site visit not found"))
|
|
.ToResult(visit?.Map()!);
|
|
}));
|
|
}
|