566 lines
28 KiB
C#
566 lines
28 KiB
C#
using PostFundManagement.Application.Abstractions.Services;
|
|
using PostFundManagement.Application.Extensions;
|
|
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.Governance;
|
|
|
|
public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
|
|
ITenantContextService tenantContext) : IGovernanceService
|
|
{
|
|
public async Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var programmes = await context.Programmes.AsNoTracking()
|
|
.Where(p => p.PortfolioId == decodeResult.Value)
|
|
.OrderByDescending(o => o.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(programmes?.Select(p => p.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Portfolio[]>> GetOrganisationPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var portfolios = await context.Portfolios.AsNoTracking()
|
|
.Include(i => i.Organisation)
|
|
.Where(f => f.OrganisationId == decodeResult.Value)
|
|
.OrderByDescending(o => o.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(portfolios?.Select(p => p.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Organisation[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var organisations = await context.TenantOrganisations.AsNoTracking()
|
|
.Include(i => i.Organisation)
|
|
.OrderBy(o => o.Organisation!.Name)
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(organisations?.Select(o => o.Organisation!.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var tenantOrganisation = await context.TenantOrganisations.AsNoTracking()
|
|
.Include(i => i.OrganisationId)
|
|
.FirstOrDefaultAsync(o => o.OrganisationId == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(tenantOrganisation is null, NotFoundError.Create("Organisation not found"))
|
|
.ToResult(tenantOrganisation?.Organisation?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Instrument[]>>>)(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 instruments = await context.Instruments.AsNoTracking()
|
|
.Where(i => i.ProgrammeId == decodeResult.Value)
|
|
.OrderByDescending(o => o.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(instruments?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var totalPortfolioValue = await context.Awards.SumAsync(a => a.Amount, cancellationToken);
|
|
var activeAwardsCount = await context.Awards.CountAsync(a => a.Status == ApprovalStatus.Approved, cancellationToken);
|
|
|
|
var disbursedAmount = await context.Disbursements.Where(d => d.Status == ApprovalStatus.Approved)
|
|
.SumAsync(d => d.Amount, cancellationToken);
|
|
|
|
var totalProjects = await context.Projects.CountAsync(cancellationToken);
|
|
var onTrackProjects = await context.Projects.CountAsync(p => p.Status == ApprovalStatus.Approved, cancellationToken);
|
|
|
|
var onTrackPercentage = totalProjects > 0
|
|
? Math.Round((double)onTrackProjects / totalProjects * 100, 1)
|
|
: 100.0;
|
|
|
|
var atRiskCount = await context.Risks.CountAsync(r => r.Impact == RiskImpact.Critical || r.Impact == RiskImpact.Major, cancellationToken);
|
|
|
|
var beneficiariesReached = await context.Beneficiaries.SumAsync(b => b.ReachedCount, cancellationToken);
|
|
|
|
return Result.Ok(new Dashboard(totalPortfolioValue, activeAwardsCount,
|
|
disbursedAmount, onTrackPercentage, atRiskCount, beneficiariesReached));
|
|
}));
|
|
|
|
public async Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var registrationNo = request.RegistrationNo.Clean();
|
|
|
|
if(!await context.Users.AnyAsync(u => u.Id == request.OrganisationUser, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Organisation user not found"));
|
|
|
|
if(!await context.TenantUsers.AnyAsync(u => u.UserId == request.OrganisationUser && u.TenantId == tenantContext.TenantId, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Organisation user does not belong to the current tenant"));
|
|
|
|
if (await context.Organisations.AnyAsync(o => o.RegistrationNo == registrationNo, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Organisation with the same registration number already exists"));
|
|
|
|
var organisation = context.Organisations.Add(new Domain.Entities.Organisation
|
|
{
|
|
Name = request.Name.Humanize(LetterCasing.Title).Trim(),
|
|
RegistrationNo = registrationNo,
|
|
Email = request.Email.ToLower(CultureInfo.InvariantCulture).Clean(),
|
|
Type = request.Type,
|
|
Status = ActivityStatus.Active,
|
|
CreatedBy = userId,
|
|
CreatedAt = DateTime.UtcNow,
|
|
UserId = request.OrganisationUser
|
|
});
|
|
|
|
if(!string.IsNullOrWhiteSpace(request.IdNumber))
|
|
{
|
|
var linkedUser = await context.Users.FirstOrDefaultAsync(u => u.Id == request.OrganisationUser, cancellationToken);
|
|
|
|
linkedUser!.IdNumber = request.IdNumber.Clean();
|
|
}
|
|
|
|
await context.SaveChangesAsync(cancellationToken);
|
|
|
|
var mapResult = await CreateTenantOrganisationAsync(hashService.HashEncodeLongId(organisation.Entity.Id).Value,
|
|
hashService.HashEncodeLongId(tenantContext.TenantId).Value, userId, cancellationToken);
|
|
|
|
return Result.FailIf(mapResult.IsFailed, CreateError.Create("Failed to create organisation"));
|
|
}));
|
|
|
|
public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Organisation>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (!await context.Users.AnyAsync(u => u.Id == request.OrganisationUser, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Organisation user not found"));
|
|
|
|
if (!await context.TenantUsers.AnyAsync(u => u.UserId == request.OrganisationUser && u.TenantId == tenantContext.TenantId, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Organisation user does not belong to the current tenant"));
|
|
|
|
var changedTotal = await context.Organisations
|
|
.Where(f => f.Id == request.OrganisationId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.RegistrationNo, request.RegistrationNo.Clean())
|
|
.SetProperty(u => u.Email, request.Email.ToLower(CultureInfo.InvariantCulture).Clean())
|
|
.SetProperty(u => u.Type, request.Type)
|
|
.SetProperty(u => u.Status, request.Status), cancellationToken);
|
|
|
|
var tenantOrganisation = await context.TenantOrganisations.AsNoTracking().FirstOrDefaultAsync(f => f.OrganisationId == request.OrganisationId, cancellationToken);
|
|
|
|
if (tenantOrganisation is null)
|
|
return Result.Fail(ValidationError.Create("Failed to find linked tenant organisation"));
|
|
|
|
var updateResult = await UpdateTenantOrganisationAsync(hashService.HashEncodeLongId(tenantOrganisation.Id).Value, request.Status, userId, cancellationToken);
|
|
|
|
if (!string.IsNullOrWhiteSpace(request.IdNumber))
|
|
{
|
|
var linkedUser = await context.Users.FirstOrDefaultAsync(u => u.Id == request.OrganisationUser, cancellationToken);
|
|
|
|
linkedUser!.IdNumber = request.IdNumber.Clean();
|
|
}
|
|
|
|
await context.SaveChangesAsync(cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0 && updateResult.IsSuccess, UpdateError.Create("Failed to update organisation"));
|
|
}));
|
|
|
|
public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest 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 == request.OwnerId, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Owner user not found"));
|
|
|
|
if (!await context.Organisations.AnyAsync(u => u.Id == request.OrganisationId, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Organisation not found"));
|
|
|
|
var name = request.Name.Humanize(LetterCasing.Title).Trim();
|
|
|
|
if (await context.Portfolios.AnyAsync(p => p.Name == name && p.OrganisationId == request.OrganisationId, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("A portfolio with the same name exists in this organisation"));
|
|
|
|
context.Portfolios.Add(new Domain.Entities.Portfolio
|
|
{
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
OrganisationId = request.OrganisationId,
|
|
OwnedBy = request.OwnerId,
|
|
Name = name,
|
|
Description = request.Description.Humanize(LetterCasing.Sentence).Trim(),
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create portfolio"));
|
|
}));
|
|
|
|
public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest 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 == request.OwnerId, cancellationToken))
|
|
return Result.Fail(NotFoundError.Create("Owner user not found"));
|
|
|
|
var changedTotal = await context.Portfolios
|
|
.Where(p => p.Id == request.PortfolioId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.OwnedBy, request.OwnerId)
|
|
.SetProperty(u => u.Description, request.Description.Humanize(LetterCasing.Sentence).Trim()), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Nothing was saved, no change detected."));
|
|
}));
|
|
|
|
public async Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Programme[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var programmes = await context.Programmes.AsNoTracking()
|
|
.Where(f => f.PortfolioId == decodeResult.Value)
|
|
.OrderByDescending(o => o.CreatedAt)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(programmes?.Select(p => p.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Portfolio>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var portfolio = await context.Portfolios.AsNoTracking()
|
|
.FirstOrDefaultAsync(p => p.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(portfolio is null, NotFoundError.Create("Portfolio not found"))
|
|
.ToResult(portfolio?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> CreateTenantAsync(CreateTenantRequest 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();
|
|
|
|
if (await context.Tenants.AnyAsync(t => t.Name == requestedName, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("A tenant with an equivalent name exists."));
|
|
|
|
context.Tenants.Add(new Domain.Entities.Tenant
|
|
{
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
Name = requestedName,
|
|
Status = ActivityStatus.Active
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("Failed to create new tenant"));
|
|
}));
|
|
|
|
public async Task<Result<Tenant[]>> GetTenantsAsync(CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Tenant[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var tenants = await context.Tenants.AsNoTracking()
|
|
.OrderByDescending(o => o.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(tenants?.Select(t => t.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<Tenant>> GetTenantAsync(string tenantIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Tenant>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(tenantIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var tenant = await context.Tenants.AsNoTracking().FirstOrDefaultAsync(t => t.Id == decodeResult.Value, cancellationToken);
|
|
|
|
return Result.FailIf(tenant is null, NotFoundError.Create("Failed to retrieve tenant"))
|
|
.ToResult(tenant?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> UpdateTenantAsync(UpdateTenantRequest 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();
|
|
|
|
if (await context.Tenants.AnyAsync(t => t.Name == requestedName, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("A tenant with an equivalent name exists."));
|
|
|
|
var changedTotal = await context.Tenants
|
|
.Where(f => f.Id == request.TenantId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.UpdatedAt, DateTime.UtcNow)
|
|
.SetProperty(u => u.UpdatedBy, userId)
|
|
.SetProperty(u => u.Status, request.Status)
|
|
.SetProperty(u => u.Name, requestedName), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records updated"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateTenantUserAsync(UpdateTenantUserRequest 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.TenantUsers
|
|
.Where(f => f.UserId == request.UserId)
|
|
.ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, request.Status), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("No records updated"));
|
|
}));
|
|
|
|
public async Task<Result> CreateTenantOrganisationAsync(string organisationIdHash, string tenantIdHash, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
var organisationDecodeResult = hashService.DecodeLongIdHash(organisationIdHash);
|
|
|
|
if (organisationDecodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(organisationDecodeResult.Errors));
|
|
|
|
var tenantDecodeResult = hashService.DecodeLongIdHash(tenantIdHash);
|
|
|
|
if (tenantDecodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(tenantDecodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
if (await context.TenantOrganisations.AnyAsync(to => to.OrganisationId == organisationDecodeResult.Value && to.TenantId == tenantDecodeResult.Value, cancellationToken))
|
|
return Result.Fail(ValidationError.Create("Already exists"));
|
|
|
|
context.TenantOrganisations.Add(new Domain.Entities.TenantOrganisation
|
|
{
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
OrganisationId = organisationDecodeResult.Value,
|
|
TenantId = tenantDecodeResult.ValueOrDefault
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
|
|
CreateError.Create("Failed to create tenant organisation map"));
|
|
}));
|
|
|
|
public async Task<Result> UpdateTenantOrganisationAsync(string tenantOrganisationIdHash, ActivityStatus status, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(tenantOrganisationIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var changedTotal = await context.TenantOrganisations
|
|
.Where(f => f.Id == decodeResult.Value)
|
|
.ExecuteUpdateAsync(f => f.SetProperty(u => u.Status, status), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update tenant organisation map"));
|
|
}));
|
|
|
|
public async Task<Result<TenantOrganisation[]>> GetTenantOrganisationsAsync(string tenantIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<TenantOrganisation[]>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(tenantIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var tenantOrganisations = await context.TenantOrganisations.AsNoTracking()
|
|
.Include(i => i.Organisation)
|
|
.Include(i => i.Tenant)
|
|
.Where(f => f.TenantId == decodeResult.Value)
|
|
.ToListAsync();
|
|
|
|
return Result.Ok(tenantOrganisations?.Select(i => i.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<TenantOrganisation>> GetTenantOrganisationAsync(string tenantOrganisationIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<TenantOrganisation>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(tenantOrganisationIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var tenantOrganisation = await context.TenantOrganisations.AsNoTracking()
|
|
.Include(i => i.Organisation)
|
|
.Include(i => i.Tenant)
|
|
.FirstOrDefaultAsync(f => f.TenantId == tenantContext.TenantId, cancellationToken);
|
|
|
|
return Result.FailIf(tenantOrganisation is null, NotFoundError.Create("Failed to find tenant organisation map"))
|
|
.ToResult(tenantOrganisation?.Map()!);
|
|
}));
|
|
|
|
public async Task<Result> UpdateInstrumentAsync(UpdateInstrumentRequest 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.Instruments
|
|
.Where(i => i.Id == request.InstructionId)
|
|
.ExecuteUpdateAsync(f => f
|
|
.SetProperty(u => u.Name, request.Name.Humanize(LetterCasing.Title).Trim())
|
|
.SetProperty(u => u.Code, request.Code)
|
|
.SetProperty(u => u.Description, request.Description)
|
|
.SetProperty(u => u.Status, request.Status), cancellationToken);
|
|
|
|
return Result.OkIf(changedTotal > 0, UpdateError.Create("Failed to update instrument"));
|
|
}));
|
|
|
|
public async Task<Result> CreateInstrumentAsync(CreateInstrumentRequest request, Guid userId, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
context.Instruments.Add(new Domain.Entities.Instrument
|
|
{
|
|
Code = request.Code,
|
|
CreatedAt = DateTime.UtcNow,
|
|
CreatedBy = userId,
|
|
Description = request.Description,
|
|
Name = request.Name.Humanize(LetterCasing.Title).Trim(),
|
|
Status = ActivityStatus.Active,
|
|
ProgrammeId = request.ProgrammeId,
|
|
TenantId = tenantContext.TenantId
|
|
});
|
|
|
|
return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.Create("Failed to create instrument"));
|
|
}));
|
|
|
|
public async Task<Result<Portfolio[]>> GetPorfoliosAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<Portfolio[]>>>)(async () =>
|
|
{
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var portfolios = await context.Portfolios.AsNoTracking()
|
|
.Skip((pagination.Page - 1) * pagination.PageSize)
|
|
.Take(pagination.PageSize)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
return Result.Ok(portfolios?.Select(p => p.Map()).ToArray() ?? []);
|
|
}));
|
|
|
|
public async Task<Result<decimal>> GetProgrammeValueAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<decimal>>>)(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 value = await context.Budgets.AsNoTracking()
|
|
.Include(i => i.Project!.Programme)
|
|
.Where(v => v.Project!.Programme!.Id == decodeResult.Value &&
|
|
v.Project.Programme.Status == ApprovalStatus.Approved &&
|
|
v.Status == ApprovalStatus.Approved)
|
|
.SumAsync(v => v.Amount, cancellationToken);
|
|
|
|
return Result.Ok(value);
|
|
}));
|
|
|
|
public async Task<Result<decimal>> GetPorfolioValueAsync(string portfolioIdHash, CancellationToken cancellationToken = default) =>
|
|
await Result.Try((Func<Task<Result<decimal>>>)(async () =>
|
|
{
|
|
var decodeResult = hashService.DecodeLongIdHash(portfolioIdHash);
|
|
|
|
if (decodeResult.IsFailed)
|
|
return Result.Fail(IdDecodeError.Create()
|
|
.CausedBy(decodeResult.Errors));
|
|
|
|
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
var value = await context.Budgets
|
|
.Include(i => i.Project!.Programme!.Portfolio)
|
|
.Where(v => v.Project!.Programme!.Portfolio!.Id == decodeResult.Value &&
|
|
v.Project.Programme.Status == ApprovalStatus.Approved &&
|
|
v.Status == ApprovalStatus.Approved)
|
|
.SumAsync(v => v.Amount, cancellationToken);
|
|
|
|
return Result.Ok(value);
|
|
}));
|
|
}
|