Implemented audit logging and automated logging

PostFundManagement.Api/appsettings.json

@@ -20,8 +20,11 @@
   },
   "Logging": {
     "LogLevel": {
-      "Default": "Information",
-      "Microsoft.AspNetCore": "Warning"
+      "Default": "Warning",
+      "Quartz": "Error",
+      "Microsoft.AspNetCore": "Warning",
+      "Microsoft.EntityFrameworkCore.Database": "Error",
+      "Microsoft.EntityFrameworkCore.Update": "Error"
     }
   },
   "EmailProcessorCron": "0 */5 * * * ?",

PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs

@@ -7,12 +7,16 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface ICommunicationsService
 {
+    [Log]
     [Audit]
     Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs

@@ -7,32 +7,44 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IEvidenceService
 {
+    [Log]
     [Audit]
     Task<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken);
 
+    [Log]
     Task<Result<Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<string>> GetEvidenceUrlAsync(string evidenceIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IExecutionService.cs

@@ -7,26 +7,35 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IExecutionService
 {
+    [Log]
     Task<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs

@@ -7,31 +7,43 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IGovernanceService
 {
+    [Log]
     Task<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
-    
+
+    [Log]
     Task<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
-    
+
+    [Log]
     Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IGrantsService.cs

@@ -7,36 +7,49 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IGrantsService
 {
+    [Log]
     Task<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result<string>> GetContractUrlAsync(string contractIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UploadContractAsync(string contractIdHash, Guid userId, IFormFile file, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateContractAsync(UpdateContractRequest request, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IIdentityService.cs

@@ -4,6 +4,7 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IIdentityService
 {
+    [Log]
     [Audit]
     Task<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IProjectService.cs

@@ -7,48 +7,67 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IProjectService
 {
+    [Log]
     [Audit]
     Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
-    
+
+    [Log]
     Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IUserService.cs

@@ -7,13 +7,17 @@ namespace PostFundManagement.Application.Abstractions.Services;
 
 public interface IUserService
 {
+    [Log]
     [Audit]
     Task<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default);
 
+    [Log]
     [Audit]
     Task<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default);
 
+    [Log]
     Task<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken);
 }

PostFundManagement.Application/Extensions/Services.cs

@@ -16,7 +16,7 @@ namespace PostFundManagement.Application.Extensions;
 
 public static class Services
 {
-    public static IServiceCollection AddAuditedCachedScoped<TInterface, TImplementation, TCacheDecorator>(this IServiceCollection services)
+    public static IServiceCollection AddLoggedAuditedCachedServiceScoped<TInterface, TImplementation, TCacheDecorator>(this IServiceCollection services)
         where TInterface : class
         where TImplementation : class, TInterface
         where TCacheDecorator : class, TInterface
@@ -27,30 +27,16 @@ public static class Services
         services.AddScoped(sp =>
         {
             var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
-            var interceptor = sp.GetRequiredService<AuditInterceptor>();
+            var auditInterceptor = sp.GetRequiredService<AuditInterceptor>();
+            var loggingInterceptor = sp.GetRequiredService<LoggingInterceptor>();
 
             var actual = sp.GetRequiredService<TImplementation>();
 
             var cached = ActivatorUtilities.CreateInstance<TCacheDecorator>(sp, actual);
 
-            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(cached, interceptor.ToInterceptor());
-        });
-
-        return services;
-    }
-
-    public static IServiceCollection AddAuditedScoped<TInterface, TImplementation>(this IServiceCollection services)
-            where TInterface : class
-            where TImplementation : class, TInterface
-    {
-        services.AddScoped<TImplementation>();
-        services.AddScoped(sp =>
-        {
-            var proxyGenerator = sp.GetRequiredService<ProxyGenerator>();
-            var actual = sp.GetRequiredService<TImplementation>();
-            var interceptor = sp.GetRequiredService<AuditInterceptor>();
-
-            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(actual, interceptor.ToInterceptor());
+            return proxyGenerator.CreateInterfaceProxyWithTarget<TInterface>(cached, 
+                loggingInterceptor.ToInterceptor(), 
+                           auditInterceptor.ToInterceptor());
         });
 
         return services;
@@ -59,15 +45,16 @@ public static class Services
     public static IServiceCollection AddRegisterServicesWithCaching(this IServiceCollection services, IConfiguration configuration)
     {
         services.AddScoped<AuditInterceptor>();
+        services.AddScoped<LoggingInterceptor>();
         services.AddSingleton<ProxyGenerator>();
 
-        services.AddAuditedCachedScoped<ICommunicationsService, CommunicationsService, CommunicationsCacheService>();
-        services.AddAuditedCachedScoped<IEvidenceService, EvidenceService, EvidenceCacheService>();
-        services.AddAuditedCachedScoped<IUserService, UserService, UserCacheService>();
-        services.AddAuditedCachedScoped<IExecutionService, ExecutionService, ExecutionCacheService>();
-        services.AddAuditedCachedScoped<IGovernanceService, GovernanceService, GovernanceCacheService>();
-        services.AddAuditedCachedScoped<IGrantsService, GrantsService, GrantsCacheService>();
-        services.AddAuditedCachedScoped<IProjectService, ProjectService, ProjectCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<ICommunicationsService, CommunicationsService, CommunicationsCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IEvidenceService, EvidenceService, EvidenceCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IUserService, UserService, UserCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IExecutionService, ExecutionService, ExecutionCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IGovernanceService, GovernanceService, GovernanceCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IGrantsService, GrantsService, GrantsCacheService>();
+        services.AddLoggedAuditedCachedServiceScoped<IProjectService, ProjectService, ProjectCacheService>();
 
         services.AddScoped<IIdentityService, IdentityService>();
         services.Decorate<IIdentityService, IdentityCacheService>();

PostFundManagement.Application/Interceptors/LoggingInterceptor.cs

@@ -0,0 +1,136 @@
+using PostFundManagement.Domain.Attributes;
+
+namespace PostFundManagement.Application.Interceptors;
+
+public sealed class LoggingInterceptor(ILogger<LoggingInterceptor> logger) : IAsyncInterceptor
+{
+    public void InterceptSynchronous(IInvocation invocation)
+    {
+        invocation.Proceed();
+
+        CheckAndLogIfFailed(invocation, invocation.ReturnValue);
+    }
+
+    public void InterceptAsynchronous(IInvocation invocation) =>
+        invocation.ReturnValue = InternalInterceptAsynchronous(invocation);
+
+    public void InterceptAsynchronous<TResult>(IInvocation invocation) =>
+        invocation.ReturnValue = InternalInterceptAsynchronous<TResult>(invocation);
+
+    private static async Task InternalInterceptAsynchronous(IInvocation invocation)
+    {
+        invocation.Proceed();
+
+        var task = (Task)invocation.ReturnValue;
+
+        await task.ConfigureAwait(false);
+    }
+
+    private async Task<TResult> InternalInterceptAsynchronous<TResult>(IInvocation invocation)
+    {
+        invocation.Proceed();
+
+        var task = (Task<TResult>)invocation.ReturnValue;
+        var resultObj = await task.ConfigureAwait(false);
+
+        var method = invocation.MethodInvocationTarget ?? invocation.Method;
+        var auditAttr = method.GetCustomAttribute<LogAttribute>()
+                     ?? invocation.Method.GetCustomAttribute<LogAttribute>();
+
+        if (auditAttr == null) return resultObj;
+
+        CheckAndLogIfFailed(invocation, resultObj);
+
+        return resultObj;
+    }
+
+    private void CheckAndLogIfFailed(IInvocation invocation, object? resultObj)
+    {
+        if (resultObj is IResultBase result && result.IsFailed)
+        {
+            try
+            {
+                var method = invocation.MethodInvocationTarget ?? invocation.Method;
+                var parameters = BuildPayloadSummary(method.GetParameters(), invocation.Arguments);
+
+                var errorMessages = new List<string>();
+
+                if (result.Reasons != null)
+                {
+                    foreach (var reason in result.Reasons)
+                        if (reason is IError error)
+                            errorMessages.Add(error.Message);
+                }
+
+                var errorsString = string.Join("; ", errorMessages);
+
+                logger.LogError("Method {MethodName} failed. Errors: {Errors}. Parameters: {@Parameters}",
+                    method.Name, errorsString, parameters);
+            }
+            catch (Exception ex)
+            {
+                logger.LogWarning(ex, "Failed to write error log for method {MethodName}.", invocation.Method.Name);
+            }
+        }
+    }
+
+    private static string[] BuildPayloadSummary(ParameterInfo[] parameters, object[] args)
+    {
+        var entries = new List<string>();
+
+        for (var i = 0; i < parameters.Length; i++)
+        {
+            var param = parameters[i];
+            var arg = args[i];
+
+            if (param.ParameterType == typeof(CancellationToken))
+                continue;
+
+            if (arg == null)
+            {
+                entries.Add($"{param.Name}: null");
+
+                continue;
+            }
+
+            if (arg is IFormFile file)
+            {
+                entries.Add($"{param.Name}: [File] Name='{file.FileName}', Size={file.Length} bytes, Type='{file.ContentType}'");
+
+                continue;
+            }
+
+            if (arg is IEnumerable<IFormFile> files)
+            {
+                var fileSummaries = new List<string>();
+
+                foreach (var f in files)
+                    fileSummaries.Add($"'{f.FileName}' ({f.Length} bytes)");
+
+                entries.Add($"{param.Name}: [Files] count={fileSummaries.Count} [{string.Join(", ", fileSummaries)}]");
+
+                continue;
+            }
+
+            if (arg is Stream stream)
+            {
+                entries.Add($"{param.Name}: [Stream] Length={(stream.CanSeek ? stream.Length : -1)} bytes");
+
+                continue;
+            }
+
+            try
+            {
+                var json = JsonSerializer.Serialize(arg);
+
+                entries.Add($"{param.Name}: {json}");
+            }
+            catch
+            {
+                entries.Add($"{param.Name}: [Unserializable]");
+            }
+        }
+
+        return [.. entries];
+    }
+}

PostFundManagement.Application/Services/Users/UserService.cs

@@ -85,7 +85,7 @@ public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextF
             var user = await context.Users.AsNoTracking()
                 .FirstOrDefaultAsync(f => f.Id == userId, cancellationToken);
 
-            return Result.FailIf(user is null, NotFoundError.New)
-                .ToResult(user!.Map());
+            return Result.FailIf(user == null, NotFoundError.New)
+                .ToResult(user?.Map()!);
         }));
 }

PostFundManagement.Domain/Attributes/LogAttribute.cs

@@ -0,0 +1,4 @@
+namespace PostFundManagement.Domain.Attributes;
+
+[AttributeUsage(AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
+public sealed class LogAttribute : Attribute;

PostFundManagement.Domain/Entities/Award.cs

@@ -41,7 +41,7 @@ public sealed class AwardConfiguration : IEntityTypeConfiguration<Award>
         builder.Property(f => f.Amount).IsRequired().HasPrecision(18, 2);
 
         builder.HasOne(f => f.Tenant)
-            .WithMany()
+            .WithMany(f => f.Awards)
             .HasForeignKey(fk => fk.TenantId)
             .IsRequired()
             .OnDelete(DeleteBehavior.Restrict);

PostFundManagement.Domain/Entities/Portfolio.cs

@@ -32,7 +32,7 @@ public sealed class PortfolioConfiguration : IEntityTypeConfiguration<Portfolio>
         builder.Property(f => f.Description).IsRequired(false).HasMaxLength(TextLength);
 
         builder.HasOne(f => f.Tenant)
-            .WithMany()
+            .WithMany(f => f.Portfolios)
             .HasForeignKey(fk => fk.TenantId)
             .IsRequired()
             .OnDelete(DeleteBehavior.Restrict);

PostFundManagement.Domain/Entities/Programme.cs

@@ -41,7 +41,7 @@ public sealed class ProgrammeConfiguration : IEntityTypeConfiguration<Programme>
             .HasSentinel(ApprovalStatus.Pending);
 
         builder.HasOne(f => f.Tenant)
-            .WithMany()
+            .WithMany(f => f.Programmes)
             .HasForeignKey(fk => fk.TenantId)
             .IsRequired()
             .OnDelete(DeleteBehavior.NoAction);

PostFundManagement.Domain/Entities/Project.cs

@@ -41,7 +41,7 @@ public sealed class ProjectConfiguration : IEntityTypeConfiguration<Project>
             .HasSentinel(ApprovalStatus.Pending);
 
         builder.HasOne(f => f.Tenant)
-            .WithMany()
+            .WithMany(f => f.Projects)
             .HasForeignKey(fk => fk.TenantId)
             .IsRequired()
             .OnDelete(DeleteBehavior.Restrict);

PostFundManagement.Domain/Entities/Tenant.cs

@@ -8,6 +8,14 @@ public class Tenant : Models.Tenant
     public virtual User? Creator { get; set; }
 
     public virtual User? Updator { get; set; }
+
+    public ICollection<Award> Awards { get; set; } = [];
+
+    public ICollection<Project> Projects { get; set; } = [];
+
+    public ICollection<Programme> Programmes { get; set; } = [];
+
+    public ICollection<Portfolio> Portfolios { get; set; } = [];
 }
 
 public sealed class TenantConfiguration : IEntityTypeConfiguration<Tenant>