pfm/PostFundManagement.Application/Services/Governance/GovernanceService.cs

using PostFundManagement.Application.Shared;
using PostFundManagement.Domain;
using PostFundManagement.Domain.Abstractions;
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) : IService
{
    public async ValueTask<Result<Programme[]>> GetProgrammesAsync(CancellationToken cancellationToken =  default)
    {
        try
        {
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var programmes = await context.Programmes.AsNoTracking().ToListAsync(cancellationToken);

            return Result.Ok(programmes?.Select(p => p.Map()).ToArray() ?? []);
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(CancellationToken cancellationToken =  default)
    {
        try
        {
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var portfolios = await context.Portfolios.AsNoTracking().ToListAsync(cancellationToken);

            return Result.Ok(portfolios?.Select(p => p.Map()).ToArray() ?? []);
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken =  default)
    {
        try
        {
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var organisations = await context.Organisations.AsNoTracking()
                .OrderBy(o => o.Name)
                .Skip((pagination.Page - 1) * pagination.PageSize)
                .Take(pagination.PageSize)
                .ToListAsync(cancellationToken);

            return Result.Ok(organisations?.Select(o => o.Map()).ToArray() ?? []);
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Organisation>> GetOrganisationByIdAsync(string organisationIdHash, CancellationToken cancellationToken =  default)
    {
        try
        {
            var decodeResult = hashService.DecodeLongIdHash(organisationIdHash);

            if (decodeResult.IsFailed)
                return Result.Fail(decodeResult.Errors);

            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var organisation = await context.Organisations.AsNoTracking()
                .FirstOrDefaultAsync(o => o.Id == decodeResult.Value, cancellationToken);

            return organisation is not null
                ? Result.Ok(organisation.Map())
                : Result.Fail("Failed to find specific organisation");
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Instrument[]>> GetInstrumentsAsync(CancellationToken cancellationToken =  default)
    {
        try
        {
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            var instruments = await context.Instruments.AsNoTracking().ToListAsync(cancellationToken);

            return Result.Ok(instruments?.Select(i => i.Map()).ToArray() ?? []);
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default)
    {
        try
        {
            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));
        }
        catch (Exception ex)
        {
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }

    public async ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default)
    {
		try
		{
            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);

            if (await context.Organisations.AnyAsync(o => o.RegistrationNo == request.RegistrationNo, cancellationToken))
                return Result.Fail("Organisation with the same registration number already exists");

            context.Organisations.Add(new Domain.Entities.Organisation
            {
                Name = request.Name,
                RegistrationNo = request.RegistrationNo,
                Email = request.Email,
                Type = request.Type,
                Status = ActivityStatus.Active,
                CreatedBy = userId,
                CreatedAt = DateTime.UtcNow
            });

            return await context.SaveChangesAsync(cancellationToken) > 0
                ? Result.Ok()
                : Result.Fail("Failed to create organisation");
        }
		catch (Exception ex)
		{
            return Result.Fail(new Error(ex.Message).CausedBy(ex));
        }
    }
}