From 76713d05c1f88e4db13ea5d2d80dd0b573a466b8 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 08:31:46 -0700
Subject: [PATCH 01/61] AB#32307 store AI runtime configuration in database

---
 .../Prompts/AIPromptDto.cs                    |   7 +-
 .../Prompts/AIPromptVersionDto.cs             |  12 +-
 .../Prompts/CreateUpdateAIPromptDto.cs        |  17 +-
 .../Prompts/CreateUpdateAIPromptVersionDto.cs |  30 +-
 .../AI/Runtime/AIPromptTemplateProvider.cs    |  23 +-
 .../AI/Runtime/AIPromptTemplateRenderer.cs    |   5 -
 .../AI/Runtime/AIPromptTemplateSnapshot.cs    |   2 +-
 .../AI/Runtime/AIProviderPayloadValidator.cs  |  19 +
 .../AI/Runtime/OpenAIConfigurationResolver.cs | 302 +++++++++----
 .../AI/Runtime/OpenAIRuntimeService.cs        |  55 ++-
 .../AI/Runtime/OpenAITransportService.cs      |  89 +++-
 .../AIApplicationMapperlyProfile.cs           |  34 +-
 .../DataSeed/AIModelDataSeeder.cs             | 106 +++++
 .../DataSeed/AIOperationDataSeeder.cs         | 199 ++++++++
 .../DataSeed/AIPromptDataSeeder.cs            |  99 +---
 .../Unity.AI.Application/Domain/AIModel.cs    |  24 +
 .../Domain/AIModelSettings.cs                 |   8 +
 .../Domain/AIOperation.cs                     |  36 ++
 .../Unity.AI.Application/Domain/AIPrompt.cs   |  25 +-
 .../Domain/AIPromptVersion.cs                 |  50 --
 .../AIDbContextModelCreatingExtensions.cs     |  78 +++-
 .../Prompts/AIPromptAppService.cs             |  19 +-
 .../Prompts/AIPromptVersionAppService.cs      |  53 ++-
 .../Localization/AI/en.json                   |  12 +-
 .../Pages/Prompts/EditModal.cshtml.cs         |   6 +-
 .../Unity.AI.Web/Pages/Prompts/Index.cshtml   |  48 +-
 .../src/Unity.AI.Web/Pages/Prompts/Index.js   |  85 ++--
 .../Versions/CreateVersionModal.cshtml.cs     |   3 +-
 .../Versions/EditVersionModal.cshtml.cs       |  14 +-
 .../AI/DataSeed/AIModelDataSeederTests.cs     |  72 +++
 .../AI/DataSeed/AIOperationDataSeederTests.cs | 113 +++++
 .../Runtime/AIPromptTemplateProviderTests.cs  |  35 +-
 .../Runtime/AIPromptTemplateRendererTests.cs  |  16 +-
 .../AIProviderPayloadValidatorTests.cs        |  59 +++
 .../OpenAIConfigurationResolverTests.cs       | 426 ++++++++++++------
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   |  65 +++
 36 files changed, 1561 insertions(+), 685 deletions(-)
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModel.cs
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModelSettings.cs
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPromptVersion.cs
 create mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
 create mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
 create mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
index 0bdff63a08..5903cdc248 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
@@ -7,8 +7,9 @@ namespace Unity.AI.Prompts;
 public class AIPromptDto : AuditedEntityDto<Guid>
 {
     public string Name { get; set; } = string.Empty;
-    public string? Description { get; set; }
-    public PromptType Type { get; set; }
+    public int VersionNumber { get; set; }
+    public string SystemPrompt { get; set; } = string.Empty;
+    public string UserPrompt { get; set; } = string.Empty;
+    public string? MetadataJson { get; set; }
     public bool IsActive { get; set; }
-    public List<AIPromptVersionDto> Versions { get; set; } = new();
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
index a9ed4e50a8..f21d2e8d4e 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
@@ -5,16 +5,10 @@ namespace Unity.AI.Prompts;
 
 public class AIPromptVersionDto : AuditedEntityDto<Guid>
 {
-    public Guid PromptId { get; set; }
+    public string Name { get; set; } = string.Empty;
     public int VersionNumber { get; set; }
     public string SystemPrompt { get; set; } = string.Empty;
-    public string UserPromptTemplate { get; set; } = string.Empty;
-    public string? DeveloperNotes { get; set; }
-    public string? TargetModel { get; set; }
-    public string? TargetProvider { get; set; }
-    public double Temperature { get; set; }
-    public int? MaxTokens { get; set; }
-    public bool IsPublished { get; set; }
-    public bool IsDeprecated { get; set; }
+    public string UserPrompt { get; set; } = string.Empty;
     public string? MetadataJson { get; set; }
+    public bool IsActive { get; set; }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
index 6d361fd3ba..37435424f7 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
@@ -10,12 +10,19 @@ public class CreateUpdateAIPromptDto
     [DisplayName("PromptName")]
     public string Name { get; set; } = string.Empty;
 
-    [MaxLength(2000)]
-    [DisplayName("PromptDescription")]
-    public string? Description { get; set; }
+    [DisplayName("VersionNumber")]
+    public int VersionNumber { get; set; }
 
-    [DisplayName("PromptType")]
-    public PromptType Type { get; set; }
+    [Required]
+    [DisplayName("SystemPrompt")]
+    public string SystemPrompt { get; set; } = string.Empty;
+
+    [Required]
+    [DisplayName("UserPrompt")]
+    public string UserPrompt { get; set; } = string.Empty;
+
+    [DisplayName("MetadataJson")]
+    public string? MetadataJson { get; set; }
 
     [DisplayName("PromptIsActive")]
     public bool IsActive { get; set; } = true;
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
index 8e3414943f..9ce8423b96 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
@@ -16,32 +16,12 @@ public class CreateUpdateAIPromptVersionDto
     public string SystemPrompt { get; set; } = string.Empty;
 
     [Required]
-    [DisplayName("UserPromptTemplate")]
-    public string UserPromptTemplate { get; set; } = string.Empty;
-
-    [DisplayName("DeveloperNotes")]
-    public string? DeveloperNotes { get; set; }
-
-    [MaxLength(100)]
-    [DisplayName("TargetModel")]
-    public string? TargetModel { get; set; }
-
-    [MaxLength(100)]
-    [DisplayName("TargetProvider")]
-    public string? TargetProvider { get; set; }
-
-    [DisplayName("Temperature")]
-    public double Temperature { get; set; } = 0.2;
-
-    [DisplayName("MaxTokens")]
-    public int? MaxTokens { get; set; }
-
-    [DisplayName("IsPublished")]
-    public bool IsPublished { get; set; }
-
-    [DisplayName("IsDeprecated")]
-    public bool IsDeprecated { get; set; }
+    [DisplayName("UserPrompt")]
+    public string UserPrompt { get; set; } = string.Empty;
 
     [DisplayName("MetadataJson")]
     public string? MetadataJson { get; set; }
+
+    [DisplayName("PromptIsActive")]
+    public bool IsActive { get; set; } = true;
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
index de92cd64b7..d744c67c6b 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
 
@@ -10,8 +11,7 @@ namespace Unity.AI.Runtime;
 
 public class AIPromptTemplateProvider(
     IRepository<AIPrompt, Guid> promptRepository,
-    IRepository<AIPromptVersion, Guid> promptVersionRepository,
-    ICurrentTenant currentTenant) : IAIPromptTemplateProvider, ITransientDependency
+    IDataFilter<IMultiTenant> multiTenantDataFilter) : IAIPromptTemplateProvider, ITransientDependency
 {
     public async Task<AIPromptTemplateSnapshot> GetRequiredPromptAsync(
         string promptType,
@@ -21,27 +21,20 @@ public async Task<AIPromptTemplateSnapshot> GetRequiredPromptAsync(
         var normalizedPromptVersion = OpenAIPromptRenderer.ResolvePromptVersion(promptVersion);
         var versionNumber = OpenAIPromptRenderer.ResolvePromptVersionNumber(normalizedPromptVersion);
 
-        using (currentTenant.Change(null))
+        using (multiTenantDataFilter.Disable())
         {
-            var prompt = await promptRepository.FindAsync(p => p.Name == promptType);
+            var prompt = await promptRepository.FindAsync(p => p.Name == promptType && p.VersionNumber == versionNumber);
             if (prompt == null || !prompt.IsActive)
-            {
-                throw new InvalidOperationException($"AI prompt '{promptType}' is not configured.");
-            }
-
-            var version = await promptVersionRepository.FindAsync(
-                v => v.PromptId == prompt.Id && v.VersionNumber == versionNumber);
-            if (version == null || !version.IsPublished || version.IsDeprecated)
             {
                 throw new InvalidOperationException(
-                    $"AI prompt version '{normalizedPromptVersion}' for prompt '{promptType}' is not configured.");
+                    $"AI prompt '{promptType}' version '{normalizedPromptVersion}' is not configured.");
             }
 
             return new AIPromptTemplateSnapshot(
                 normalizedPromptVersion,
-                version.SystemPrompt,
-                version.UserPromptTemplate,
-                version.MetadataJson);
+                prompt.SystemPrompt,
+                prompt.UserPrompt,
+                prompt.MetadataJson);
         }
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateRenderer.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateRenderer.cs
index b6fc24cd60..da342fe04e 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateRenderer.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateRenderer.cs
@@ -116,11 +116,6 @@ private static Dictionary<string, string> ExtractMetadataSections(string? metada
                 return new Dictionary<string, string>(StringComparer.Ordinal);
             }
 
-            if (root.TryGetProperty("sections", out var sections) && sections.ValueKind == JsonValueKind.Object)
-            {
-                return ExtractStringProperties(sections);
-            }
-
             return ExtractStringProperties(root);
         }
         catch (JsonException ex)
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateSnapshot.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateSnapshot.cs
index fb60ccdde6..89be54c5bf 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateSnapshot.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateSnapshot.cs
@@ -3,5 +3,5 @@ namespace Unity.AI.Runtime;
 public sealed record AIPromptTemplateSnapshot(
     string PromptVersion,
     string SystemPrompt,
-    string UserPromptTemplate,
+    string UserPrompt,
     string? MetadataJson);
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
index b49d718e15..99ecee6f77 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
@@ -26,6 +26,13 @@ public static AIResponseValidationResult ValidateApplicationAnalysisJson(string
                 return AIResponseValidationResult.Invalid($"Application analysis response is missing or invalid required field '{AIJsonKeys.Decision}' (expected string).");
             }
 
+             var normalizedDecision = (decision.GetString() ?? string.Empty).Trim().ToUpperInvariant();
+             if (normalizedDecision != "PROCEED" && normalizedDecision != "HOLD")
+             {
+                 return AIResponseValidationResult.Invalid(
+                     $"Application analysis response has invalid '{AIJsonKeys.Decision}' value. Expected 'PROCEED' or 'HOLD'.");
+             }
+
             if (!root.TryGetProperty(AIJsonKeys.Errors, out var errors) || errors.ValueKind != JsonValueKind.Array)
             {
                 return AIResponseValidationResult.Invalid($"Application analysis response is missing or invalid required field '{AIJsonKeys.Errors}' (expected array).");
@@ -46,6 +53,18 @@ public static AIResponseValidationResult ValidateApplicationAnalysisJson(string
                 return AIResponseValidationResult.Invalid($"Application analysis response is missing or invalid required field '{AIJsonKeys.Recommendations}' (expected array).");
             }
 
+            var hasAnyFindings =
+                errors.GetArrayLength() > 0
+                || warnings.GetArrayLength() > 0
+                || summaries.GetArrayLength() > 0
+                || recommendations.GetArrayLength() > 0;
+
+            if (!hasAnyFindings)
+            {
+                return AIResponseValidationResult.Invalid(
+                    "Application analysis response did not include any findings. At least one finding is required.");
+            }
+
             return AIResponseValidationResult.Success();
         }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index d608869f30..a1fbefa6dc 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -1,168 +1,262 @@
 using Microsoft.Extensions.Configuration;
 using System;
-using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.AI.Domain;
+using Unity.AI.Operations;
+using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
 
 namespace Unity.AI.Runtime;
 
-public class OpenAIConfigurationResolver(IConfiguration configuration) : ITransientDependency
+public class OpenAIConfigurationResolver(
+    IRepository<AIModel, Guid> modelRepository,
+    IRepository<AIOperation, Guid> operationRepository,
+    IRepository<AIPrompt, Guid> promptRepository,
+    IConfiguration configuration,
+    IDataFilter<IMultiTenant> multiTenantDataFilter) : ITransientDependency
 {
+    private const string DefaultOperationName = "Default";
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNameCaseInsensitive = true
+    };
+
+    private readonly IRepository<AIModel, Guid> _modelRepository = modelRepository;
+    private readonly IRepository<AIOperation, Guid> _operationRepository = operationRepository;
+    private readonly IRepository<AIPrompt, Guid> _promptRepository = promptRepository;
     private readonly IConfiguration _configuration = configuration;
+    private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter = multiTenantDataFilter;
+
+    public string ResolveProviderName() => Required("Azure:Operations:Defaults:Provider");
 
-    public string ResolveProviderName(string? operationName = null)
+    public Task<string> ResolveApiKeyAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        if (!string.IsNullOrWhiteSpace(operationName))
+        var providerName = Required("Azure:Operations:Defaults:Provider");
+        return Task.FromResult(Required($"Azure:{providerName}:ApiKey"));
+    }
+
+    public async Task<OpenAIOperationSettings> ResolveOperationSettingsAsync(
+        string operationName,
+        CancellationToken cancellationToken = default)
+    {
+        var operation = await ResolveOperationAsync(operationName, cancellationToken);
+        if (operation == null)
         {
-            var operationProvider = Optional($"Azure:Operations:{operationName}:Provider");
-            if (operationProvider != null)
-            {
-                return operationProvider;
-            }
+            throw new InvalidOperationException($"AI operation '{operationName}' is not configured.");
         }
 
-        return Required("Azure:Operations:Defaults:Provider");
-    }
+        var model = await _modelRepository.GetAsync(operation.AIModelId, cancellationToken: cancellationToken);
+        if (!model.IsActive)
+        {
+            throw new InvalidOperationException($"AI model '{model.Name}' is inactive.");
+        }
 
-    public string ResolveApiKey(string? operationName = null)
-    {
-        var providerName = ResolveProviderName(operationName);
-        return Required($"Azure:{providerName}:ApiKey");
-    }
+        var modelSettings = ResolveModelSettings(model);
+        var providerName = Required("Azure:Operations:Defaults:Provider");
+        var endpoint = Required($"Azure:{providerName}:Endpoint");
+        var prompt = await LoadPromptAsync(operation.AIPromptId, cancellationToken);
+        if (!prompt.IsActive)
+        {
+            throw new InvalidOperationException($"AI prompt '{prompt.Name}' v{prompt.VersionNumber} is not active.");
+        }
 
-    public OpenAIOperationSettings ResolveOperationSettings(string operationName)
-    {
-        var providerName = ResolveProviderName(operationName);
-        var profileName = ResolveProfileName(operationName);
-        var apiKey = Required($"Azure:{providerName}:ApiKey");
-        var endpoint = ResolveEndpointUri(providerName);
-        var deploymentName = RequiredProfile(providerName, profileName, "DeploymentName");
-        var promptVersion = Optional($"Azure:Operations:{operationName}:PromptVersion")
-            ?? Required("Azure:Operations:Defaults:PromptVersion");
+        if (operation.CompletionTokens <= 0)
+        {
+            throw new InvalidOperationException($"AI operation '{operation.Name}' must define a positive CompletionTokens value.");
+        }
 
+        var apiKey = Required($"Azure:{providerName}:ApiKey");
         return new OpenAIOperationSettings(
             providerName,
-            profileName,
+            model.Name,
             apiKey,
-            endpoint,
-            deploymentName,
-            ResolveMaxOutputTokenCountSupported(operationName),
-            ResolveConfiguredTemperature(operationName),
-            ResolveCompletionTokens(operationName),
-            promptVersion);
+            new Uri(endpoint),
+            Required($"Azure:{providerName}:Profiles:{model.Name}:DeploymentName"),
+            modelSettings.MaxOutputTokenCountSupported,
+            modelSettings.Temperature,
+            operation.CompletionTokens,
+            $"v{prompt.VersionNumber}");
     }
 
-    public double? ResolveConfiguredTemperature(string? operationName = null)
+    public async Task<double?> ResolveConfiguredTemperatureAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        var providerName = ResolveProviderName(operationName);
-        var profileName = ResolveProfileName(operationName);
-        var profileTemperature = OptionalProfile(providerName, profileName, "Temperature");
-        if (profileTemperature != null
-            && double.TryParse(profileTemperature, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedTemperature))
+        var modelConfiguration = await ResolveModelConfigurationAsync(modelName, cancellationToken);
+        if (modelConfiguration != null)
         {
-            return parsedTemperature;
+            return modelConfiguration.Value.Settings.Temperature;
         }
 
-        return null;
+        throw new InvalidOperationException("AI model is not configured.");
     }
 
-    public bool ResolveMaxOutputTokenCountSupported(string? operationName = null)
+    public async Task<bool> ResolveMaxOutputTokenCountSupportedAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        var providerName = ResolveProviderName(operationName);
-        var profileName = ResolveProfileName(operationName);
-        var key = ProfileKey(providerName, profileName, "MaxOutputTokenCountSupported");
-        var configuredValue = Optional(key);
-        if (configuredValue == null)
+        var modelConfiguration = await ResolveModelConfigurationAsync(modelName, cancellationToken);
+        if (modelConfiguration != null)
         {
-            return true;
-        }
+            var providerName = Required("Azure:Operations:Defaults:Provider");
+            var profileName = modelConfiguration.Value.Model.Name;
+            var configuredValue = Optional($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported");
+            if (configuredValue != null)
+            {
+                if (bool.TryParse(configuredValue, out var parsedValue))
+                {
+                    return parsedValue;
+                }
 
-        if (bool.TryParse(configuredValue, out var parsedValue))
-        {
-            return parsedValue;
+                throw new InvalidOperationException($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported is not a valid boolean.");
+            }
+
+            return modelConfiguration.Value.Settings.MaxOutputTokenCountSupported;
         }
 
-        throw new InvalidOperationException($"{key} must be 'true' or 'false'.");
+        throw new InvalidOperationException("AI model is not configured.");
     }
 
-    public int ResolveCompletionTokens(string operationName)
+    public async Task<int> ResolveCompletionTokensAsync(string operationName, CancellationToken cancellationToken = default)
     {
-        var configuredValue = OptionalPositiveInt($"Azure:Operations:{operationName}:MaxCompletionTokens");
-        if (configuredValue is > 0)
+        var operation = await ResolveOperationAsync(operationName, cancellationToken);
+        if (operation == null)
         {
-            return configuredValue.Value;
+            throw new InvalidOperationException($"AI operation '{operationName}' is not configured.");
         }
 
-        var defaultConfiguredValue = OptionalPositiveInt("Azure:Operations:Defaults:MaxCompletionTokens");
-        if (defaultConfiguredValue is > 0)
+        var model = await _modelRepository.GetAsync(operation.AIModelId, cancellationToken: cancellationToken);
+        if (!model.IsActive)
         {
-            return defaultConfiguredValue.Value;
+            throw new InvalidOperationException($"AI model '{model.Name}' is inactive.");
         }
 
-        throw new InvalidOperationException($"AI max completion tokens are not configured for operation '{operationName}'.");
+        if (operation.CompletionTokens <= 0)
+        {
+            throw new InvalidOperationException($"AI operation '{operation.Name}' must define a positive CompletionTokens value.");
+        }
+
+        return operation.CompletionTokens;
     }
 
-    public string ResolvePromptVersion(string operationName)
+    public Task<string> ResolvePromptVersionAsync(string operationName, CancellationToken cancellationToken = default)
     {
-        return Optional($"Azure:Operations:{operationName}:PromptVersion")
-            ?? Required("Azure:Operations:Defaults:PromptVersion");
+        return ResolvePromptVersionAsyncCore(operationName, cancellationToken);
     }
 
-    public Uri ResolveEndpoint(string? operationName = null)
+    public async Task<Uri> ResolveEndpointAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        var providerName = ResolveProviderName(operationName);
-        return ResolveEndpointUri(providerName);
+        var modelConfiguration = await ResolveModelConfigurationAsync(modelName, cancellationToken);
+        if (modelConfiguration != null)
+        {
+            var providerName = Required("Azure:Operations:Defaults:Provider");
+            return new Uri(Required($"Azure:{providerName}:Endpoint"));
+        }
+
+        throw new InvalidOperationException("AI model is not configured.");
     }
 
-    public string ResolveDeploymentName(string? operationName = null)
+    public async Task<string> ResolveDeploymentNameAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        var providerName = ResolveProviderName(operationName);
-        var profileName = ResolveProfileName(operationName);
-        return RequiredProfile(providerName, profileName, "DeploymentName");
+        var modelConfiguration = await ResolveModelConfigurationAsync(modelName, cancellationToken);
+        if (modelConfiguration != null)
+        {
+            var providerName = Required("Azure:Operations:Defaults:Provider");
+            return Required($"Azure:{providerName}:Profiles:{modelConfiguration.Value.Model.Name}:DeploymentName");
+        }
+
+        throw new InvalidOperationException("AI model is not configured.");
     }
 
-    private string ResolveProfileName(string? operationName)
+    public async Task<string> ResolveProfileNameAsync(string? modelName = null, CancellationToken cancellationToken = default)
     {
-        if (!string.IsNullOrWhiteSpace(operationName))
+        var modelConfiguration = await ResolveModelConfigurationAsync(modelName, cancellationToken);
+        if (modelConfiguration != null)
         {
-            var operationProfile = Optional($"Azure:Operations:{operationName}:Profile");
-            if (operationProfile != null)
-            {
-                return operationProfile;
-            }
+            return modelConfiguration.Value.Model.Name;
         }
 
-        return Required("Azure:Operations:Defaults:Profile");
+        throw new InvalidOperationException("AI model is not configured.");
     }
 
-    private string RequiredProfile(string providerName, string profileName, string settingName)
+    private async Task<(AIModel Model, AIModelSettings Settings)?> ResolveModelConfigurationAsync(
+        string? modelName,
+        CancellationToken cancellationToken)
     {
-        var key = ProfileKey(providerName, profileName, settingName);
-        return Required(key);
+        var model = await ResolveModelAsync(modelName, cancellationToken);
+        if (model == null)
+        {
+            return null;
+        }
+
+        var settings = JsonSerializer.Deserialize<AIModelSettings>(model.SettingsJson, JsonOptions);
+        if (settings == null)
+        {
+            throw new InvalidOperationException($"AI model '{model.Name}' has invalid settings JSON.");
+        }
+
+        return (model, settings);
     }
 
-    private string? OptionalProfile(string providerName, string profileName, string settingName)
+    private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
-        return Optional(ProfileKey(providerName, profileName, settingName));
+        var activeOperations = await _operationRepository.GetListAsync(operation => operation.IsActive);
+
+        var specificOperation = activeOperations.FirstOrDefault(operation =>
+            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
+        if (specificOperation != null)
+        {
+            return specificOperation;
+        }
+
+        return activeOperations.FirstOrDefault(operation =>
+            string.Equals(operation.Name, DefaultOperationName, StringComparison.OrdinalIgnoreCase));
     }
 
-    private string Required(string key)
+    private static AIModelSettings ResolveModelSettings(AIModel model)
     {
-        return Optional(key) ?? throw new InvalidOperationException($"{key} is not configured.");
+        var settings = JsonSerializer.Deserialize<AIModelSettings>(model.SettingsJson, JsonOptions);
+        if (settings == null)
+        {
+            throw new InvalidOperationException($"AI model '{model.Name}' has invalid settings JSON.");
+        }
+
+        return settings;
     }
 
-    private Uri ResolveEndpointUri(string providerName)
+    private async Task<AIModel?> ResolveModelAsync(string? modelName, CancellationToken cancellationToken)
     {
-        var key = $"Azure:{providerName}:Endpoint";
-        var endpoint = Required(key);
+        var activeModels = await _modelRepository.GetListAsync(model => model.IsActive);
+        if (activeModels.Count == 0)
+        {
+            return null;
+        }
 
-        try
+        if (!string.IsNullOrWhiteSpace(modelName))
         {
-            return new Uri(endpoint);
+            return activeModels.FirstOrDefault(model =>
+                string.Equals(model.Name, modelName, StringComparison.OrdinalIgnoreCase));
         }
-        catch (UriFormatException ex)
+
+        var configuredDefaultProfile = Optional("Azure:Operations:Defaults:Profile");
+        if (!string.IsNullOrWhiteSpace(configuredDefaultProfile))
         {
-            throw new InvalidOperationException($"{key} must be a valid absolute URI.", ex);
+            var configuredDefaultModel = activeModels.FirstOrDefault(model =>
+                string.Equals(model.Name, configuredDefaultProfile, StringComparison.OrdinalIgnoreCase));
+            if (configuredDefaultModel != null)
+            {
+                return configuredDefaultModel;
+            }
         }
+
+        return activeModels.FirstOrDefault(model =>
+            string.Equals(model.Name, "Default", StringComparison.OrdinalIgnoreCase));
+    }
+
+    private string Required(string key)
+    {
+        return Optional(key) ?? throw new InvalidOperationException($"{key} is not configured.");
     }
 
     private string? Optional(string key)
@@ -171,14 +265,28 @@ private Uri ResolveEndpointUri(string providerName)
         return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
     }
 
-    private int? OptionalPositiveInt(string key)
+    private async Task<string> ResolvePromptVersionAsyncCore(string operationName, CancellationToken cancellationToken)
     {
-        var value = _configuration.GetValue<int?>(key);
-        return value is > 0 ? value : null;
+        var operation = await ResolveOperationAsync(operationName, cancellationToken);
+        if (operation == null)
+        {
+            throw new InvalidOperationException($"AI operation '{operationName}' is not configured.");
+        }
+
+        var prompt = await LoadPromptAsync(operation.AIPromptId, cancellationToken);
+        if (!prompt.IsActive)
+        {
+            throw new InvalidOperationException($"AI prompt '{prompt.Name}' v{prompt.VersionNumber} is not active.");
+        }
+
+        return $"v{prompt.VersionNumber}";
     }
 
-    private static string ProfileKey(string providerName, string profileName, string settingName)
+    private async Task<AIPrompt> LoadPromptAsync(Guid promptId, CancellationToken cancellationToken)
     {
-        return $"Azure:{providerName}:Profiles:{profileName}:{settingName}";
+        using (_multiTenantDataFilter.Disable())
+        {
+            return await _promptRepository.GetAsync(promptId, cancellationToken: cancellationToken);
+        }
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
index d7f6f35e64..9094a14330 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
@@ -42,16 +42,7 @@ public OpenAIRuntimeService(
 
         public Task<bool> IsAvailableAsync()
         {
-            try
-            {
-                _openAIConfigurationResolver.ResolveApiKey();
-                return Task.FromResult(true);
-            }
-            catch (InvalidOperationException ex)
-            {
-                _logger.LogWarning(ex, "AI is unavailable because the OpenAI configuration could not be resolved.");
-                return Task.FromResult(false);
-            }
+            return IsAvailableCoreAsync();
         }
 
         public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(ApplicationAnalysisRequest request, CancellationToken cancellationToken = default)
@@ -59,7 +50,7 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
             try
             {
                 ArgumentNullException.ThrowIfNull(request);
-                var settings = _openAIConfigurationResolver.ResolveOperationSettings(ApplicationAnalysisPromptType);
+                var settings = await _openAIConfigurationResolver.ResolveOperationSettingsAsync(ApplicationAnalysisPromptType, cancellationToken);
                 var promptTemplate = await _promptTemplateProvider.GetRequiredPromptAsync(
                     ApplicationAnalysisPromptType,
                     request.PromptVersion ?? settings.PromptVersion,
@@ -79,7 +70,7 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
                 var attachments = JsonSerializer.Serialize(attachmentsPayload, AIJsonDefaults.Indented);
                 var systemPrompt = promptTemplate.SystemPrompt;
                 var applicationAnalysisContent = AIPromptTemplateRenderer.BuildApplicationAnalysisUserPrompt(
-                    promptTemplate.UserPromptTemplate,
+                    promptTemplate.UserPrompt,
                     schema,
                     data,
                     attachments,
@@ -101,7 +92,21 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
 
                 if (result.Outcome != AIOperationOutcome.Success)
                 {
-                    return new ApplicationAnalysisResponse();
+                    var providerDetails = result.Response?.RawResponse;
+                    if (string.IsNullOrWhiteSpace(providerDetails))
+                    {
+                        providerDetails = result.Response?.Content;
+                    }
+
+                    if (!string.IsNullOrWhiteSpace(providerDetails) && providerDetails.Length > 400)
+                    {
+                        providerDetails = providerDetails[..400];
+                    }
+
+                    throw new InvalidOperationException(
+                        $"Application analysis generation failed with outcome '{result.Outcome}' and failure category '{result.FailureCategory}'. " +
+                        $"HTTP status: {(result.Response?.HttpStatusCode?.ToString() ?? "n/a")}. " +
+                        $"Provider details: {providerDetails ?? "n/a"}");
                 }
 
                 return OpenAIResponseParser.ParseApplicationAnalysisResponse(result.Content);
@@ -113,7 +118,7 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
             catch (Exception ex)
             {
                 _logger.LogError(ex, "Error generating application analysis.");
-                return new ApplicationAnalysisResponse();
+                throw;
             }
         }
 
@@ -125,7 +130,7 @@ public async Task<AttachmentSummaryResponse> GenerateAttachmentSummaryAsync(Atta
 
             try
             {
-                var settings = _openAIConfigurationResolver.ResolveOperationSettings(AttachmentSummaryPromptType);
+                var settings = await _openAIConfigurationResolver.ResolveOperationSettingsAsync(AttachmentSummaryPromptType, cancellationToken);
                 var promptTemplate = await _promptTemplateProvider.GetRequiredPromptAsync(
                     AttachmentSummaryPromptType,
                     request.PromptVersion ?? settings.PromptVersion,
@@ -152,7 +157,7 @@ public async Task<AttachmentSummaryResponse> GenerateAttachmentSummaryAsync(Atta
                 };
                 var attachment = JsonSerializer.Serialize(attachmentPayload, AIJsonDefaults.Indented);
                 var contentToAnalyze = AIPromptTemplateRenderer.BuildAttachmentSummaryUserPrompt(
-                    promptTemplate.UserPromptTemplate,
+                    promptTemplate.UserPrompt,
                     attachment,
                     promptTemplate.MetadataJson);
 
@@ -201,7 +206,7 @@ public async Task<ApplicationScoringResponse> GenerateApplicationScoringAsync(Ap
             ArgumentNullException.ThrowIfNull(request);
             try
             {
-                var settings = _openAIConfigurationResolver.ResolveOperationSettings(ApplicationScoringPromptType);
+                var settings = await _openAIConfigurationResolver.ResolveOperationSettingsAsync(ApplicationScoringPromptType, cancellationToken);
                 var promptTemplate = await _promptTemplateProvider.GetRequiredPromptAsync(
                     ApplicationScoringPromptType,
                     request.PromptVersion ?? settings.PromptVersion,
@@ -228,7 +233,7 @@ public async Task<ApplicationScoringResponse> GenerateApplicationScoringAsync(Ap
                 }
 
                 var applicationScoringContent = AIPromptTemplateRenderer.BuildApplicationScoringUserPrompt(
-                    promptTemplate.UserPromptTemplate,
+                    promptTemplate.UserPrompt,
                     dataJson,
                     attachments,
                     section,
@@ -337,6 +342,20 @@ private async Task<AIOperationResult> GenerateWithRetryAsync(
             return lastResult;
         }
 
+        private async Task<bool> IsAvailableCoreAsync()
+        {
+            try
+            {
+                await _openAIConfigurationResolver.ResolveApiKeyAsync();
+                return true;
+            }
+            catch (InvalidOperationException ex)
+            {
+                _logger.LogWarning(ex, "AI is unavailable because the OpenAI configuration could not be resolved.");
+                return false;
+            }
+        }
+
         private static string ResolveNarrativeContent(AIOperationResult result)
         {
             return result.Outcome switch
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAITransportService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAITransportService.cs
index db1cf6fdd2..769a538af1 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAITransportService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAITransportService.cs
@@ -37,23 +37,16 @@ public async Task<AIOperationResult> GenerateSummaryAsync(
                 ? "You are a professional grant analyst for the BC Government."
                 : systemPrompt;
 
-            var options = new ChatCompletionOptions();
-            if (settings.MaxOutputTokenCountSupported)
+            var messages = new List<ChatMessage>
             {
-                options.MaxOutputTokenCount = maxTokens;
-            }
-
-            if (settings.Temperature.HasValue)
-            {
-                options.Temperature = (float)settings.Temperature.Value;
-            }
-
-            var result = await _chatClientFactory.Create(settings).CompleteChatAsync(
-                [
-                    new SystemChatMessage(resolvedSystemPrompt),
-                    new UserChatMessage(content ?? string.Empty)
-                ],
-                options,
+                new SystemChatMessage(resolvedSystemPrompt),
+                new UserChatMessage(content ?? string.Empty)
+            };
+
+            var result = await CompleteChatWithTemperatureFallbackAsync(
+                settings,
+                messages,
+                maxTokens,
                 cancellationToken);
 
             var completion = result.Value;
@@ -110,6 +103,70 @@ public async Task<AIOperationResult> GenerateSummaryAsync(
         }
     }
 
+    private async Task<ClientResult<ChatCompletion>> CompleteChatWithTemperatureFallbackAsync(
+        OpenAIOperationSettings settings,
+        IReadOnlyList<ChatMessage> messages,
+        int maxTokens,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            return await _chatClientFactory.Create(settings).CompleteChatAsync(
+                messages,
+                BuildOptions(settings, maxTokens, includeTemperature: true),
+                cancellationToken);
+        }
+        catch (ClientResultException ex)
+        {
+            var responseContent = ex.GetRawResponse()?.Content?.ToString() ?? ex.Message;
+            if (!ShouldRetryWithoutTemperature(settings, ex.Status, responseContent))
+            {
+                throw;
+            }
+
+            _logger.LogWarning(
+                ex,
+                "Retrying OpenAI request without temperature after provider rejected the temperature parameter for profile {ProfileName}.",
+                settings.ProfileName);
+
+            return await _chatClientFactory.Create(settings).CompleteChatAsync(
+                messages,
+                BuildOptions(settings, maxTokens, includeTemperature: false),
+                cancellationToken);
+        }
+    }
+
+    private static ChatCompletionOptions BuildOptions(OpenAIOperationSettings settings, int maxTokens, bool includeTemperature)
+    {
+        var options = new ChatCompletionOptions();
+        if (settings.MaxOutputTokenCountSupported)
+        {
+            options.MaxOutputTokenCount = maxTokens;
+        }
+
+        if (includeTemperature && settings.Temperature.HasValue)
+        {
+            options.Temperature = (float)settings.Temperature.Value;
+        }
+
+        return options;
+    }
+
+    private static bool ShouldRetryWithoutTemperature(OpenAIOperationSettings settings, int statusCode, string responseContent)
+    {
+        if (!settings.Temperature.HasValue || statusCode != 400 || string.IsNullOrWhiteSpace(responseContent))
+        {
+            return false;
+        }
+
+        var lowered = responseContent.ToLowerInvariant();
+        return lowered.Contains("temperature")
+            && (lowered.Contains("unsupported")
+                || lowered.Contains("not supported")
+                || lowered.Contains("not allowed")
+                || lowered.Contains("invalid"));
+    }
+
     private static AIOperationResult MapFailureOutcome(HttpStatusCode statusCode, AIProviderResult response)
     {
         var statusCodeValue = (int)statusCode;
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
index 092ea879d1..589ac6aea2 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
@@ -21,7 +21,6 @@ public partial class CreateUpdateAIPromptDtoToAIPromptMapper : MapperBase<Create
     private static AIPrompt CreateAIPrompt() =>
         (AIPrompt)RuntimeHelpers.GetUninitializedObject(typeof(AIPrompt));
 
-    [MapperIgnoreTarget(nameof(AIPrompt.Versions))]
     [MapperIgnoreTarget(nameof(AIPrompt.TenantId))]
     [MapperIgnoreTarget(nameof(AIPrompt.ConcurrencyStamp))]
     [MapperIgnoreTarget(nameof(AIPrompt.CreationTime))]
@@ -30,7 +29,6 @@ private static AIPrompt CreateAIPrompt() =>
     [MapperIgnoreTarget(nameof(AIPrompt.LastModifierId))]
     public override partial AIPrompt Map(CreateUpdateAIPromptDto source);
 
-    [MapperIgnoreTarget(nameof(AIPrompt.Versions))]
     [MapperIgnoreTarget(nameof(AIPrompt.TenantId))]
     [MapperIgnoreTarget(nameof(AIPrompt.ConcurrencyStamp))]
     [MapperIgnoreTarget(nameof(AIPrompt.CreationTime))]
@@ -41,35 +39,9 @@ private static AIPrompt CreateAIPrompt() =>
 }
 
 [Mapper]
-public partial class AIPromptVersionToAIPromptVersionDtoMapper : MapperBase<AIPromptVersion, AIPromptVersionDto>
+public partial class AIPromptToAIPromptVersionDtoMapper : MapperBase<AIPrompt, AIPromptVersionDto>
 {
-    public override partial AIPromptVersionDto Map(AIPromptVersion source);
+    public override partial AIPromptVersionDto Map(AIPrompt source);
 
-    public override partial void Map(AIPromptVersion source, AIPromptVersionDto destination);
-}
-
-[Mapper]
-public partial class CreateUpdateAIPromptVersionDtoToAIPromptVersionMapper : MapperBase<CreateUpdateAIPromptVersionDto, AIPromptVersion>
-{
-    [ObjectFactory]
-    private static AIPromptVersion CreateAIPromptVersion() =>
-        (AIPromptVersion)RuntimeHelpers.GetUninitializedObject(typeof(AIPromptVersion));
-
-    [MapperIgnoreTarget(nameof(AIPromptVersion.Prompt))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.TenantId))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.ConcurrencyStamp))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.CreationTime))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.CreatorId))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.LastModificationTime))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.LastModifierId))]
-    public override partial AIPromptVersion Map(CreateUpdateAIPromptVersionDto source);
-
-    [MapperIgnoreTarget(nameof(AIPromptVersion.Prompt))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.TenantId))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.ConcurrencyStamp))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.CreationTime))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.CreatorId))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.LastModificationTime))]
-    [MapperIgnoreTarget(nameof(AIPromptVersion.LastModifierId))]
-    public override partial void Map(CreateUpdateAIPromptVersionDto source, AIPromptVersion destination);
+    public override partial void Map(AIPrompt source, AIPromptVersionDto destination);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
new file mode 100644
index 0000000000..68cce573ed
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
+using Unity.AI.Domain;
+using Unity.AI.Prompts;
+using Volo.Abp.Data;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Repositories;
+
+namespace Unity.AI.DataSeed;
+
+public class AIModelDataSeeder(
+    IRepository<AIModel, Guid> modelRepository,
+    IConfiguration configuration) : IDataSeedContributor, ITransientDependency
+{
+    public async Task SeedAsync(DataSeedContext context)
+    {
+        if (context.TenantId != null)
+        {
+            return;
+        }
+
+        var providerName = Optional("Azure:Operations:Defaults:Provider");
+        var defaultProfileName = Optional("Azure:Operations:Defaults:Profile");
+        if (providerName == null || defaultProfileName == null)
+        {
+            return;
+        }
+
+        var profilesSection = configuration.GetSection($"Azure:{providerName}:Profiles");
+        var profileNames = profilesSection
+            .GetChildren()
+            .Select(section => section.Key)
+            .Where(name => !string.IsNullOrWhiteSpace(name))
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        if (!profileNames.Contains(defaultProfileName, StringComparer.OrdinalIgnoreCase))
+        {
+            profileNames.Add(defaultProfileName);
+        }
+
+        foreach (var profileName in profileNames)
+        {
+            var deploymentName = Optional($"Azure:{providerName}:Profiles:{profileName}:DeploymentName");
+            if (deploymentName == null)
+            {
+                continue;
+            }
+
+            await EnsureModelAsync(
+                profileName,
+                new AIModelSettings
+                {
+                    MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
+                    Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
+                });
+        }
+
+    }
+
+    private async Task EnsureModelAsync(string modelName, AIModelSettings settings)
+    {
+        var existing = await modelRepository.FirstOrDefaultAsync(model => model.Name == modelName);
+        if (existing != null)
+        {
+            existing.IsActive = true;
+            existing.SettingsJson = JsonSerializer.Serialize(settings);
+            await modelRepository.UpdateAsync(existing);
+            return;
+        }
+
+        await modelRepository.InsertAsync(
+            new AIModel(Guid.CreateVersion7(), modelName)
+            {
+                IsActive = true,
+                SettingsJson = JsonSerializer.Serialize(settings)
+            });
+    }
+
+    private string? Optional(string key)
+    {
+        var value = configuration[key];
+        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+    }
+
+    private bool? OptionalBool(string key)
+    {
+        var value = Optional(key);
+        return value != null && bool.TryParse(value, out var parsedValue)
+            ? parsedValue
+            : null;
+    }
+
+    private double? OptionalDouble(string key)
+    {
+        var value = Optional(key);
+        return value != null && double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedValue)
+            ? parsedValue
+            : null;
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
new file mode 100644
index 0000000000..ed22ba9ca4
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
@@ -0,0 +1,199 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using System.Threading.Tasks;
+using Unity.AI.Domain;
+using Unity.AI.Operations;
+using Unity.AI.Prompts;
+using Volo.Abp.Data;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
+
+namespace Unity.AI.DataSeed;
+
+public class AIOperationDataSeeder(
+    IRepository<AIOperation, Guid> operationRepository,
+    IRepository<AIModel, Guid> modelRepository,
+    IRepository<AIPrompt, Guid> promptRepository,
+    IConfiguration configuration,
+    ICurrentTenant currentTenant,
+    ILogger<AIOperationDataSeeder> logger) : IDataSeedContributor, ITransientDependency
+{
+    private const string DefaultOperationName = "Default";
+    private const string DefaultOperationPromptType = AIPromptTypes.ApplicationAnalysis;
+
+    public async Task SeedAsync(DataSeedContext context)
+    {
+        if (context.TenantId != null)
+        {
+            return;
+        }
+
+        using (currentTenant.Change(null))
+        {
+            var model = await EnsureConfiguredDefaultModelAsync();
+            if (model == null)
+            {
+                logger.LogWarning("AI operation seeding skipped: no model is configured. Check Azure:Operations:Defaults:Provider and Azure:Operations:Defaults:Profile settings.");
+                return;
+            }
+
+            await EnsureOperationAsync(DefaultOperationName, DefaultOperationPromptType, model, isDefaultOperation: true);
+            await EnsureOperationAsync(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, model);
+            await EnsureOperationAsync(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, model);
+            await EnsureOperationAsync(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, model);
+        }
+    }
+
+    private async Task EnsureOperationAsync(
+        string operationName,
+        string promptName,
+        AIModel model,
+        bool isDefaultOperation = false)
+    {
+        var prompt = await ResolveLatestActivePromptAsync(promptName);
+        if (prompt == null)
+        {
+            if (isDefaultOperation)
+            {
+                logger.LogWarning("AI default operation seeding skipped: no active prompt found for '{PromptName}'.", promptName);
+            }
+            else
+            {
+                logger.LogWarning("AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}'.", operationName, promptName);
+            }
+            return;
+        }
+
+        var completionTokens = ResolveCompletionTokens(promptName);
+        if (completionTokens == null)
+        {
+            if (isDefaultOperation)
+            {
+                logger.LogWarning("AI default operation seeding skipped: MaxCompletionTokens not configured for '{PromptName}'.", promptName);
+            }
+            else
+            {
+                logger.LogWarning("AI operation seeding skipped: MaxCompletionTokens not configured for operation '{OperationName}' (prompt '{PromptName}').", operationName, promptName);
+            }
+            return;
+        }
+
+        var existing = await operationRepository.FirstOrDefaultAsync(op => op.Name == operationName);
+        if (existing != null)
+        {
+            existing.AIModelId = model.Id;
+            existing.AIPromptId = prompt.Id;
+            existing.ExecutionMode = AIExecutionMode.Sequential;
+            existing.CompletionTokens = completionTokens.Value;
+            existing.IsActive = true;
+            await operationRepository.UpdateAsync(existing);
+            return;
+        }
+
+        await operationRepository.InsertAsync(
+            new AIOperation(Guid.CreateVersion7(), operationName, model.Id, prompt.Id)
+            {
+                ExecutionMode = AIExecutionMode.Sequential,
+                CompletionTokens = completionTokens.Value,
+                IsActive = true
+            });
+    }
+
+    private async Task<AIModel?> EnsureConfiguredDefaultModelAsync()
+    {
+        var providerName = Optional("Azure:Operations:Defaults:Provider");
+        var profileName = Optional("Azure:Operations:Defaults:Profile");
+        if (providerName == null || profileName == null)
+        {
+            return null;
+        }
+
+        var deploymentName = Optional($"Azure:{providerName}:Profiles:{profileName}:DeploymentName");
+        if (deploymentName == null)
+        {
+            return null;
+        }
+
+        var existing = await modelRepository.FirstOrDefaultAsync(model => model.Name == profileName && model.IsActive);
+        if (existing != null)
+        {
+            existing.SettingsJson = System.Text.Json.JsonSerializer.Serialize(new AIModelSettings
+            {
+                MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
+                Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
+            });
+            await modelRepository.UpdateAsync(existing);
+            return existing;
+        }
+
+        var settings = new AIModelSettings
+        {
+            MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
+            Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
+        };
+
+        var existingInactive = await modelRepository.FirstOrDefaultAsync(model => model.Name == profileName);
+        if (existingInactive != null)
+        {
+            existingInactive.IsActive = true;
+            existingInactive.SettingsJson = System.Text.Json.JsonSerializer.Serialize(settings);
+            return await modelRepository.UpdateAsync(existingInactive);
+        }
+
+        var model = await modelRepository.InsertAsync(
+            new AIModel(Guid.CreateVersion7(), profileName)
+            {
+                IsActive = true,
+                SettingsJson = System.Text.Json.JsonSerializer.Serialize(settings)
+            });
+
+        return model;
+    }
+
+    private async Task<AIPrompt?> ResolveLatestActivePromptAsync(string promptName)
+    {
+        var prompts = await promptRepository.GetListAsync(item => item.Name == promptName && item.IsActive);
+        return prompts
+            .OrderByDescending(prompt => prompt.VersionNumber)
+            .FirstOrDefault();
+    }
+
+    private string? Optional(string key)
+    {
+        var value = configuration[key];
+        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+    }
+
+    private int? OptionalPositiveInt(string key)
+    {
+        var value = configuration.GetValue<int?>(key);
+        return value is > 0 ? value : null;
+    }
+
+    private int? ResolveCompletionTokens(string operationName)
+    {
+        var value = OptionalPositiveInt($"Azure:Operations:{operationName}:MaxCompletionTokens")
+            ?? OptionalPositiveInt("Azure:Operations:Defaults:MaxCompletionTokens");
+        return value;
+    }
+
+    private bool? OptionalBool(string key)
+    {
+        var value = Optional(key);
+        return value != null && bool.TryParse(value, out var parsedValue)
+            ? parsedValue
+            : null;
+    }
+
+    private double? OptionalDouble(string key)
+    {
+        var value = Optional(key);
+        return value != null && double.TryParse(value, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var parsedValue)
+            ? parsedValue
+            : null;
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 52c13be7e3..13e2896aae 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -13,20 +13,12 @@ namespace Unity.AI.DataSeed;
 
 /// <summary>
 /// Seeds the built-in AI prompts (application analysis, attachment summary, application scoring) into the host database.
-/// Each prompt is seeded with two versions — v0 (original single-file prompts) and v1 (modular
-/// prompts with separate rubric, score, output, and rules sections stored in MetadataJson).
-/// The seeder is idempotent: it inserts fixed records when missing and does not overwrite existing records.
+/// Each prompt family is represented as versioned rows in AIPrompts.
 /// </summary>
 public class AIPromptDataSeeder(
     IRepository<AIPrompt, Guid> promptRepository,
-    IRepository<AIPromptVersion, Guid> versionRepository,
     ICurrentTenant currentTenant) : IDataSeedContributor, ITransientDependency
 {
-    // Fixed deterministic GUIDs — never change these; they ensure idempotent re-seeding
-    private static readonly Guid AnalysisPromptId   = new("4a100001-1000-4000-a000-000000000001");
-    private static readonly Guid AttachmentPromptId = new("4a100001-1000-4000-a000-000000000002");
-    private static readonly Guid ScoresheetPromptId = new("4a100001-1000-4000-a000-000000000003");
-
     public async Task SeedAsync(DataSeedContext context)
     {
         if (context.TenantId != null) return; // host database only
@@ -43,24 +35,12 @@ public async Task SeedAsync(DataSeedContext context)
 
     private async Task SeedAnalysisPromptAsync()
     {
+        await EnsurePromptAsync(AIPromptTypes.ApplicationAnalysis, 0, AnalysisSystemV0, AnalysisUserV0);
         await EnsurePromptAsync(
-            AnalysisPromptId,
             AIPromptTypes.ApplicationAnalysis,
-            "Grant application analysis and review");
-
-        await EnsureVersionAsync(
-            AnalysisPromptId,
-            0,
-            AnalysisSystemV0,
-            AnalysisUserV0,
-            "v0 — initial single-file analysis prompt");
-
-        await EnsureVersionAsync(
-            AnalysisPromptId,
             1,
             AnalysisSystemV1,
             AnalysisUserV1,
-            "v1 — modular prompt with separate rubric, score, output, and rules sections",
             BuildSections(
                 rubric: AnalysisRubric,
                 score: AnalysisScore,
@@ -73,24 +53,12 @@ await EnsureVersionAsync(
 
     private async Task SeedAttachmentPromptAsync()
     {
+        await EnsurePromptAsync(AIPromptTypes.AttachmentSummary, 0, AttachmentSystemV0, AttachmentUserV0);
         await EnsurePromptAsync(
-            AttachmentPromptId,
             AIPromptTypes.AttachmentSummary,
-            "Attachment summarization for grant review");
-
-        await EnsureVersionAsync(
-            AttachmentPromptId,
-            0,
-            AttachmentSystemV0,
-            AttachmentUserV0,
-            "v0 — initial single-file attachment prompt");
-
-        await EnsureVersionAsync(
-            AttachmentPromptId,
             1,
             AttachmentSystemV1,
             AttachmentUserV1,
-            "v1 — modular prompt with separate output and rules sections",
             BuildSections(
                 output: AttachmentOutput,
                 rules: AttachmentRules,
@@ -101,24 +69,12 @@ await EnsureVersionAsync(
 
     private async Task SeedScoresheetPromptAsync()
     {
+        await EnsurePromptAsync(AIPromptTypes.ApplicationScoring, 0, ScoresheetSystemV0, ScoresheetUserV0);
         await EnsurePromptAsync(
-            ScoresheetPromptId,
             AIPromptTypes.ApplicationScoring,
-            "Scoresheet section answering assistant");
-
-        await EnsureVersionAsync(
-            ScoresheetPromptId,
-            0,
-            ScoresheetSystemV0,
-            ScoresheetUserV0,
-            "v0 — initial single-file scoresheet prompt");
-
-        await EnsureVersionAsync(
-            ScoresheetPromptId,
             1,
             ScoresheetSystemV1,
             ScoresheetUserV1,
-            "v1 — modular prompt with separate output and rules sections",
             BuildSections(
                 output: ScoresheetOutput,
                 rules: ScoresheetRules,
@@ -137,50 +93,37 @@ private static string BuildSections(
         if (output != null)      dict["OUTPUT"]       = output;
         if (rules != null)       dict["RULES"]        = rules;
         if (commonRules != null) dict["COMMON_RULES"] = commonRules;
-        return JsonSerializer.Serialize(new { sections = dict });
-    }
-
-    private async Task EnsurePromptAsync(Guid promptId, string promptName, string? description)
-    {
-        var prompt = await promptRepository.FirstOrDefaultAsync(p => p.Id == promptId);
-        if (prompt != null)
-        {
-            return;
-        }
-
-        await promptRepository.InsertAsync(new AIPrompt(promptId, promptName, PromptType.Skill)
-        {
-            Description = description,
-            IsActive = true
-        });
+        return JsonSerializer.Serialize(dict);
     }
 
-    private async Task EnsureVersionAsync(
-        Guid promptId,
+    private async Task EnsurePromptAsync(
+        string promptName,
         int versionNumber,
         string systemPrompt,
-        string userPromptTemplate,
-        string developerNotes,
+        string userPrompt,
         string? metadataJson = null)
     {
-        var version = await versionRepository.FirstOrDefaultAsync(
-            v => v.PromptId == promptId && v.VersionNumber == versionNumber);
-        if (version != null)
+        var prompt = await promptRepository.FirstOrDefaultAsync(
+            p => p.Name == promptName && p.VersionNumber == versionNumber);
+        if (prompt != null)
         {
+            prompt.SystemPrompt = systemPrompt;
+            prompt.UserPrompt = userPrompt;
+            prompt.MetadataJson = metadataJson;
+            prompt.IsActive = true;
+            await promptRepository.UpdateAsync(prompt, autoSave: true);
             return;
         }
 
-        await versionRepository.InsertAsync(new AIPromptVersion(
+        await promptRepository.InsertAsync(new AIPrompt(
             Guid.CreateVersion7(),
-            promptId,
+            promptName,
             versionNumber,
             systemPrompt,
-            userPromptTemplate)
+            userPrompt)
         {
-            DeveloperNotes = developerNotes,
-            IsPublished = true,
-            IsDeprecated = false,
-            MetadataJson = metadataJson
+            MetadataJson = metadataJson,
+            IsActive = true
         });
     }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModel.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModel.cs
new file mode 100644
index 0000000000..511ba071ec
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModel.cs
@@ -0,0 +1,24 @@
+using System;
+using Volo.Abp.Domain.Entities.Auditing;
+
+namespace Unity.AI.Domain;
+
+public class AIModel : AuditedAggregateRoot<Guid>
+{
+    public string Name { get; set; } = default!;
+
+    public bool IsActive { get; set; } = true;
+
+    /// <summary>Free-form model settings stored as JSON for dynamic runtime options.</summary>
+    public string SettingsJson { get; set; } = "{}";
+
+    protected AIModel()
+    {
+    }
+
+    public AIModel(Guid id, string name)
+    {
+        Id = id;
+        Name = name;
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModelSettings.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModelSettings.cs
new file mode 100644
index 0000000000..7a9c268eac
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIModelSettings.cs
@@ -0,0 +1,8 @@
+namespace Unity.AI.Domain;
+
+public class AIModelSettings
+{
+    public bool MaxOutputTokenCountSupported { get; set; } = true;
+
+    public double? Temperature { get; set; }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
new file mode 100644
index 0000000000..eee9427cf2
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
@@ -0,0 +1,36 @@
+using System;
+using Unity.AI.Operations;
+using Volo.Abp.Domain.Entities.Auditing;
+
+namespace Unity.AI.Domain;
+
+public class AIOperation : AuditedAggregateRoot<Guid>
+{
+    public string Name { get; set; } = default!;
+
+    public Guid AIModelId { get; set; }
+
+    public AIModel AIModel { get; set; } = default!;
+
+    public Guid AIPromptId { get; set; }
+
+    public AIPrompt AIPrompt { get; set; } = default!;
+
+    public AIExecutionMode ExecutionMode { get; set; } = AIExecutionMode.Sequential;
+
+    public int CompletionTokens { get; set; }
+
+    public bool IsActive { get; set; } = true;
+
+    protected AIOperation()
+    {
+    }
+
+    public AIOperation(Guid id, string name, Guid aiModelId, Guid aiPromptId)
+    {
+        Id = id;
+        Name = name;
+        AIModelId = aiModelId;
+        AIPromptId = aiPromptId;
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
index 8aeb74d3d2..631a400961 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using Volo.Abp.Domain.Entities.Auditing;
 using Volo.Abp.MultiTenancy;
 
@@ -7,25 +6,35 @@ namespace Unity.AI.Domain;
 
 public class AIPrompt : AuditedAggregateRoot<Guid>, IMultiTenant
 {
-    public virtual Guid? TenantId { get; protected set; }
+    public Guid? TenantId { get; protected set; }
 
     public string Name { get; set; } = default!;
 
-    public string? Description { get; set; }
+    public int VersionNumber { get; set; }
 
-    public PromptType Type { get; set; }
+    public string SystemPrompt { get; set; } = default!;
 
-    public bool IsActive { get; set; } = true;
+    public string UserPrompt { get; set; } = default!;
+
+    public string? MetadataJson { get; set; }
 
-    public ICollection<AIPromptVersion> Versions { get; set; } = new List<AIPromptVersion>();
+    public bool IsActive { get; set; } = true;
 
     protected AIPrompt() { }
 
-    public AIPrompt(Guid id, string name, PromptType type, Guid? tenantId = null)
+    public AIPrompt(
+        Guid id,
+        string name,
+        int versionNumber,
+        string systemPrompt,
+        string userPrompt,
+        Guid? tenantId = null)
     {
         Id = id;
         Name = name;
-        Type = type;
+        VersionNumber = versionNumber;
+        SystemPrompt = systemPrompt;
+        UserPrompt = userPrompt;
         TenantId = tenantId;
         IsActive = true;
     }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPromptVersion.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPromptVersion.cs
deleted file mode 100644
index 440aec6e0c..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPromptVersion.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-using System;
-using Volo.Abp.Domain.Entities.Auditing;
-using Volo.Abp.MultiTenancy;
-
-namespace Unity.AI.Domain;
-
-public class AIPromptVersion : AuditedAggregateRoot<Guid>, IMultiTenant
-{
-    public virtual Guid? TenantId { get; protected set; }
-
-    public Guid PromptId { get; set; }
-    public AIPrompt? Prompt { get; set; }
-
-    public int VersionNumber { get; set; }
-
-    public string SystemPrompt { get; set; } = default!;
-    public string UserPromptTemplate { get; set; } = default!;
-    public string? DeveloperNotes { get; set; }
-
-    public string? TargetModel { get; set; }
-    public string? TargetProvider { get; set; }
-
-    public double Temperature { get; set; } = 0.2;
-    public int? MaxTokens { get; set; }
-
-    public bool IsPublished { get; set; }
-    public bool IsDeprecated { get; set; }
-
-    /// <summary>Optional JSON metadata for extensibility (stored as Postgres jsonb).</summary>
-    public string? MetadataJson { get; set; }
-
-    protected AIPromptVersion() { }
-
-    public AIPromptVersion(
-        Guid id,
-        Guid promptId,
-        int versionNumber,
-        string systemPrompt,
-        string userPromptTemplate,
-        Guid? tenantId = null)
-    {
-        Id = id;
-        PromptId = promptId;
-        VersionNumber = versionNumber;
-        SystemPrompt = systemPrompt;
-        UserPromptTemplate = userPromptTemplate;
-        TenantId = tenantId;
-        Temperature = 0.2;
-    }
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
index a23dae6f48..fcddaace58 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
@@ -21,41 +21,81 @@ public static void ConfigureAI(this ModelBuilder modelBuilder)
                 .IsRequired()
                 .HasMaxLength(200);
 
-            b.Property(x => x.Description)
-                .HasMaxLength(2000);
+            b.Property(x => x.VersionNumber)
+                .IsRequired();
+
+            b.Property(x => x.SystemPrompt)
+                .IsRequired()
+                .HasColumnType("text");
+
+            b.Property(x => x.UserPrompt)
+                .IsRequired()
+                .HasColumnType("text");
 
-            b.Property(x => x.Type)
+            b.Property(x => x.MetadataJson)
+                .HasColumnType("jsonb");
+
+            b.Property(x => x.IsActive)
                 .IsRequired();
 
-            b.HasIndex(x => x.Name)
+            b.HasIndex(x => new { x.TenantId, x.Name, x.VersionNumber })
                 .IsUnique();
+        });
+
+        modelBuilder.Entity<AIModel>(b =>
+        {
+            b.ToTable(AIDbProperties.DbTablePrefix + "AIModels", AIDbProperties.DbSchema);
+
+            b.ConfigureByConvention();
+
+            b.Property(x => x.Name)
+                .IsRequired()
+                .HasMaxLength(200);
 
-            b.HasMany(x => x.Versions)
-                .WithOne(x => x.Prompt)
-                .HasForeignKey(x => x.PromptId)
-                .OnDelete(DeleteBehavior.Cascade);
+            b.Property(x => x.IsActive)
+                .IsRequired();
+
+            b.Property(x => x.SettingsJson)
+                .IsRequired()
+                .HasColumnType("jsonb");
+
+            b.HasIndex(x => x.Name)
+                .IsUnique();
         });
 
-        modelBuilder.Entity<AIPromptVersion>(b =>
+        modelBuilder.Entity<AIOperation>(b =>
         {
-            b.ToTable(AIDbProperties.DbTablePrefix + "AIPromptVersions", AIDbProperties.DbSchema);
+            b.ToTable(AIDbProperties.DbTablePrefix + "AIOperations", AIDbProperties.DbSchema);
 
             b.ConfigureByConvention();
 
-            b.Property(x => x.SystemPrompt).IsRequired().HasColumnType("text");
-            b.Property(x => x.UserPromptTemplate).IsRequired().HasColumnType("text");
+            b.Property(x => x.Name)
+                .IsRequired()
+                .HasMaxLength(200);
 
-            b.Property(x => x.TargetModel)
-                .HasMaxLength(100);
+            b.Property(x => x.ExecutionMode)
+                .IsRequired()
+                .HasConversion<string>()
+                .HasMaxLength(20);
 
-            b.Property(x => x.TargetProvider)
-                .HasMaxLength(100);
+            b.Property(x => x.CompletionTokens)
+                .IsRequired();
 
-            b.Property(x => x.MetadataJson)
-                .HasColumnType("jsonb");
+            b.Property(x => x.IsActive)
+                .IsRequired();
 
-            b.HasIndex(x => new { x.PromptId, x.VersionNumber })
+            b.HasIndex(x => x.Name)
                 .IsUnique();
+
+            b.HasOne(x => x.AIModel)
+                .WithMany()
+                .HasForeignKey(x => x.AIModelId)
+                .OnDelete(DeleteBehavior.Restrict);
+
+            b.HasOne(x => x.AIPrompt)
+                .WithMany()
+                .HasForeignKey(x => x.AIPromptId)
+                .OnDelete(DeleteBehavior.Restrict);
         });
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
index e7f11e6c33..9a3f66ec94 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
@@ -4,9 +4,11 @@
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.Modules.Shared.Permissions;
+using Volo.Abp.Data;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
 
 namespace Unity.AI.Prompts;
 
@@ -21,9 +23,14 @@ public class AIPromptAppService :
         CreateUpdateAIPromptDto>,
     IAIPromptAppService
 {
-    public AIPromptAppService(IRepository<AIPrompt, Guid> repository)
+    private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter;
+
+    public AIPromptAppService(
+        IRepository<AIPrompt, Guid> repository,
+        IDataFilter<IMultiTenant> multiTenantDataFilter)
         : base(repository)
     {
+        _multiTenantDataFilter = multiTenantDataFilter;
         GetPolicyName = IdentityConsts.ITOperationsPolicyName;
         GetListPolicyName = IdentityConsts.ITOperationsPolicyName;
         CreatePolicyName = IdentityConsts.ITOperationsPolicyName;
@@ -34,7 +41,7 @@ public AIPromptAppService(IRepository<AIPrompt, Guid> repository)
     [HttpGet("{id}")]
     public override async Task<AIPromptDto> GetAsync(Guid id)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.GetAsync(id);
         }
@@ -43,7 +50,7 @@ public override async Task<AIPromptDto> GetAsync(Guid id)
     [HttpGet]
     public override async Task<PagedResultDto<AIPromptDto>> GetListAsync(PagedAndSortedResultRequestDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.GetListAsync(input);
         }
@@ -52,7 +59,7 @@ public override async Task<PagedResultDto<AIPromptDto>> GetListAsync(PagedAndSor
     [HttpPost]
     public override async Task<AIPromptDto> CreateAsync(CreateUpdateAIPromptDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.CreateAsync(input);
         }
@@ -61,7 +68,7 @@ public override async Task<AIPromptDto> CreateAsync(CreateUpdateAIPromptDto inpu
     [HttpPut("{id}")]
     public override async Task<AIPromptDto> UpdateAsync(Guid id, CreateUpdateAIPromptDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.UpdateAsync(id, input);
         }
@@ -70,7 +77,7 @@ public override async Task<AIPromptDto> UpdateAsync(Guid id, CreateUpdateAIPromp
     [HttpDelete("{id}")]
     public override async Task DeleteAsync(Guid id)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             await base.DeleteAsync(id);
         }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
index ff431bb7c6..7084c9cc10 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
@@ -6,9 +6,11 @@
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.Modules.Shared.Permissions;
+using Volo.Abp.Data;
 using Volo.Abp.Application.Dtos;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
 
 namespace Unity.AI.Prompts;
 
@@ -16,16 +18,21 @@ namespace Unity.AI.Prompts;
 [Route("api/app/ai/prompt-versions")]
 public class AIPromptVersionAppService :
     CrudAppService<
-        AIPromptVersion,
+        AIPrompt,
         AIPromptVersionDto,
         Guid,
         PagedAndSortedResultRequestDto,
         CreateUpdateAIPromptVersionDto>,
     IAIPromptVersionAppService
 {
-    public AIPromptVersionAppService(IRepository<AIPromptVersion, Guid> repository)
+    private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter;
+
+    public AIPromptVersionAppService(
+        IRepository<AIPrompt, Guid> repository,
+        IDataFilter<IMultiTenant> multiTenantDataFilter)
         : base(repository)
     {
+        _multiTenantDataFilter = multiTenantDataFilter;
         GetPolicyName = IdentityConsts.ITOperationsPolicyName;
         GetListPolicyName = IdentityConsts.ITOperationsPolicyName;
         CreatePolicyName = IdentityConsts.ITOperationsPolicyName;
@@ -36,19 +43,20 @@ public AIPromptVersionAppService(IRepository<AIPromptVersion, Guid> repository)
     [HttpGet("by-prompt/{promptId}")]
     public async Task<ListResultDto<AIPromptVersionDto>> GetByPromptAsync(Guid promptId)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
-            var items = await Repository.GetListAsync(v => v.PromptId == promptId);
+            var selected = await Repository.GetAsync(promptId);
+            var items = await Repository.GetListAsync(v => v.TenantId == selected.TenantId && v.Name == selected.Name);
             var sorted = items.OrderBy(v => v.VersionNumber).ToList();
             return new ListResultDto<AIPromptVersionDto>(
-                ObjectMapper.Map<List<AIPromptVersion>, List<AIPromptVersionDto>>(sorted));
+                ObjectMapper.Map<List<AIPrompt>, List<AIPromptVersionDto>>(sorted));
         }
     }
 
     [HttpGet("{id}")]
     public override async Task<AIPromptVersionDto> GetAsync(Guid id)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.GetAsync(id);
         }
@@ -57,7 +65,7 @@ public override async Task<AIPromptVersionDto> GetAsync(Guid id)
     [HttpGet]
     public override async Task<PagedResultDto<AIPromptVersionDto>> GetListAsync(PagedAndSortedResultRequestDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             return await base.GetListAsync(input);
         }
@@ -66,25 +74,46 @@ public override async Task<PagedResultDto<AIPromptVersionDto>> GetListAsync(Page
     [HttpPost]
     public override async Task<AIPromptVersionDto> CreateAsync(CreateUpdateAIPromptVersionDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
-            return await base.CreateAsync(input);
+            var prompt = await Repository.GetAsync(input.PromptId);
+            var entity = await Repository.InsertAsync(
+                new AIPrompt(
+                    Guid.CreateVersion7(),
+                    prompt.Name,
+                    input.VersionNumber,
+                    input.SystemPrompt,
+                    input.UserPrompt)
+                {
+                    TenantId = prompt.TenantId,
+                    MetadataJson = input.MetadataJson,
+                    IsActive = input.IsActive
+                });
+
+            return ObjectMapper.Map<AIPrompt, AIPromptVersionDto>(entity);
         }
     }
 
     [HttpPut("{id}")]
     public override async Task<AIPromptVersionDto> UpdateAsync(Guid id, CreateUpdateAIPromptVersionDto input)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
-            return await base.UpdateAsync(id, input);
+            var entity = await Repository.GetAsync(id);
+            entity.VersionNumber = input.VersionNumber;
+            entity.SystemPrompt = input.SystemPrompt;
+            entity.UserPrompt = input.UserPrompt;
+            entity.MetadataJson = input.MetadataJson;
+            entity.IsActive = input.IsActive;
+            entity = await Repository.UpdateAsync(entity);
+            return ObjectMapper.Map<AIPrompt, AIPromptVersionDto>(entity);
         }
     }
 
     [HttpDelete("{id}")]
     public override async Task DeleteAsync(Guid id)
     {
-        using (CurrentTenant.Change(null))
+        using (_multiTenantDataFilter.Disable())
         {
             await base.DeleteAsync(id);
         }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Domain.Shared/Localization/AI/en.json b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Domain.Shared/Localization/AI/en.json
index aef66e58de..2c12bd19f1 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Domain.Shared/Localization/AI/en.json
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Domain.Shared/Localization/AI/en.json
@@ -34,19 +34,13 @@
     "AIPrompt": "AI Prompt",
     "AIPromptVersion": "Prompt Version",
     "AIPromptVersions": "Prompt Versions",
-    "PromptType": "Type",
     "PromptName": "Name",
-    "PromptDescription": "Description",
     "PromptIsActive": "Active",
     "VersionNumber": "Version Number",
     "SystemPrompt": "System Prompt",
-    "UserPromptTemplate": "User Prompt Template",
-    "DeveloperNotes": "Developer Notes",
-    "TargetModel": "Target Model",
-    "TargetProvider": "Target Provider",
+    "UserPrompt": "User Prompt",
+    "MetadataJson": "Metadata JSON",
     "Temperature": "Temperature",
-    "MaxTokens": "Max Tokens",
-    "IsPublished": "Published",
-    "IsDeprecated": "Deprecated"
+    "MaxTokens": "Max Tokens"
   }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
index 1279b7a691..ea394f2c2a 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
@@ -28,8 +28,10 @@ public async Task OnGetAsync()
         Prompt = new CreateUpdateAIPromptDto
         {
             Name = dto.Name,
-            Description = dto.Description,
-            Type = dto.Type,
+            VersionNumber = dto.VersionNumber,
+            SystemPrompt = dto.SystemPrompt,
+            UserPrompt = dto.UserPrompt,
+            MetadataJson = dto.MetadataJson,
             IsActive = dto.IsActive
         };
     }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.cshtml b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.cshtml
index 0099f5cf0e..1b4d2bddd8 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.cshtml
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.cshtml
@@ -67,36 +67,6 @@
 
                         <div class="row g-3">
 
-                            <div class="col-sm-6">
-                                <label for="versionTargetModel" class="form-label small fw-semibold mb-1">@L["TargetModel"]</label>
-                                <input type="text" id="versionTargetModel" class="form-control form-control-sm" maxlength="100" placeholder="e.g. gpt-4o" />
-                            </div>
-                            <div class="col-sm-6">
-                                <label for="versionTargetProvider" class="form-label small fw-semibold mb-1">@L["TargetProvider"]</label>
-                                <input type="text" id="versionTargetProvider" class="form-control form-control-sm" maxlength="100" placeholder="e.g. openai" />
-                            </div>
-
-                            <div class="col-6 col-sm-3">
-                                <label for="versionTemperature" class="form-label small fw-semibold mb-1">@L["Temperature"]</label>
-                                <input type="number" id="versionTemperature" class="form-control form-control-sm" step="0.05" min="0" max="2" placeholder="0.2" />
-                            </div>
-                            <div class="col-6 col-sm-3">
-                                <label for="versionMaxTokens" class="form-label small fw-semibold mb-1">@L["MaxTokens"]</label>
-                                <input type="number" id="versionMaxTokens" class="form-control form-control-sm" min="1" placeholder="unlimited" />
-                            </div>
-                            <div class="col-6 col-sm-3 d-flex align-items-end pb-1">
-                                <div class="form-check">
-                                    <input type="checkbox" id="versionIsPublished" class="form-check-input" />
-                                    <label class="form-check-label small" for="versionIsPublished">@L["IsPublished"]</label>
-                                </div>
-                            </div>
-                            <div class="col-6 col-sm-3 d-flex align-items-end pb-1">
-                                <div class="form-check">
-                                    <input type="checkbox" id="versionIsDeprecated" class="form-check-input" />
-                                    <label class="form-check-label small" for="versionIsDeprecated">@L["IsDeprecated"]</label>
-                                </div>
-                            </div>
-
                             <div class="col-12">
                                 <label for="versionSystemPrompt" class="form-label small fw-semibold mb-1">@L["SystemPrompt"] <span class="text-danger">*</span></label>
                                 <textarea id="versionSystemPrompt" class="form-control version-textarea version-textarea--code" rows="7" spellcheck="false"></textarea>
@@ -104,26 +74,28 @@
                             </div>
 
                             <div class="col-12">
-                                <label for="versionUserPromptTemplate" class="form-label small fw-semibold mb-1">@L["UserPromptTemplate"] <span class="text-danger">*</span></label>
-                                <textarea id="versionUserPromptTemplate" class="form-control version-textarea version-textarea--code" rows="7" spellcheck="false"></textarea>
-                                <div class="invalid-feedback">User Prompt Template is required.</div>
+                                <label for="versionUserPrompt" class="form-label small fw-semibold mb-1">@L["UserPrompt"] <span class="text-danger">*</span></label>
+                                <textarea id="versionUserPrompt" class="form-control version-textarea version-textarea--code" rows="7" spellcheck="false"></textarea>
+                                <div class="invalid-feedback">User Prompt is required.</div>
                             </div>
 
-                            <div class="col-12">
-                                <label for="versionDeveloperNotes" class="form-label small fw-semibold mb-1">@L["DeveloperNotes"]</label>
-                                <textarea id="versionDeveloperNotes" class="form-control version-textarea" rows="3" spellcheck="false"></textarea>
+                            <div class="col-6 col-sm-3 d-flex align-items-end pb-1">
+                                <div class="form-check">
+                                    <input type="checkbox" id="versionIsActive" class="form-check-input" checked="checked" />
+                                    <label class="form-check-label small" for="versionIsActive">@L["PromptIsActive"]</label>
+                                </div>
                             </div>
 
                             <div class="col-12">
                                 <div class="d-flex align-items-center gap-2 mb-1">
-                                    <label for="versionMetadataJson" class="form-label small fw-semibold mb-0">Metadata JSON</label>
+                                    <label for="versionMetadataJson" class="form-label small fw-semibold mb-0">@L["MetadataJson"]</label>
                                     <span class="badge bg-secondary" style="font-size:0.6rem;">jsonb</span>
                                     <button type="button" id="formatJsonBtn" class="btn btn-link btn-sm p-0 ms-1" title="Format JSON">
                                         <i class="fa fa-indent"></i> Format
                                     </button>
                                     <span id="jsonValidationMsg" class="small text-danger ms-1" style="display:none;"></span>
                                 </div>
-                                <textarea id="versionMetadataJson" class="form-control version-textarea version-textarea--json" rows="10" spellcheck="false" placeholder='{"sections": {...}}'></textarea>
+                                <textarea id="versionMetadataJson" class="form-control version-textarea version-textarea--json" rows="10" spellcheck="false" placeholder='{"RULES": "...", "COMMON_RULES": "..."}'></textarea>
                             </div>
 
                         </div>
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
index 28062f58cf..a60c0d9f87 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
@@ -1,7 +1,7 @@
 $(function () {
     const l = abp.localization.getResource('AI');
 
-    // Prompt-level modals (create / edit prompt metadata only)
+    // Prompt-level modals (create / edit prompt rows)
     let createModal = new abp.ModalManager(abp.appPath + 'Prompts/CreateModal');
     let editModal   = new abp.ModalManager(abp.appPath + 'Prompts/EditModal');
 
@@ -19,27 +19,32 @@ $(function () {
             index: 0
         },
         {
-            title: l('PromptType'),
-            name: 'type',
-            data: 'type',
+            title: l('VersionNumber'),
+            name: 'versionNumber',
+            data: 'versionNumber',
             index: 1,
-            render: (data) => {
-                const types = ['Orchestrator', 'Skill', 'Instruction', 'Agent'];
-                return types[data] ?? data;
-            }
         },
         {
-            title: l('PromptDescription'),
-            name: 'description',
-            data: 'description',
+            title: l('SystemPrompt'),
+            name: 'systemPrompt',
+            data: 'systemPrompt',
             index: 2,
-            defaultContent: ''
+            defaultContent: '',
+            render: (data) => (data ?? '').slice(0, 80)
+        },
+        {
+            title: l('UserPrompt'),
+            name: 'userPrompt',
+            data: 'userPrompt',
+            index: 3,
+            defaultContent: '',
+            render: (data) => (data ?? '').slice(0, 80)
         },
         {
             title: l('PromptIsActive'),
             name: 'isActive',
             data: 'isActive',
-            index: 3,
+            index: 4,
             render: (data) => data
                 ? '<span class="badge bg-success">Active</span>'
                 : '<span class="badge bg-secondary">Inactive</span>'
@@ -50,7 +55,7 @@ $(function () {
             orderable: false,
             className: 'text-center',
             name: 'rowActions',
-            index: 4,
+            index: 5,
             rowAction: {
                 items: [
                     {
@@ -78,7 +83,7 @@ $(function () {
         }
     ];
 
-    const defaultVisibleColumns = ['name', 'type', 'description', 'isActive', 'rowActions'];
+    const defaultVisibleColumns = ['name', 'versionNumber', 'systemPrompt', 'userPrompt', 'isActive', 'rowActions'];
     const dt = $('#AIPromptsTable');
 
     const dataTable = initializeDataTable({
@@ -177,15 +182,9 @@ $(function () {
 
         $('#versionId').val(v.id);
         $('#versionNumber').val(v.versionNumber);
-        $('#versionTargetModel').val(v.targetModel ?? '');
-        $('#versionTargetProvider').val(v.targetProvider ?? '');
-        $('#versionTemperature').val(v.temperature ?? 0.2);
-        $('#versionMaxTokens').val(v.maxTokens ?? '');
-        $('#versionIsPublished').prop('checked', v.isPublished ?? false);
-        $('#versionIsDeprecated').prop('checked', v.isDeprecated ?? false);
         $('#versionSystemPrompt').val(v.systemPrompt ?? '').removeClass('is-invalid');
-        $('#versionUserPromptTemplate').val(v.userPromptTemplate ?? '').removeClass('is-invalid');
-        $('#versionDeveloperNotes').val(v.developerNotes ?? '');
+        $('#versionUserPrompt').val(v.userPrompt ?? '').removeClass('is-invalid');
+        $('#versionIsActive').prop('checked', v.isActive ?? true);
 
         // Pretty-print MetadataJson if valid
         let meta = v.metadataJson ?? '';
@@ -204,15 +203,9 @@ $(function () {
         currentVersionId = null;
 
         $('#versionId').val('');
-        $('#versionTargetModel').val('');
-        $('#versionTargetProvider').val('');
-        $('#versionTemperature').val(0.2);
-        $('#versionMaxTokens').val('');
-        $('#versionIsPublished').prop('checked', false);
-        $('#versionIsDeprecated').prop('checked', false);
         $('#versionSystemPrompt').val('');
-        $('#versionUserPromptTemplate').val('');
-        $('#versionDeveloperNotes').val('');
+        $('#versionUserPrompt').val('');
+        $('#versionIsActive').prop('checked', true);
         $('#versionMetadataJson').val('');
 
         clearJsonError();
@@ -239,8 +232,8 @@ $(function () {
         if (!promptId) return;
 
         // Required-field validation
-        const systemPrompt       = $('#versionSystemPrompt').val().trim();
-        const userPromptTemplate = $('#versionUserPromptTemplate').val().trim();
+        const systemPrompt = $('#versionSystemPrompt').val().trim();
+        const userPrompt   = $('#versionUserPrompt').val().trim();
         let valid = true;
         if (systemPrompt) {
             $('#versionSystemPrompt').removeClass('is-invalid');
@@ -248,14 +241,14 @@ $(function () {
             $('#versionSystemPrompt').addClass('is-invalid');
             valid = false;
         }
-        if (userPromptTemplate) {
-            $('#versionUserPromptTemplate').removeClass('is-invalid');
+        if (userPrompt) {
+            $('#versionUserPrompt').removeClass('is-invalid');
         } else {
-            $('#versionUserPromptTemplate').addClass('is-invalid');
+            $('#versionUserPrompt').addClass('is-invalid');
             valid = false;
         }
         if (!valid) {
-            $('#versionSystemPrompt.is-invalid, #versionUserPromptTemplate.is-invalid')[0]?.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+            $('#versionSystemPrompt.is-invalid, #versionUserPrompt.is-invalid')[0]?.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
             return;
         }
 
@@ -263,18 +256,12 @@ $(function () {
         if (metaRaw && !validateJson(metaRaw)) return;
 
         const dto = {
-            promptId:            promptId,
-            versionNumber:       Number.parseInt($('#versionNumber').val()) || 0,
-            systemPrompt:        systemPrompt,
-            userPromptTemplate:  userPromptTemplate,
-            developerNotes:      $('#versionDeveloperNotes').val() || null,
-            targetModel:         $('#versionTargetModel').val() || null,
-            targetProvider:      $('#versionTargetProvider').val() || null,
-            temperature:         Number.parseFloat($('#versionTemperature').val()) || 0.2,
-            maxTokens:           $('#versionMaxTokens').val() ? Number.parseInt($('#versionMaxTokens').val()) : null,
-            isPublished:         $('#versionIsPublished').is(':checked'),
-            isDeprecated:        $('#versionIsDeprecated').is(':checked'),
-            metadataJson:        metaRaw || null
+            promptId:     promptId,
+            versionNumber: Number.parseInt($('#versionNumber').val()) || 0,
+            systemPrompt:  systemPrompt,
+            userPrompt:    userPrompt,
+            metadataJson:  metaRaw || null,
+            isActive:      $('#versionIsActive').is(':checked')
         };
 
         if (isNewVersion) {
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs
index ba49f50d0a..53b3b0c54f 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs
@@ -22,8 +22,7 @@ public void OnGet(Guid promptId)
     {
         Version = new CreateUpdateAIPromptVersionDto
         {
-            PromptId = promptId,
-            Temperature = 0.2
+            PromptId = promptId
         };
     }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs
index 40390dd976..cf9947f77d 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs
@@ -27,18 +27,12 @@ public async Task OnGetAsync()
         var dto = await _versionAppService.GetAsync(Id);
         Version = new CreateUpdateAIPromptVersionDto
         {
-            PromptId = dto.PromptId,
+            PromptId = dto.Id,
             VersionNumber = dto.VersionNumber,
             SystemPrompt = dto.SystemPrompt,
-            UserPromptTemplate = dto.UserPromptTemplate,
-            DeveloperNotes = dto.DeveloperNotes,
-            TargetModel = dto.TargetModel,
-            TargetProvider = dto.TargetProvider,
-            Temperature = dto.Temperature,
-            MaxTokens = dto.MaxTokens,
-            IsPublished = dto.IsPublished,
-            IsDeprecated = dto.IsDeprecated,
-            MetadataJson = dto.MetadataJson
+            UserPrompt = dto.UserPrompt,
+            MetadataJson = dto.MetadataJson,
+            IsActive = dto.IsActive
         };
     }
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
new file mode 100644
index 0000000000..ae6380b57b
--- /dev/null
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
@@ -0,0 +1,72 @@
+using Microsoft.Extensions.Configuration;
+using NSubstitute;
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Unity.AI.DataSeed;
+using Unity.AI.Domain;
+using Volo.Abp.Data;
+using Volo.Abp.Domain.Repositories;
+using Xunit;
+
+namespace Unity.GrantManager.AI.DataSeed;
+
+public class AIModelDataSeederTests
+{
+    [Fact]
+    public async Task Should_Seed_All_Configured_Profiles()
+    {
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        var insertedModels = new List<AIModel>();
+        modelRepository
+            .FirstOrDefaultAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIModel, bool>>>())
+            .Returns((AIModel?)null);
+        modelRepository
+            .InsertAsync(Arg.Any<AIModel>())
+            .Returns(callInfo =>
+            {
+                var model = callInfo.Arg<AIModel>();
+                insertedModels.Add(model);
+                return Task.FromResult(model);
+            });
+
+        var configuration = BuildConfiguration(new Dictionary<string, string?>
+        {
+            ["Azure:Operations:Defaults:Provider"] = "OpenAI",
+            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
+            ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
+            ["Azure:OpenAI:Profiles:Gpt5Mini:Temperature"] = "0.15",
+            ["Azure:OpenAI:Profiles:Gpt5Nano:DeploymentName"] = "gpt-5-nano",
+            ["Azure:OpenAI:Endpoint"] = "https://example.test"
+        });
+
+        var seeder = new AIModelDataSeeder(modelRepository, configuration);
+
+        await seeder.SeedAsync(new DataSeedContext());
+
+        insertedModels.Count.ShouldBe(2);
+        insertedModels.ShouldContain(model => model.Name == "Gpt5Mini" && model.IsActive);
+        insertedModels.ShouldContain(model => model.Name == "Gpt5Nano" && model.IsActive);
+
+        var gpt5MiniModel = insertedModels.Find(model => model.Name == "Gpt5Mini");
+        gpt5MiniModel.ShouldNotBeNull();
+        DeserializeSettings(gpt5MiniModel.SettingsJson).MaxOutputTokenCountSupported.ShouldBeTrue();
+        DeserializeSettings(gpt5MiniModel.SettingsJson).Temperature.ShouldBe(0.15);
+    }
+
+    private static IConfiguration BuildConfiguration(IReadOnlyDictionary<string, string?> values)
+    {
+        return new ConfigurationBuilder()
+            .AddInMemoryCollection(values)
+            .Build();
+    }
+
+    private static AIModelSettings DeserializeSettings(string settingsJson)
+    {
+        var settings = JsonSerializer.Deserialize<AIModelSettings>(settingsJson);
+        settings.ShouldNotBeNull();
+        return settings;
+    }
+}
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
new file mode 100644
index 0000000000..5cff2c9648
--- /dev/null
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
@@ -0,0 +1,113 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using System.Threading;
+using Unity.AI;
+using Unity.AI.DataSeed;
+using Unity.AI.Domain;
+using Unity.AI.Prompts;
+using Volo.Abp.Data;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
+using Xunit;
+
+namespace Unity.GrantManager.AI.DataSeed;
+
+public class AIOperationDataSeederTests
+{
+    [Fact]
+    public async Task Should_Seed_Configured_Default_Profile_Model_When_Missing()
+    {
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository
+            .GetQueryableAsync()
+            .Returns(Task.FromResult(new List<AIOperation>().AsQueryable()));
+
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        var insertedModels = new List<AIModel>();
+        modelRepository
+            .GetQueryableAsync()
+            .Returns(Task.FromResult(new List<AIModel>().AsQueryable()));
+        modelRepository
+            .InsertAsync(Arg.Any<AIModel>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo =>
+            {
+                var model = callInfo.Arg<AIModel>();
+                insertedModels.Add(model);
+                return Task.FromResult(model);
+            });
+
+        var insertedOperations = new List<AIOperation>();
+        operationRepository
+            .InsertAsync(Arg.Any<AIOperation>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo =>
+            {
+                var operation = callInfo.Arg<AIOperation>();
+                insertedOperations.Add(operation);
+                return Task.FromResult(operation);
+            });
+
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
+        var prompts = new List<AIPrompt>
+        {
+            new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, 1, "system", "user"),
+            new(Guid.NewGuid(), AIPromptTypes.AttachmentSummary, 1, "system", "user"),
+            new(Guid.NewGuid(), AIPromptTypes.ApplicationScoring, 1, "system", "user")
+        };
+        promptRepository
+            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>())
+            .Returns(callInfo =>
+            {
+                var predicate = callInfo.Arg<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>().Compile();
+                return Task.FromResult(prompts.Where(predicate).ToList());
+            });
+
+        var currentTenant = Substitute.For<ICurrentTenant>();
+        var configuration = BuildConfiguration(new Dictionary<string, string?>
+        {
+            ["Azure:Operations:Defaults:Provider"] = "OpenAI",
+            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
+            ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
+            ["Azure:OpenAI:Endpoint"] = "https://example.test",
+            ["Azure:Operations:ApplicationAnalysis:MaxCompletionTokens"] = "4000",
+            ["Azure:Operations:AttachmentSummary:MaxCompletionTokens"] = "2000",
+            ["Azure:Operations:ApplicationScoring:MaxCompletionTokens"] = "8000"
+        });
+
+        var seeder = new AIOperationDataSeeder(
+            operationRepository,
+            modelRepository,
+            promptRepository,
+            configuration,
+            currentTenant,
+            Substitute.For<ILogger<AIOperationDataSeeder>>());
+
+        await seeder.SeedAsync(new DataSeedContext());
+
+        insertedModels.Count.ShouldBe(1);
+        insertedModels[0].Name.ShouldBe("Gpt5Mini");
+        DeserializeSettings(insertedModels[0].SettingsJson).MaxOutputTokenCountSupported.ShouldBeTrue();
+        DeserializeSettings(insertedModels[0].SettingsJson).Temperature.ShouldBeNull();
+
+    }
+
+    private static IConfiguration BuildConfiguration(IReadOnlyDictionary<string, string?> values)
+    {
+        return new ConfigurationBuilder()
+            .AddInMemoryCollection(values)
+            .Build();
+    }
+
+    private static AIModelSettings DeserializeSettings(string settingsJson)
+    {
+        var settings = JsonSerializer.Deserialize<AIModelSettings>(settingsJson);
+        settings.ShouldNotBeNull();
+        return settings;
+    }
+}
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateProviderTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateProviderTests.cs
index 9e96d22241..144f2cde9e 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateProviderTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateProviderTests.cs
@@ -6,6 +6,7 @@
 using Unity.AI.Prompts;
 using Unity.AI.Runtime;
 using Unity.AI;
+using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
 using Xunit;
@@ -17,26 +18,25 @@ public class AIPromptTemplateProviderTests
     [Fact]
     public async Task GetRequiredPromptAsync_Should_Return_Prompt_Definition_From_Database()
     {
-        var prompt = new AIPrompt(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, PromptType.Skill);
-        var version = new AIPromptVersion(
+        var prompt = new AIPrompt(
             Guid.NewGuid(),
-            prompt.Id,
+            AIPromptTypes.ApplicationAnalysis,
             1,
             "SYSTEM",
             "USER")
         {
-            MetadataJson = "{\"sections\":{\"RULES\":\"- rule\"}}",
-            IsPublished = true
+            MetadataJson = "{\"RULES\":\"- rule\"}",
+            IsActive = true
         };
 
-        var provider = CreateProvider(prompt, version);
+        var provider = CreateProvider(prompt);
 
         var snapshot = await provider.GetRequiredPromptAsync(AIPromptTypes.ApplicationAnalysis, "v1");
 
         snapshot.PromptVersion.ShouldBe("v1");
         snapshot.SystemPrompt.ShouldBe("SYSTEM");
-        snapshot.UserPromptTemplate.ShouldBe("USER");
-        snapshot.MetadataJson.ShouldBe("{\"sections\":{\"RULES\":\"- rule\"}}");
+        snapshot.UserPrompt.ShouldBe("USER");
+        snapshot.MetadataJson.ShouldBe("{\"RULES\":\"- rule\"}");
     }
 
     [Fact]
@@ -51,20 +51,19 @@ public async Task GetRequiredPromptAsync_Should_Throw_When_Prompt_Is_Missing()
     }
 
     private static AIPromptTemplateProvider CreateProvider(
-        AIPrompt? prompt = null,
-        AIPromptVersion? version = null)
+        AIPrompt? prompt = null)
     {
         var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
-        var promptVersionRepository = Substitute.For<IRepository<AIPromptVersion, Guid>>();
-        var currentTenant = Substitute.For<ICurrentTenant>();
-        currentTenant.Change(null).Returns(Substitute.For<IDisposable>());
+        var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
+        multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
 
         promptRepository.FindAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>())
-            .Returns(prompt);
+            .Returns(callInfo =>
+            {
+                var predicate = callInfo.Arg<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>();
+                return Task.FromResult(prompt != null && predicate.Compile()(prompt) ? prompt : null);
+            });
 
-        promptVersionRepository.FindAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIPromptVersion, bool>>>())
-            .Returns(version);
-
-        return new AIPromptTemplateProvider(promptRepository, promptVersionRepository, currentTenant);
+        return new AIPromptTemplateProvider(promptRepository, multiTenantDataFilter);
     }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateRendererTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateRendererTests.cs
index 551153abfb..2e24629bed 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateRendererTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIPromptTemplateRendererTests.cs
@@ -27,10 +27,8 @@ public void BuildApplicationAnalysisUserPrompt_Should_Render_Metadata_And_Preser
 
         const string metadataJson = """
             {
-              "sections": {
-                "RULES": "- Use only provided input sections as evidence.",
-                "COMMON_RULES": "- If ATTACHMENTS is empty, use DATA only and do not mention missing attachments unless their absence is material."
-              }
+              "RULES": "- Use only provided input sections as evidence.",
+              "COMMON_RULES": "- If ATTACHMENTS is empty, use DATA only and do not mention missing attachments unless their absence is material."
             }
             """;
 
@@ -79,10 +77,8 @@ public void BuildApplicationScoringUserPrompt_Should_Render_Metadata_Sections()
 
         const string metadataJson = """
             {
-              "sections": {
-                "RULES": "- Use only DATA and ATTACHMENTS as evidence.",
-                "COMMON_RULES": "- Return valid JSON only."
-              }
+              "RULES": "- Use only DATA and ATTACHMENTS as evidence.",
+              "COMMON_RULES": "- Return valid JSON only."
             }
             """;
 
@@ -108,9 +104,7 @@ public void BuildApplicationAnalysisUserPrompt_Should_Map_Output_Metadata_To_Res
 
         const string metadataJson = """
             {
-              "sections": {
-                "OUTPUT": "{ \"decision\": \"PROCEED\" }"
-              }
+              "OUTPUT": "{ \"decision\": \"PROCEED\" }"
             }
             """;
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
index bbaf3981a5..e539c78852 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
@@ -50,6 +50,65 @@ public void ValidateApplicationScoringJson_Should_Return_InvalidOutput_When_Answ
         result.Reason.ShouldContain("q1");
     }
 
+    [Fact]
+    public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_Decision_Is_Not_Proceed_Or_Hold()
+    {
+        var result = AIProviderPayloadValidator.ValidateApplicationAnalysisJson(
+            """
+            {
+              "decision": "unknown",
+              "errors": [],
+              "warnings": [],
+              "summaries": [
+                { "title": "Summary", "detail": "Content" }
+              ],
+              "recommendations": []
+            }
+            """);
+
+        result.IsValid.ShouldBeFalse();
+        result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
+        result.Reason.ShouldContain("Expected 'PROCEED' or 'HOLD'");
+    }
+
+    [Fact]
+    public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_All_Findings_Are_Empty()
+    {
+        var result = AIProviderPayloadValidator.ValidateApplicationAnalysisJson(
+            """
+            {
+              "decision": "PROCEED",
+              "errors": [],
+              "warnings": [],
+              "summaries": [],
+              "recommendations": []
+            }
+            """);
+
+        result.IsValid.ShouldBeFalse();
+        result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
+        result.Reason.ShouldContain("At least one finding is required");
+    }
+
+    [Fact]
+    public void ValidateApplicationAnalysisJson_Should_Return_Success_For_Proceed_With_Findings()
+    {
+        var result = AIProviderPayloadValidator.ValidateApplicationAnalysisJson(
+            """
+            {
+              "decision": "PROCEED",
+              "errors": [],
+              "warnings": [],
+              "summaries": [
+                { "title": "Summary", "detail": "Looks complete." }
+              ],
+              "recommendations": []
+            }
+            """);
+
+        result.IsValid.ShouldBeTrue();
+    }
+
     [Fact]
     public void ValidateAttachmentSummaryText_Should_Return_InvalidOutput_For_Empty_Text()
     {
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index 2c62d8dc35..e81d02f899 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -1,8 +1,20 @@
 using Microsoft.Extensions.Configuration;
+using NSubstitute;
 using Shouldly;
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Unity.AI.Domain;
+using Unity.AI.Operations;
+using Unity.AI.Prompts;
 using Unity.AI.Runtime;
+using Volo.Abp.Data;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Runtime;
@@ -10,212 +22,330 @@ namespace Unity.GrantManager.AI.Runtime;
 public class OpenAIConfigurationResolverTests
 {
     [Fact]
-    public void ResolveProviderName_Should_Throw_When_DefaultProvider_Is_Missing()
+    public async Task Should_Throw_When_Operation_Is_Missing()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>())
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var resolver = CreateResolver();
 
-        var ex = Should.Throw<InvalidOperationException>(() => resolver.ResolveProviderName());
-        ex.Message.ShouldContain("Azure:Operations:Defaults:Provider");
+        var ex = await Should.ThrowAsync<InvalidOperationException>(() => resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
+        ex.Message.ShouldContain("AI operation");
     }
 
     [Fact]
-    public void ResolveCompletionTokens_Should_Throw_When_Operation_And_Default_Are_Missing()
+    public async Task Should_Resolve_Operation_Strictly_From_Database()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>())
-            .Build();
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var modelId = Guid.NewGuid();
+        var promptId = Guid.NewGuid();
 
-        var ex = Should.Throw<InvalidOperationException>(() => resolver.ResolveCompletionTokens("ApplicationAnalysis"));
-        ex.Message.ShouldContain("ApplicationAnalysis");
-    }
-
-    [Fact]
-    public void ResolvePromptVersion_Should_Use_Operation_Override_Before_Default()
-    {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+        modelRepository
+            .GetAsync(modelId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(new AIModel(modelId, "Gpt5Mini")
             {
-                ["Azure:Operations:Defaults:PromptVersion"] = "v0",
-                ["Azure:Operations:ApplicationAnalysis:PromptVersion"] = "v1"
-            })
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
+                IsActive = true,
+                SettingsJson = JsonSerializer.Serialize(new AIModelSettings
+                {
+                    MaxOutputTokenCountSupported = true,
+                    Temperature = 0.25
+                })
+            });
+
+        operationRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
+            {
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
+                {
+                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                    {
+                        ExecutionMode = AIExecutionMode.Sequential,
+                        CompletionTokens = 2222,
+                        IsActive = true
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
+
+        promptRepository
+            .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
+            {
+                IsActive = true
+            }));
 
-        resolver.ResolvePromptVersion("ApplicationAnalysis").ShouldBe("v1");
+        var resolver = CreateResolver(
+            new Dictionary<string, string?>
+            {
+                ["Azure:OpenAI:ApiKey"] = "secret",
+                ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini"
+            },
+            modelRepository,
+            operationRepository,
+            promptRepository);
+
+        var settings = await resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis);
+
+        settings.ProviderName.ShouldBe("OpenAI");
+        settings.ProfileName.ShouldBe("Gpt5Mini");
+        settings.Endpoint.ShouldBe(new Uri("https://example.test"));
+        settings.DeploymentName.ShouldBe("gpt-5-mini");
+        settings.Temperature.ShouldBe(0.25);
+        settings.CompletionTokens.ShouldBe(2222);
+        settings.PromptVersion.ShouldBe("v1");
     }
 
     [Fact]
-    public void ResolvePromptVersion_Should_Throw_When_Default_Is_Missing()
+    public async Task Should_Fallback_To_Default_Operation_When_Override_Is_Missing()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>())
-            .Build();
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var modelId = Guid.NewGuid();
+        var promptId = Guid.NewGuid();
 
-        var ex = Should.Throw<InvalidOperationException>(() => resolver.ResolvePromptVersion("ApplicationAnalysis"));
-        ex.Message.ShouldContain("Azure:Operations:Defaults:PromptVersion");
-    }
-
-    [Fact]
-    public void ResolveApiKey_Should_Throw_When_Configured_Key_Is_Missing()
-    {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+        modelRepository
+            .GetAsync(modelId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(new AIModel(modelId, "Gpt5Mini")
             {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI"
-            })
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
-
-        var ex = Should.Throw<InvalidOperationException>(() => resolver.ResolveApiKey());
-        ex.Message.ShouldContain("Azure:OpenAI:ApiKey");
-    }
-
-    [Fact]
-    public void ResolveEndpoint_Should_Return_Configured_Provider_Endpoint()
-    {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+                IsActive = true,
+                SettingsJson = JsonSerializer.Serialize(new AIModelSettings
+                {
+                    Temperature = 0.2
+                })
+            });
+
+        operationRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
             {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-                ["Azure:OpenAI:Endpoint"] = "https://example.test"
-            })
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
-
-        resolver.ResolveEndpoint().ShouldBe(new Uri("https://example.test"));
-    }
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
+                {
+                    new(Guid.NewGuid(), "Default", modelId, promptId)
+                    {
+                        ExecutionMode = AIExecutionMode.Sequential,
+                        CompletionTokens = 2000,
+                        IsActive = true
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
+
+        promptRepository
+            .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
+            {
+                IsActive = true
+            }));
 
-    [Fact]
-    public void ResolveDeploymentName_Should_Return_Profile_DeploymentName()
-    {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+        var resolver = CreateResolver(
+            new Dictionary<string, string?>
             {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-                ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
+                ["Azure:OpenAI:ApiKey"] = "secret",
                 ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini"
-            })
-            .Build();
+            },
+            modelRepository,
+            operationRepository,
+            promptRepository);
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var settings = await resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis);
 
-        resolver.ResolveDeploymentName().ShouldBe("gpt-5-mini");
+        settings.ProviderName.ShouldBe("OpenAI");
+        settings.PromptVersion.ShouldBe("v1");
+        settings.CompletionTokens.ShouldBe(2000);
     }
 
     [Fact]
-    public void ResolveDeploymentName_Should_Use_Operation_Profile_Override()
+    public async Task Should_Resolve_Model_Values_Strictly_From_Database()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
-            {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-                ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
-                ["Azure:Operations:ApplicationAnalysis:Profile"] = "Gpt4oMini",
-                ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
-                ["Azure:OpenAI:Profiles:Gpt4oMini:DeploymentName"] = "gpt-4o-mini"
-            })
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
-
-        resolver.ResolveDeploymentName("ApplicationAnalysis").ShouldBe("gpt-4o-mini");
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        modelRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIModel, bool>>>())
+            .Returns(callInfo =>
+            {
+                var predicate = callInfo.Arg<Expression<Func<AIModel, bool>>>();
+                return Task.FromResult(new List<AIModel>
+                {
+                    new(Guid.NewGuid(), "Gpt5Mini")
+                    {
+                        IsActive = true,
+                        SettingsJson = JsonSerializer.Serialize(new AIModelSettings
+                        {
+                            MaxOutputTokenCountSupported = true,
+                            Temperature = 0.35
+                        })
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
+
+        var resolver = CreateResolver(modelRepository: modelRepository);
+
+        resolver.ResolveProviderName().ShouldBe("OpenAI");
+        (await resolver.ResolveDeploymentNameAsync()).ShouldBe("gpt-5-mini");
+        (await resolver.ResolveEndpointAsync()).ShouldBe(new Uri("https://example.test"));
+        (await resolver.ResolveConfiguredTemperatureAsync()).ShouldBe(0.35);
+        (await resolver.ResolveMaxOutputTokenCountSupportedAsync()).ShouldBeTrue();
     }
 
     [Fact]
-    public void ResolveDeploymentName_Should_Throw_When_Profile_DeploymentName_Is_Missing()
+    public async Task Should_Resolve_ApiKey_From_Provider_Secret()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        modelRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIModel, bool>>>())
+            .Returns(callInfo =>
             {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-                ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini"
-            })
-            .Build();
-
-        var resolver = new OpenAIConfigurationResolver(configuration);
+                var predicate = callInfo.Arg<Expression<Func<AIModel, bool>>>();
+                return Task.FromResult(new List<AIModel>
+                {
+                    new(Guid.NewGuid(), "Default")
+                    {
+                        IsActive = true,
+                        SettingsJson = JsonSerializer.Serialize(new AIModelSettings
+                        {
+                            MaxOutputTokenCountSupported = true
+                        })
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
+
+        var resolver = CreateResolver(
+            new Dictionary<string, string?>
+            {
+                ["Azure:OpenAI:ApiKey"] = "secret"
+            },
+            modelRepository);
 
-        var ex = Should.Throw<InvalidOperationException>(() => resolver.ResolveDeploymentName());
-        ex.Message.ShouldContain("Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName");
+        (await resolver.ResolveApiKeyAsync()).ShouldBe("secret");
     }
 
     [Fact]
-    public void ResolveConfiguredTemperature_Should_Return_Profile_Temperature()
+    public async Task Should_Resolve_Operation_Settings_From_Host_Context()
     {
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(new Dictionary<string, string?>
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
+        var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
+        multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
+
+        var modelId = Guid.NewGuid();
+        var promptId = Guid.NewGuid();
+
+        modelRepository
+            .GetAsync(modelId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(new AIModel(modelId, "Gpt5Mini")
             {
-                ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-                ["Azure:Operations:Defaults:Profile"] = "Gpt4oMini",
-                ["Azure:OpenAI:Profiles:Gpt4oMini:Temperature"] = "0.3"
-            })
-            .Build();
+                IsActive = true,
+                SettingsJson = JsonSerializer.Serialize(new AIModelSettings
+                {
+                    Temperature = 0.1
+                })
+            });
+
+        operationRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
+            {
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
+                {
+                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                    {
+                        IsActive = true,
+                        CompletionTokens = 2000
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
+
+        promptRepository
+            .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
+            {
+                IsActive = true
+            }));
+
+        var resolver = CreateResolver(
+            new Dictionary<string, string?>
+            {
+                ["Azure:OpenAI:ApiKey"] = "secret"
+            },
+            modelRepository,
+            operationRepository,
+            promptRepository,
+            multiTenantDataFilter);
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var settings = await resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis);
 
-        resolver.ResolveConfiguredTemperature().ShouldBe(0.3);
+        settings.PromptVersion.ShouldBe("v1");
+        multiTenantDataFilter.Received().Disable();
     }
 
-    [Theory]
-    [InlineData(null)]
-    [InlineData("not-a-number")]
-    public void ResolveConfiguredTemperature_Should_Return_Null_When_Profile_Temperature_Is_Missing_Or_Invalid(string? temperature)
+    private static OpenAIConfigurationResolver CreateResolver(
+        IReadOnlyDictionary<string, string?>? values = null,
+        IRepository<AIModel, Guid>? modelRepository = null,
+        IRepository<AIOperation, Guid>? operationRepository = null,
+        IRepository<AIPrompt, Guid>? promptRepository = null,
+        IDataFilter<IMultiTenant>? multiTenantDataFilter = null)
     {
-        var values = new Dictionary<string, string?>
+        var configurationValues = new Dictionary<string, string?>
         {
             ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-            ["Azure:Operations:Defaults:Profile"] = "Gpt4oMini"
+            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
+            ["Azure:OpenAI:Endpoint"] = "https://example.test",
+            ["Azure:OpenAI:ApiKey"] = "secret",
+            ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
+            ["Azure:OpenAI:Profiles:Gpt5Mini:MaxOutputTokenCountSupported"] = "true"
         };
 
-        if (temperature != null)
+        if (values != null)
         {
-            values["Azure:OpenAI:Profiles:Gpt4oMini:Temperature"] = temperature;
+            foreach (var pair in values)
+            {
+                configurationValues[pair.Key] = pair.Value;
+            }
         }
 
         var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(values)
+            .AddInMemoryCollection(configurationValues)
             .Build();
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+        var filter = multiTenantDataFilter ?? Substitute.For<IDataFilter<IMultiTenant>>();
+        filter.Disable().Returns(Substitute.For<IDisposable>());
 
-        resolver.ResolveConfiguredTemperature().ShouldBeNull();
+        return new OpenAIConfigurationResolver(
+            modelRepository ?? CreateEmptyModelRepository(),
+            operationRepository ?? CreateEmptyOperationRepository(),
+            promptRepository ?? CreateEmptyPromptRepository(),
+            configuration,
+            filter);
     }
 
-    [Theory]
-    [InlineData(null, true)]
-    [InlineData("true", true)]
-    [InlineData("false", false)]
-    public void ResolveMaxOutputTokenCountSupported_Should_Use_Profile_Setting_Or_Default_True(
-        string? configuredValue,
-        bool expected)
+    private static IRepository<AIModel, Guid> CreateEmptyModelRepository()
     {
-        var values = new Dictionary<string, string?>
-        {
-            ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini"
-        };
-
-        if (configuredValue != null)
-        {
-            values["Azure:OpenAI:Profiles:Gpt5Mini:MaxOutputTokenCountSupported"] = configuredValue;
-        }
-
-        var configuration = new ConfigurationBuilder()
-            .AddInMemoryCollection(values)
-            .Build();
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        modelRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIModel, bool>>>())
+            .Returns(Task.FromResult(new List<AIModel>()));
+        return modelRepository;
+    }
 
-        var resolver = new OpenAIConfigurationResolver(configuration);
+    private static IRepository<AIOperation, Guid> CreateEmptyOperationRepository()
+    {
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(Task.FromResult(new List<AIOperation>()));
+        return operationRepository;
+    }
 
-        resolver.ResolveMaxOutputTokenCountSupported().ShouldBe(expected);
+    private static IRepository<AIPrompt, Guid> CreateEmptyPromptRepository()
+    {
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
+        promptRepository
+            .GetAsync(Arg.Any<Guid>(), cancellationToken: Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(new AIPrompt(callInfo.Arg<Guid>(), "Default", 1, "system", "user")));
+        return promptRepository;
     }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
new file mode 100644
index 0000000000..8c48f3985e
--- /dev/null
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -0,0 +1,65 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Unity.AI.Domain;
+using Unity.AI.Operations;
+using Unity.AI.Requests;
+using Unity.AI.Runtime;
+using Volo.Abp.Data;
+using Volo.Abp.Domain.Repositories;
+using Volo.Abp.MultiTenancy;
+using Xunit;
+
+namespace Unity.GrantManager.AI.Runtime;
+
+public class OpenAIRuntimeServiceTests
+{
+    [Fact]
+    public async Task Should_Throw_When_Analysis_Operation_Is_Not_Configured()
+    {
+        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
+        modelRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIModel, bool>>>())
+            .Returns(new List<AIModel>());
+
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(new List<AIOperation>());
+
+        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
+        var configuration = new ConfigurationBuilder().Build();
+        var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
+        multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
+
+        var resolver = new OpenAIConfigurationResolver(
+            modelRepository,
+            operationRepository,
+            promptRepository,
+            configuration,
+            multiTenantDataFilter);
+
+        var logger = Substitute.For<ILogger<OpenAIRuntimeService>>();
+        var runtimeService = new OpenAIRuntimeService(
+            logger,
+            null!,
+            resolver,
+            null!,
+            null!);
+
+        var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
+            runtimeService.GenerateApplicationAnalysisAsync(new ApplicationAnalysisRequest
+            {
+                Schema = JsonSerializer.SerializeToElement(new { project = "x" }),
+                Data = JsonSerializer.SerializeToElement(new { project = "x" })
+            }));
+
+        ex.Message.ShouldContain("AI operation");
+    }
+}

From a8baa4a3aa26d7bff40048363701e55242be7056 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 08:31:59 -0700
Subject: [PATCH 02/61] AB#32307 wire AI generation request plumbing

---
 .../AIGenerationRequestDto.cs                 |  1 +
 .../AIGenerationStatusAppService.cs           | 33 ++++++-
 .../ApplicationAIGenerationQueue.cs           | 28 +++++-
 .../RunApplicationAIPipelineJob.cs            | 12 ++-
 .../GrantApplicationAppService.cs             | 74 ++++++++++------
 .../GrantManagerApplicationMapperlyProfile.cs |  1 -
 .../AIGenerationRequestKeyHelper.cs           | 16 ++++
 .../GrantApplications/AIGenerationRequest.cs  |  6 +-
 .../Automation/AIGenerationQueueTests.cs      | 64 ++++++++++----
 .../AIGenerationStatusAppServiceTests.cs      | 88 ++++++++++++++++++-
 .../RunApplicationAIPipelineJobTests.cs       |  2 +-
 ...GrantApplicationAIGenerationStatusTests.cs | 45 +++++++++-
 12 files changed, 308 insertions(+), 62 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
index 0dfccaa949..6a5f5b7f66 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
@@ -6,6 +6,7 @@ namespace Unity.GrantManager.GrantApplications;
 public class AIGenerationRequestDto : EntityDto<Guid>
 {
     public Guid? ApplicationId { get; set; }
+    public Guid OperationId { get; set; }
     public string OperationType { get; set; } = string.Empty;
     public string RequestKey { get; set; } = string.Empty;
     public AIGenerationRequestStatus Status { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index e887a1fc8a..92b930052c 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Application.Services;
 using Volo.Abp.Domain.Repositories;
@@ -10,18 +11,32 @@ namespace Unity.GrantManager.GrantApplications;
 
 public class AIGenerationStatusAppService(
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
+    IRepository<AIOperation, Guid> operationRepository,
     ICurrentTenant currentTenant)
     : ApplicationService, IAIGenerationStatusAppService
 {
     public virtual async Task<AIGenerationRequestDto?> GetLatestAsync(Guid applicationId, string operationType, Guid? tenantId = null)
     {
+        var operationName = AIGenerationRequestKeyHelper.ResolveOperationName(operationType);
+
+        if (operationName == null)
+        {
+            return null;
+        }
+
+        var operation = await ResolveOperationAsync(operationName);
+        if (operation == null)
+        {
+            return null;
+        }
+
         var query = await generationRequestRepository.GetQueryableAsync();
         var resolvedTenantId = tenantId ?? currentTenant.Id;
 
         var item = query
             .Where(x =>
                 x.ApplicationId == applicationId &&
-                x.OperationType == operationType &&
+                x.OperationId == operation.Id &&
                 x.TenantId == resolvedTenantId)
             .OrderByDescending(x => x.CreationTime)
             .ThenByDescending(x => x.Id)
@@ -33,7 +48,8 @@ public class AIGenerationStatusAppService(
             {
                 Id = item.Id,
                 ApplicationId = item.ApplicationId,
-                OperationType = item.OperationType,
+                OperationId = item.OperationId,
+                OperationType = operationType,
                 RequestKey = item.RequestKey,
                 Status = item.Status,
                 StartedAt = item.StartedAt,
@@ -42,4 +58,17 @@ public class AIGenerationStatusAppService(
                 IsActive = item.IsActive
             };
     }
+
+    private async Task<AIOperation?> ResolveOperationAsync(string operationName)
+    {
+        var operations = await operationRepository.GetQueryableAsync();
+        var activeOperations = operations
+            .Where(operation => operation.IsActive)
+            .ToList();
+
+        return activeOperations.FirstOrDefault(operation =>
+                   string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
+               ?? activeOperations.FirstOrDefault(operation =>
+                   string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
+    }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index c2aa5f6a2c..d564ccba88 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Automation;
 using Unity.AI.Features;
 using Unity.AI.Localization;
@@ -24,6 +25,7 @@ namespace Unity.GrantManager.GrantApplications.Automation;
 public class ApplicationAIGenerationQueue(
     IBackgroundJobManager backgroundJobManager,
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
+    IRepository<AIOperation, Guid> operationRepository,
     IDistributedLockProvider distributedLockProvider,
     IAIGenerationPrerequisiteValidator aiGenerationPrerequisiteValidator,
     IFeatureChecker featureChecker,
@@ -155,10 +157,12 @@ private async Task EnsureRequestAndEnqueueAsync(
             // The limiter is a no-op for system/background callers without an authenticated user.
             await aiRateLimiter.EnsureAsync();
 
+            var operation = await ResolveOperationAsync(operationType);
+
             var request = new AIGenerationRequest(
                 Guid.NewGuid(),
                 tenantId,
-                operationType,
+                operation.Id,
                 applicationId,
                 requestKey);
 
@@ -176,6 +180,28 @@ private async Task EnsureRequestAndEnqueueAsync(
         }
     }
 
+    private static string ResolveOperationName(string operationType)
+        => AIGenerationRequestKeyHelper.ResolveOperationName(operationType)
+            ?? throw new UserFriendlyException($"AI operation '{operationType}' is not configured.");
+
+    private async Task<AIOperation> ResolveOperationAsync(string operationType)
+    {
+        var operationName = ResolveOperationName(operationType);
+        var activeOperations = await operationRepository.GetListAsync(operation => operation.IsActive);
+
+        var operation = activeOperations.FirstOrDefault(operation =>
+            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
+            ?? activeOperations.FirstOrDefault(operation =>
+                string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
+
+        if (operation == null)
+        {
+            throw new UserFriendlyException($"AI operation '{operationType}' is not configured.");
+        }
+
+        return operation;
+    }
+
     private async Task EnsureAnyPipelineStageAvailableAsync(Guid applicationId)
     {
         var hasEnabledStage = false;
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
index 8dec6009b1..3c76f230da 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
@@ -140,9 +140,12 @@ await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
                     }
                 }
 
-                if (scoringException != null)
+                if (analysisException != null && scoringException != null)
                 {
-                    throw scoringException;
+                    throw new AggregateException(
+                        $"AI pipeline failed for application {args.ApplicationId} in multiple stages.",
+                        analysisException,
+                        scoringException);
                 }
 
                 if (analysisException != null)
@@ -150,6 +153,11 @@ await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
                     throw analysisException;
                 }
 
+                if (scoringException != null)
+                {
+                    throw scoringException;
+                }
+
                 await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
                 await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
             }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 469414348b..b980b8bef0 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1187,13 +1187,17 @@ public async Task<AIGenerationStatusDto> QueueApplicationAnalysisAsync(Guid appl
         await EnsureAIAnalysisEnabledAsync();
         await aiGenerationQueue.QueueApplicationAnalysisAsync(applicationId, CurrentTenant.Id, promptVersion);
 
-        var request = await aiGenerationStatusAppService.GetLatestAsync(
-            applicationId,
-            AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
-            CurrentTenant.Id);
-
-        return await CreateGenerationStatusAsync(
-            request ?? throw new UserFriendlyException("Unable to queue AI analysis request."));
+        var request = await aiGenerationStatusAppService.GetLatestAsync(
+            applicationId,
+            AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
+            CurrentTenant.Id);
+
+        if (request == null)
+        {
+            throw new UserFriendlyException("Unable to queue AI analysis request.");
+        }
+
+        return await CreateGenerationStatusAsync(request);
     }
 
     [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
@@ -1203,13 +1207,17 @@ public async Task<AIGenerationStatusDto> QueueAttachmentSummaryAsync(QueueAttach
         var attachmentIds = await ResolveAttachmentSummaryIdsAsync(input);
         await aiGenerationQueue.QueueAttachmentSummaryAsync(input.ApplicationId, CurrentTenant.Id, promptVersion, attachmentIds);
 
-        var request = await aiGenerationStatusAppService.GetLatestAsync(
-            input.ApplicationId,
-            AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
-            CurrentTenant.Id);
-
-        return await CreateGenerationStatusAsync(
-            request ?? throw new UserFriendlyException("Unable to queue AI attachment summary request."));
+        var request = await aiGenerationStatusAppService.GetLatestAsync(
+            input.ApplicationId,
+            AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
+            CurrentTenant.Id);
+
+        if (request == null)
+        {
+            throw new UserFriendlyException("Unable to queue AI attachment summary request.");
+        }
+
+        return await CreateGenerationStatusAsync(request);
     }
 
     [Authorize(AIPermissions.Analysis.GenerateScoring)]
@@ -1218,13 +1226,17 @@ public async Task<AIGenerationStatusDto> QueueApplicationScoringAsync(Guid appli
         await EnsureScoringEnabledAsync();
         await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, CurrentTenant.Id, promptVersion);
 
-        var request = await aiGenerationStatusAppService.GetLatestAsync(
-            applicationId,
-            AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
-            CurrentTenant.Id);
-
-        return await CreateGenerationStatusAsync(
-            request ?? throw new UserFriendlyException("Unable to queue AI scoring request."));
+        var request = await aiGenerationStatusAppService.GetLatestAsync(
+            applicationId,
+            AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
+            CurrentTenant.Id);
+
+        if (request == null)
+        {
+            throw new UserFriendlyException("Unable to queue AI scoring request.");
+        }
+
+        return await CreateGenerationStatusAsync(request);
     }
 
     public async Task<AIGenerationStatusDto> GetAIGenerationStatusAsync(Guid applicationId, string operationType, string? promptVersion = null)
@@ -1244,14 +1256,18 @@ public async Task<AIGenerationStatusDto> QueueAllAIStagesAsync(Guid applicationI
         await EnsureScoringEnabledAsync();
         await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, CurrentTenant.Id, promptVersion);
 
-        var request = await aiGenerationStatusAppService.GetLatestAsync(
-            applicationId,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
-            CurrentTenant.Id);
-
-        return await CreateGenerationStatusAsync(
-            request ?? throw new UserFriendlyException("Unable to queue AI generation request."));
-    }
+        var request = await aiGenerationStatusAppService.GetLatestAsync(
+            applicationId,
+            AIGenerationRequestKeyHelper.PipelineOperationType,
+            CurrentTenant.Id);
+
+        if (request == null)
+        {
+            throw new UserFriendlyException("Unable to queue AI generation request.");
+        }
+
+        return await CreateGenerationStatusAsync(request);
+    }
 
     private async Task<AIGenerationStatusDto> CreateGenerationStatusAsync(AIGenerationRequestDto? request)
     {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantManagerApplicationMapperlyProfile.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantManagerApplicationMapperlyProfile.cs
index b30669f1ee..994dbe1d99 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantManagerApplicationMapperlyProfile.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantManagerApplicationMapperlyProfile.cs
@@ -538,7 +538,6 @@ public partial class ApplicationActionResultItemToDtoMapper : MapperBase<Applica
 [Mapper] public partial class CommunityToDtoMapper : MapperBase<Community, CommunityDto> { public override partial CommunityDto Map(Community source); public override partial void Map(Community source, CommunityDto destination); }
 [Mapper] public partial class RegionalDistrictToDtoMapper : MapperBase<RegionalDistrict, RegionalDistrictDto> { public override partial RegionalDistrictDto Map(RegionalDistrict source); public override partial void Map(RegionalDistrict source, RegionalDistrictDto destination); }
 [Mapper] public partial class ApplicationTagsToDtoMapper : MapperBase<ApplicationTags, ApplicationTagsDto> { public override partial ApplicationTagsDto Map(ApplicationTags source); public override partial void Map(ApplicationTags source, ApplicationTagsDto destination); }
-[Mapper] public partial class AIGenerationRequestToDtoMapper : MapperBase<AIGenerationRequest, AIGenerationRequestDto> { public override partial AIGenerationRequestDto Map(AIGenerationRequest source); public override partial void Map(AIGenerationRequest source, AIGenerationRequestDto destination); }
 [Mapper(AllowNullPropertyAssignment = true)]
 public partial class ApplicantToGrantApplicationApplicantDtoMapper : MapperBase<Applicant, GrantApplicationApplicantDto>
 {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/GrantApplications/AIGenerationRequestKeyHelper.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/GrantApplications/AIGenerationRequestKeyHelper.cs
index 0492a5d6ad..d478b3af4f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/GrantApplications/AIGenerationRequestKeyHelper.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/GrantApplications/AIGenerationRequestKeyHelper.cs
@@ -19,4 +19,20 @@ public static string BuildRequestKey(Guid? tenantId, Guid applicationId, string
             applicationId.ToString("D"),
             operationType.Trim().ToLowerInvariant());
     }
+
+    /// <summary>
+    /// Maps an operation type key (e.g. "application-analysis") to the canonical operation name
+    /// stored in the AIOperations table (e.g. "ApplicationAnalysis").
+    /// </summary>
+    public static string? ResolveOperationName(string operationType)
+    {
+        return operationType switch
+        {
+            ApplicationAnalysisOperationType => "ApplicationAnalysis",
+            AttachmentSummaryOperationType => "AttachmentSummary",
+            ApplicationScoringOperationType => "ApplicationScoring",
+            PipelineOperationType => "Default",
+            _ => null
+        };
+    }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
index 7ab2d9a8e5..94fc5a1bf1 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
@@ -8,7 +8,7 @@ public class AIGenerationRequest : FullAuditedAggregateRoot<Guid>, IMultiTenant
 {
     public Guid? TenantId { get; set; }
     public Guid? ApplicationId { get; set; }
-    public string OperationType { get; set; } = string.Empty;
+    public Guid OperationId { get; set; }
     public string RequestKey { get; set; } = string.Empty;
     public AIGenerationRequestStatus Status { get; set; }
     public DateTime? StartedAt { get; set; }
@@ -23,13 +23,13 @@ protected AIGenerationRequest()
     public AIGenerationRequest(
         Guid id,
         Guid? tenantId,
-        string operationType,
+        Guid operationId,
         Guid? applicationId,
         string requestKey)
         : base(id)
     {
         TenantId = tenantId;
-        OperationType = operationType;
+        OperationId = operationId;
         ApplicationId = applicationId;
         RequestKey = requestKey;
         Status = AIGenerationRequestStatus.Queued;
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
index 99e3a4c22f..3df4f8195b 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
@@ -6,8 +6,10 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Features;
 using Unity.AI.Localization;
 using Unity.AI.RateLimit;
@@ -37,6 +39,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
+        var operationRepository = CreateOperationRepository();
 
         RunApplicationAIPipelineJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
@@ -50,7 +53,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository);
+        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId, "v1");
 
@@ -64,7 +67,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationType == AIGenerationRequestKeyHelper.PipelineOperationType &&
+            r.OperationId != Guid.Empty &&
             r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
@@ -78,6 +81,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_When_Any_Enabled_Stage_Ha
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
+        var operationRepository = CreateOperationRepository();
 
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var prerequisiteValidator = Substitute.For<IAIGenerationPrerequisiteValidator>();
@@ -90,6 +94,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_When_Any_Enabled_Stage_Ha
         var queue = CreateQueue(
             backgroundJobManager,
             repository,
+            operationRepository: operationRepository,
             prerequisiteValidator: prerequisiteValidator);
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId);
@@ -105,6 +110,7 @@ public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_Ena
         var tenantId = Guid.NewGuid();
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
+        var operationRepository = CreateOperationRepository();
 
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<IAIRateLimiter>();
@@ -121,7 +127,8 @@ public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_Ena
             backgroundJobManager,
             repository,
             rateLimiter,
-            prerequisiteValidator);
+            prerequisiteValidator,
+            operationRepository: operationRepository);
 
         await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAllAIStagesAsync(applicationId, tenantId));
 
@@ -137,6 +144,7 @@ public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_AI_
         var tenantId = Guid.NewGuid();
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
+        var operationRepository = CreateOperationRepository();
 
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<IAIRateLimiter>();
@@ -152,7 +160,8 @@ public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_AI_
             repository,
             rateLimiter,
             prerequisiteValidator,
-            featureChecker);
+            featureChecker,
+            operationRepository: operationRepository);
 
         await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAllAIStagesAsync(applicationId, tenantId));
 
@@ -174,7 +183,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Not_Enqueue_When_An_Activ
         var request = new AIGenerationRequest(
             Guid.NewGuid(),
             tenantId,
-            AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
+            Guid.NewGuid(),
             applicationId,
             requestKey);
 
@@ -184,7 +193,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Not_Enqueue_When_An_Activ
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<Unity.AI.RateLimit.IAIRateLimiter>();
         rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
-        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter);
+        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter: rateLimiter);
 
         await queue.QueueApplicationAnalysisAsync(applicationId, tenantId, promptVersion);
 
@@ -229,7 +238,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Enqueue_New_Request_When_
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationType == AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType &&
+            r.OperationId != Guid.Empty &&
             r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
@@ -247,7 +256,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Check_Rate_Limit_Before_E
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<IAIRateLimiter>();
         rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
-        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter);
+        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter: rateLimiter);
 
         await queue.QueueApplicationAnalysisAsync(applicationId, tenantId);
 
@@ -267,7 +276,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Not_Insert_Or_Enqueue_Whe
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<IAIRateLimiter>();
         rateLimiter.EnsureAsync().Returns<Task>(_ => throw new InvalidOperationException("rate limited"));
-        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter);
+        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter: rateLimiter);
 
         await Should.ThrowAsync<InvalidOperationException>(() => queue.QueueApplicationAnalysisAsync(applicationId, tenantId));
 
@@ -290,7 +299,7 @@ public async Task QueueAttachmentSummaryAsync_Should_Not_Insert_Or_Enqueue_When_
         var prerequisiteValidator = Substitute.For<IAIGenerationPrerequisiteValidator>();
         prerequisiteValidator.EnsureAttachmentSummaryAvailableAsync(applicationId)
             .Returns<Task>(_ => throw new UserFriendlyException("No attachments are available to summarize."));
-        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter, prerequisiteValidator);
+        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter: rateLimiter, prerequisiteValidator: prerequisiteValidator);
 
         await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAttachmentSummaryAsync(applicationId, tenantId));
 
@@ -309,7 +318,7 @@ public async Task QueueAttachmentSummaryAsync_Should_Not_Enqueue_When_An_Active_
         var request = new AIGenerationRequest(
             Guid.NewGuid(),
             tenantId,
-            AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
+            Guid.NewGuid(),
             applicationId,
             requestKey);
 
@@ -335,6 +344,7 @@ public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_No
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
+        var operationRepository = CreateOperationRepository();
 
         GenerateAttachmentSummaryBackgroundJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
@@ -348,7 +358,7 @@ public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_No
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository);
+        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
 
         await queue.QueueAttachmentSummaryAsync(applicationId, tenantId, promptVersion);
 
@@ -361,7 +371,7 @@ public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_No
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationType == AIGenerationRequestKeyHelper.AttachmentSummaryOperationType &&
+            r.OperationId != Guid.Empty &&
             r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
@@ -376,7 +386,7 @@ public async Task QueueApplicationScoringAsync_Should_Not_Enqueue_When_An_Active
         var request = new AIGenerationRequest(
             Guid.NewGuid(),
             tenantId,
-            AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
+            Guid.NewGuid(),
             applicationId,
             requestKey);
 
@@ -402,6 +412,7 @@ public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_N
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
+        var operationRepository = CreateOperationRepository();
 
         GenerateApplicationScoringBackgroundJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
@@ -415,7 +426,7 @@ public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_N
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository);
+        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
 
         await queue.QueueApplicationScoringAsync(applicationId, tenantId, promptVersion);
 
@@ -428,7 +439,7 @@ public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_N
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationType == AIGenerationRequestKeyHelper.ApplicationScoringOperationType &&
+            r.OperationId != Guid.Empty &&
             r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
@@ -475,7 +486,8 @@ private static ApplicationAIGenerationQueue CreateQueue(
         IRepository<AIGenerationRequest, Guid> repository,
         Unity.AI.RateLimit.IAIRateLimiter? rateLimiter = null,
         IAIGenerationPrerequisiteValidator? prerequisiteValidator = null,
-        IFeatureChecker? featureChecker = null)
+        IFeatureChecker? featureChecker = null,
+        IRepository<AIOperation, Guid>? operationRepository = null)
     {
         if (rateLimiter == null)
         {
@@ -502,6 +514,7 @@ private static ApplicationAIGenerationQueue CreateQueue(
         return new ApplicationAIGenerationQueue(
             backgroundJobManager,
             repository,
+            operationRepository ?? CreateOperationRepository(),
             new TestDistributedLockProvider(),
             prerequisiteValidator,
             featureChecker,
@@ -513,6 +526,23 @@ private static ApplicationAIGenerationQueue CreateQueue(
 
     private static readonly Guid CreateQueueCurrentUserId = Guid.NewGuid();
 
+    private static IRepository<AIOperation, Guid> CreateOperationRepository()
+    {
+        var operations = new List<AIOperation>
+        {
+            new(Guid.NewGuid(), "AttachmentSummary", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(Guid.NewGuid(), "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(Guid.NewGuid(), "ApplicationScoring", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(Guid.NewGuid(), "Default", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true }
+        };
+
+        var repository = Substitute.For<IRepository<AIOperation, Guid>>();
+        repository.GetQueryableAsync()
+            .Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+
+        return repository;
+    }
+
     private static ICurrentUser CreateCurrentUser()
     {
         var currentUser = Substitute.For<ICurrentUser>();
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
index 432dfae6aa..c9e2fc6231 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
@@ -3,6 +3,7 @@
 using System;
 using System.Linq;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
@@ -20,24 +21,105 @@ public async Task GetLatestAsync_Should_Respect_Current_Tenant()
         var tenantId = Guid.NewGuid();
         var otherTenantId = Guid.NewGuid();
         var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
+        var operationId = Guid.NewGuid();
+
+        var operations = new[]
+        {
+            new AIOperation(operationId, "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid())
+            {
+                IsActive = true
+            }
+        };
 
         var requests = new[]
         {
-            new AIGenerationRequest(Guid.NewGuid(), otherTenantId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType, applicationId, requestKey),
-            new AIGenerationRequest(Guid.NewGuid(), tenantId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType, applicationId, requestKey)
+            new AIGenerationRequest(Guid.NewGuid(), otherTenantId, operationId, applicationId, requestKey),
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, requestKey)
         };
 
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
 
         var currentTenant = Substitute.For<ICurrentTenant>();
         currentTenant.Id.Returns(tenantId);
 
-        var service = new AIGenerationStatusAppService(repository, currentTenant);
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
 
         var result = await service.GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
 
         result.ShouldNotBeNull();
         result.ApplicationId.ShouldBe(applicationId);
     }
+
+    [Fact]
+    public async Task GetLatestAsync_Should_Return_History_For_Inactive_Operation()
+    {
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
+        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
+        var operationId = Guid.NewGuid();
+
+        var operations = new[]
+        {
+            new AIOperation(operationId, "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid())
+            {
+                IsActive = false
+            }
+        };
+
+        var requests = new[]
+        {
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, requestKey)
+        };
+
+        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
+        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+
+        var currentTenant = Substitute.For<ICurrentTenant>();
+        currentTenant.Id.Returns(tenantId);
+
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
+
+        var result = await service.GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
+
+        result.ShouldNotBeNull();
+        result!.OperationId.ShouldBe(operationId);
+        result.ApplicationId.ShouldBe(applicationId);
+    }
+
+    [Fact]
+    public async Task GetLatestAsync_Should_Reject_Legacy_Operation_Name()
+    {
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
+        var operationId = Guid.NewGuid();
+
+        var operations = new[]
+        {
+            new AIOperation(operationId, "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid())
+        };
+
+        var requests = new[]
+        {
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, "legacy-operation-name")
+        };
+
+        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
+        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
+        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+
+        var currentTenant = Substitute.For<ICurrentTenant>();
+        currentTenant.Id.Returns(tenantId);
+
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
+
+        var result = await service.GetLatestAsync(applicationId, "legacy-operation-name");
+
+        result.ShouldBeNull();
+    }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
index 8085bd5523..98fd04e712 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
@@ -303,7 +303,7 @@ private static AIGenerationRequest CreateRequest()
         return new AIGenerationRequest(
             Guid.NewGuid(),
             tenantId,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
+            Guid.NewGuid(),
             applicationId,
             AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.PipelineOperationType));
     }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/GrantApplicationAIGenerationStatusTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/GrantApplicationAIGenerationStatusTests.cs
index a8323f6cc8..9d23a533e3 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/GrantApplicationAIGenerationStatusTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/GrantApplicationAIGenerationStatusTests.cs
@@ -14,6 +14,7 @@
 using Unity.Payments.PaymentRequests;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Features;
+using Volo.Abp;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -52,9 +53,47 @@ await aiGenerationStatusAppService.Received(1)
         await aiRateLimiter.Received(1).GetStateAsync();
     }
 
+    [Fact]
+    public async Task QueueApplicationAnalysisAsync_Should_Throw_When_Latest_Request_Is_Null()
+    {
+        var applicationId = Guid.NewGuid();
+        var aiGenerationStatusAppService = Substitute.For<IAIGenerationStatusAppService>();
+        aiGenerationStatusAppService
+            .GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType, null)
+            .Returns((AIGenerationRequestDto?)null);
+
+        var aiRateLimiter = Substitute.For<IAIRateLimiter>();
+        aiRateLimiter.GetStateAsync().Returns(new AIRateLimitStateDto
+        {
+            IsGenerating = true,
+            RetryAfterSeconds = 11
+        });
+
+        var queue = Substitute.For<IApplicationAIGenerationQueue>();
+        queue
+            .QueueApplicationAnalysisAsync(applicationId, null, null)
+            .Returns(Task.CompletedTask);
+
+        var featureChecker = Substitute.For<IFeatureChecker>();
+        featureChecker
+            .IsEnabledAsync("Unity.AI.ApplicationAnalysis")
+            .Returns(true);
+
+        var appService = CreateAppService(aiGenerationStatusAppService, aiRateLimiter, queue, featureChecker);
+
+        await Should.ThrowAsync<UserFriendlyException>(() => appService.QueueApplicationAnalysisAsync(applicationId));
+
+        await queue.Received(1).QueueApplicationAnalysisAsync(applicationId, null, null);
+        await aiGenerationStatusAppService.Received(1)
+            .GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType, null);
+        await aiRateLimiter.DidNotReceive().GetStateAsync();
+    }
+
     private GrantApplicationAppService CreateAppService(
         IAIGenerationStatusAppService aiGenerationStatusAppService,
-        IAIRateLimiter aiRateLimiter)
+        IAIRateLimiter aiRateLimiter,
+        IApplicationAIGenerationQueue? aiGenerationQueue = null,
+        IFeatureChecker? featureChecker = null)
     {
         var appService = new GrantApplicationAppService(
             Substitute.For<IApplicationManager>(),
@@ -68,10 +107,10 @@ private GrantApplicationAppService CreateAppService(
             Substitute.For<IApplicantAddressRepository>(),
             Substitute.For<IApplicantSupplierAppService>(),
             Substitute.For<IPaymentRequestAppService>(),
-            Substitute.For<IApplicationAIGenerationQueue>(),
+            aiGenerationQueue ?? Substitute.For<IApplicationAIGenerationQueue>(),
             aiGenerationStatusAppService,
             aiRateLimiter,
-            Substitute.For<IFeatureChecker>());
+            featureChecker ?? Substitute.For<IFeatureChecker>());
 
         appService.LazyServiceProvider = GetRequiredService<IAbpLazyServiceProvider>();
         return appService;

From 15e2a5a17c859be69f61a1a1b8b737b356afb8e4 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 08:32:06 -0700
Subject: [PATCH 03/61] AB#32307 repair AI migration chain

---
 .../GrantManagerDbContext.cs                  |   12 +-
 .../20260324221338_AddAIPromptTables.cs       |  102 +-
 ...0618203824_AddUniqueIndexToAIPromptName.cs |   17 +-
 ...18210000_RefreshBuiltInAIPromptVersions.cs |  159 -
 ...20260624191335_RefreshAiSchema.Designer.cs | 3368 +++++++++++++++++
 .../20260624191335_RefreshAiSchema.cs         |   21 +
 .../GrantManagerDbContextModelSnapshot.cs     |  162 +-
 7 files changed, 3599 insertions(+), 242 deletions(-)
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
index aabd9ae426..06b877d8ee 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
@@ -53,7 +53,8 @@ public class GrantManagerDbContext :
 
     // Unity.AI entities
     public DbSet<AIPrompt> AIPrompts { get; set; }
-    public DbSet<AIPromptVersion> AIPromptVersions { get; set; }
+    public DbSet<AIModel> AIModels { get; set; }
+    public DbSet<AIOperation> AIOperations { get; set; }
 
     #region Entities from the modules
 
@@ -242,12 +243,17 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             b.ToTable(GrantManagerConsts.DbTablePrefix + "AIRequests", AIDbProperties.DbSchema);
             b.ConfigureByConvention();
-            b.Property(x => x.OperationType).IsRequired().HasMaxLength(64);
+            b.Property(x => x.OperationId).IsRequired();
             b.Property(x => x.RequestKey).IsRequired().HasMaxLength(256);
             b.Property(x => x.FailureReason).HasMaxLength(2000);
             b.Property(x => x.Status).IsRequired();
+            b.HasOne<AIOperation>()
+                .WithMany()
+                .HasForeignKey(x => x.OperationId)
+                .OnDelete(DeleteBehavior.Restrict);
             b.HasIndex(x => x.RequestKey);
-            b.HasIndex(x => new { x.TenantId, x.ApplicationId, x.OperationType, x.Status });
+            b.HasIndex(x => x.OperationId);
+            b.HasIndex(x => new { x.TenantId, x.ApplicationId, x.OperationId, x.Status });
         });
 
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
index e390d9dc19..2f973c1542 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
@@ -22,8 +22,11 @@ protected override void Up(MigrationBuilder migrationBuilder)
                     Id = table.Column<Guid>(type: "uuid", nullable: false),
                     TenantId = table.Column<Guid>(type: "uuid", nullable: true),
                     Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    Description = table.Column<string>(type: "character varying(2000)", maxLength: 2000, nullable: true),
-                    Type = table.Column<int>(type: "integer", nullable: false),
+                    VersionNumber = table.Column<int>(type: "integer", nullable: false),
+                    SystemPrompt = table.Column<string>(type: "text", nullable: false),
+                    UserPrompt = table.Column<string>(type: "text", nullable: false),
+                    MetadataJson = table.Column<string>(type: "jsonb", nullable: true),
+                    SeedHash = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
                     IsActive = table.Column<bool>(type: "boolean", nullable: false),
                     ExtraProperties = table.Column<string>(type: "text", nullable: false),
                     ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
@@ -38,24 +41,15 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 });
 
             migrationBuilder.CreateTable(
-                name: "AIPromptVersions",
+                name: "AIModels",
                 schema: "AI",
                 columns: table => new
                 {
                     Id = table.Column<Guid>(type: "uuid", nullable: false),
                     TenantId = table.Column<Guid>(type: "uuid", nullable: true),
-                    PromptId = table.Column<Guid>(type: "uuid", nullable: false),
-                    VersionNumber = table.Column<int>(type: "integer", nullable: false),
-                    SystemPrompt = table.Column<string>(type: "text", nullable: false),
-                    UserPromptTemplate = table.Column<string>(type: "text", nullable: false),
-                    DeveloperNotes = table.Column<string>(type: "text", nullable: true),
-                    TargetModel = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
-                    TargetProvider = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
-                    Temperature = table.Column<double>(type: "double precision", nullable: false),
-                    MaxTokens = table.Column<int>(type: "integer", nullable: true),
-                    IsPublished = table.Column<bool>(type: "boolean", nullable: false),
-                    IsDeprecated = table.Column<bool>(type: "boolean", nullable: false),
-                    MetadataJson = table.Column<string>(type: "jsonb", nullable: true),
+                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    IsActive = table.Column<bool>(type: "boolean", nullable: false),
+                    SettingsJson = table.Column<string>(type: "jsonb", nullable: false),
                     ExtraProperties = table.Column<string>(type: "text", nullable: false),
                     ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
                     CreationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
@@ -65,21 +59,79 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_AIPromptVersions", x => x.Id);
+                    table.PrimaryKey("PK_AIModels", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
+                schema: "AI",
+                table: "AIPrompts",
+                columns: new[] { "TenantId", "Name", "VersionNumber" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIModels_Name",
+                schema: "AI",
+                table: "AIModels",
+                column: "Name",
+                unique: true);
+
+            migrationBuilder.CreateTable(
+                name: "AIOperations",
+                schema: "AI",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    TenantId = table.Column<Guid>(type: "uuid", nullable: true),
+                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    AIModelId = table.Column<Guid>(type: "uuid", nullable: false),
+                    AIPromptId = table.Column<Guid>(type: "uuid", nullable: false),
+                    ExecutionMode = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
+                    CompletionTokens = table.Column<int>(type: "integer", nullable: false),
+                    IsActive = table.Column<bool>(type: "boolean", nullable: false),
+                    ExtraProperties = table.Column<string>(type: "text", nullable: false),
+                    ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
+                    CreationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
+                    CreatorId = table.Column<Guid>(type: "uuid", nullable: true),
+                    LastModificationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: true),
+                    LastModifierId = table.Column<Guid>(type: "uuid", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_AIOperations", x => x.Id);
                     table.ForeignKey(
-                        name: "FK_AIPromptVersions_AIPrompts_PromptId",
-                        column: x => x.PromptId,
+                        name: "FK_AIOperations_AIModels_AIModelId",
+                        column: x => x.AIModelId,
+                        principalSchema: "AI",
+                        principalTable: "AIModels",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_AIOperations_AIPrompts_AIPromptId",
+                        column: x => x.AIPromptId,
                         principalSchema: "AI",
                         principalTable: "AIPrompts",
                         principalColumn: "Id",
-                        onDelete: ReferentialAction.Cascade);
+                        onDelete: ReferentialAction.Restrict);
                 });
 
             migrationBuilder.CreateIndex(
-                name: "IX_AIPromptVersions_PromptId_VersionNumber",
+                name: "IX_AIOperations_AIModelId",
+                schema: "AI",
+                table: "AIOperations",
+                column: "AIModelId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIOperations_AIPromptId",
                 schema: "AI",
-                table: "AIPromptVersions",
-                columns: new[] { "PromptId", "VersionNumber" },
+                table: "AIOperations",
+                column: "AIPromptId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIOperations_Name",
+                schema: "AI",
+                table: "AIOperations",
+                column: "Name",
                 unique: true);
         }
 
@@ -87,7 +139,11 @@ protected override void Up(MigrationBuilder migrationBuilder)
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(
-                name: "AIPromptVersions",
+                name: "AIOperations",
+                schema: "AI");
+
+            migrationBuilder.DropTable(
+                name: "AIModels",
                 schema: "AI");
 
             migrationBuilder.DropTable(
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
index 75b13a5f7e..68c43ad654 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
@@ -10,11 +10,22 @@ public partial class AddUniqueIndexToAIPromptName : Migration
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIPrompts"
+                ADD COLUMN IF NOT EXISTS "VersionNumber" integer NOT NULL DEFAULT 1;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                DROP INDEX IF EXISTS "AI"."IX_AIPrompts_Name";
+                """);
+
             migrationBuilder.CreateIndex(
-                name: "IX_AIPrompts_Name",
+                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
                 schema: "AI",
                 table: "AIPrompts",
-                column: "Name",
+                columns: new[] { "TenantId", "Name", "VersionNumber" },
                 unique: true);
         }
 
@@ -22,7 +33,7 @@ protected override void Up(MigrationBuilder migrationBuilder)
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropIndex(
-                name: "IX_AIPrompts_Name",
+                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
                 schema: "AI",
                 table: "AIPrompts");
         }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
index 7efc8de94b..4aacd26ff8 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
@@ -1,177 +1,18 @@
-using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text.Json;
-using Unity.GrantManager.EntityFrameworkCore;
 
 #nullable disable
 
 namespace Unity.GrantManager.Migrations.HostMigrations
 {
-    [DbContext(typeof(GrantManagerDbContext))]
     [Migration("20260618210000_RefreshBuiltInAIPromptVersions")]
     public partial class RefreshBuiltInAIPromptVersions : Migration
     {
-        private static readonly Guid AnalysisPromptId = new("4a100001-1000-4000-a000-000000000001");
-        private static readonly Guid AttachmentPromptId = new("4a100001-1000-4000-a000-000000000002");
-        private static readonly Guid ScoringPromptId = new("4a100001-1000-4000-a000-000000000003");
-
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            migrationBuilder.Sql(
-                """
-                UPDATE "AI"."AIPrompts"
-                SET "Name" = 'ApplicationAnalysis',
-                    "Description" = 'Grant application analysis and review',
-                    "Type" = 1,
-                    "IsActive" = TRUE
-                WHERE "Id" = '4a100001-1000-4000-a000-000000000001';
-
-                UPDATE "AI"."AIPrompts"
-                SET "Name" = 'AttachmentSummary',
-                    "Description" = 'Attachment summarization for grant review',
-                    "Type" = 1,
-                    "IsActive" = TRUE
-                WHERE "Id" = '4a100001-1000-4000-a000-000000000002';
-
-                UPDATE "AI"."AIPrompts"
-                SET "Name" = 'ApplicationScoring',
-                    "Description" = 'Scoresheet section answering assistant',
-                    "Type" = 1,
-                    "IsActive" = TRUE
-                WHERE "Id" = '4a100001-1000-4000-a000-000000000003';
-                """);
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                AnalysisPromptId,
-                0,
-                ReadPromptFile("v0", "application-analysis.system.txt"),
-                ReadPromptFile("v0", "application-analysis.user.txt"),
-                "v0 - initial single-file analysis prompt",
-                null);
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                AnalysisPromptId,
-                1,
-                ReadPromptFile("v1", "application-analysis.system.txt"),
-                ReadPromptFile("v1", "application-analysis.user.txt"),
-                "v1 - modular prompt with separate rubric, score, output, and rules sections",
-                BuildSectionsJson(new Dictionary<string, string>
-                {
-                    ["RUBRIC"] = ReadPromptFile("v1", "application-analysis.rubric.txt"),
-                    ["SCORE"] = ReadPromptFile("v1", "application-analysis.score.txt"),
-                    ["OUTPUT"] = ReadPromptFile("v1", "application-analysis.output.txt"),
-                    ["RULES"] = ReadPromptFile("v1", "application-analysis.rules.txt"),
-                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
-                }));
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                AttachmentPromptId,
-                0,
-                ReadPromptFile("v0", "attachment-summary.system.txt"),
-                ReadPromptFile("v0", "attachment-summary.user.txt"),
-                "v0 - initial single-file attachment prompt",
-                null);
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                AttachmentPromptId,
-                1,
-                ReadPromptFile("v1", "attachment-summary.system.txt"),
-                ReadPromptFile("v1", "attachment-summary.user.txt"),
-                "v1 - modular prompt with separate output and rules sections",
-                BuildSectionsJson(new Dictionary<string, string>
-                {
-                    ["OUTPUT"] = ReadPromptFile("v1", "attachment-summary.output.txt"),
-                    ["RULES"] = ReadPromptFile("v1", "attachment-summary.rules.txt"),
-                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
-                }));
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                ScoringPromptId,
-                0,
-                ReadPromptFile("v0", "application-scoring.system.txt"),
-                ReadPromptFile("v0", "application-scoring.user.txt"),
-                "v0 - initial single-file scoresheet prompt",
-                null);
-
-            UpdatePromptVersion(
-                migrationBuilder,
-                ScoringPromptId,
-                1,
-                ReadPromptFile("v1", "application-scoring.system.txt"),
-                ReadPromptFile("v1", "application-scoring.user.txt"),
-                "v1 - modular prompt with separate output and rules sections",
-                BuildSectionsJson(new Dictionary<string, string>
-                {
-                    ["OUTPUT"] = ReadPromptFile("v1", "application-scoring.output.txt"),
-                    ["RULES"] = ReadPromptFile("v1", "application-scoring.rules.txt"),
-                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
-                }));
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)
         {
-            // No-op: prompt version content is managed by seeded defaults.
-        }
-
-        private static void UpdatePromptVersion(
-            MigrationBuilder migrationBuilder,
-            Guid promptId,
-            int versionNumber,
-            string systemPrompt,
-            string userPromptTemplate,
-            string developerNotes,
-            string metadataJson)
-        {
-            migrationBuilder.Sql($"""
-                UPDATE "AI"."AIPromptVersions"
-                SET "SystemPrompt" = '{EscapeSqlLiteral(systemPrompt)}',
-                    "UserPromptTemplate" = '{EscapeSqlLiteral(userPromptTemplate)}',
-                    "DeveloperNotes" = '{EscapeSqlLiteral(developerNotes)}',
-                    "IsPublished" = TRUE,
-                    "IsDeprecated" = FALSE,
-                    "MetadataJson" = {FormatNullableSqlString(metadataJson)}
-                WHERE "PromptId" = '{promptId}'
-                  AND "VersionNumber" = {versionNumber};
-                """);
-        }
-
-        private static string ReadPromptFile(string version, string fileName)
-        {
-            var path = Path.Combine(AppContext.BaseDirectory, "AI", "Prompts", "Versions", version, fileName);
-            if (!File.Exists(path))
-            {
-                throw new InvalidOperationException($"Missing prompt asset required by migration: {path}");
-            }
-
-            return File.ReadAllText(path);
-        }
-
-        private static string BuildSectionsJson(Dictionary<string, string> sections)
-        {
-            return JsonSerializer.Serialize(new { sections });
-        }
-
-        private static string EscapeSqlLiteral(string value)
-        {
-            return value.Replace("'", "''", StringComparison.Ordinal);
-        }
-
-        private static string FormatNullableSqlString(string value)
-        {
-            if (value == null)
-            {
-                return "NULL";
-            }
-
-            return $"'{EscapeSqlLiteral(value)}'";
         }
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
new file mode 100644
index 0000000000..3ba04bd744
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
@@ -0,0 +1,3368 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Unity.GrantManager.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.HostMigrations
+{
+    [DbContext(typeof(GrantManagerDbContext))]
+    [Migration("20260624191335_RefreshAiSchema")]
+    partial class RefreshAiSchema
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
+                .HasAnnotation("ProductVersion", "10.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzBlobTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<byte[]>("BlobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("blob_data");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("qrtz_blob_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzCalendar", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("text")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<byte[]>("Calendar")
+                        .IsRequired()
+                        .HasColumnType("bytea")
+                        .HasColumnName("calendar");
+
+                    b.HasKey("SchedulerName", "CalendarName");
+
+                    b.ToTable("qrtz_calendars", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzCronTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CronExpression")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("cron_expression");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("text")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("qrtz_cron_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzFiredTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("EntryId")
+                        .HasColumnType("text")
+                        .HasColumnName("entry_id");
+
+                    b.Property<long>("FiredTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("fired_time");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("instance_name");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<bool?>("RequestsRecovery")
+                        .HasColumnType("bool")
+                        .HasColumnName("requests_recovery");
+
+                    b.Property<long>("ScheduledTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("sched_time");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("state");
+
+                    b.Property<string>("TriggerGroup")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("TriggerName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.HasKey("SchedulerName", "EntryId");
+
+                    b.HasIndex("InstanceName")
+                        .HasDatabaseName("idx_qrtz_ft_trig_inst_name");
+
+                    b.HasIndex("JobGroup")
+                        .HasDatabaseName("idx_qrtz_ft_job_group");
+
+                    b.HasIndex("JobName")
+                        .HasDatabaseName("idx_qrtz_ft_job_name");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_qrtz_ft_job_req_recovery");
+
+                    b.HasIndex("TriggerGroup")
+                        .HasDatabaseName("idx_qrtz_ft_trig_group");
+
+                    b.HasIndex("TriggerName")
+                        .HasDatabaseName("idx_qrtz_ft_trig_name");
+
+                    b.HasIndex("SchedulerName", "TriggerName", "TriggerGroup")
+                        .HasDatabaseName("idx_qrtz_ft_trig_nm_gp");
+
+                    b.ToTable("qrtz_fired_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzJobDetail", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("JobName")
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<string>("JobGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("IsDurable")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_durable");
+
+                    b.Property<bool>("IsNonConcurrent")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_nonconcurrent");
+
+                    b.Property<bool>("IsUpdateData")
+                        .HasColumnType("bool")
+                        .HasColumnName("is_update_data");
+
+                    b.Property<string>("JobClassName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_class_name");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("job_data");
+
+                    b.Property<bool>("RequestsRecovery")
+                        .HasColumnType("bool")
+                        .HasColumnName("requests_recovery");
+
+                    b.HasKey("SchedulerName", "JobName", "JobGroup");
+
+                    b.HasIndex("RequestsRecovery")
+                        .HasDatabaseName("idx_qrtz_j_req_recovery");
+
+                    b.ToTable("qrtz_job_details", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzLock", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("LockName")
+                        .HasColumnType("text")
+                        .HasColumnName("lock_name");
+
+                    b.HasKey("SchedulerName", "LockName");
+
+                    b.ToTable("qrtz_locks", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzPausedTriggerGroup", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.HasKey("SchedulerName", "TriggerGroup");
+
+                    b.ToTable("qrtz_paused_trigger_grps", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzSchedulerState", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("InstanceName")
+                        .HasColumnType("text")
+                        .HasColumnName("instance_name");
+
+                    b.Property<long>("CheckInInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("checkin_interval");
+
+                    b.Property<long>("LastCheckInTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("last_checkin_time");
+
+                    b.HasKey("SchedulerName", "InstanceName");
+
+                    b.ToTable("qrtz_scheduler_state", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<bool?>("BooleanProperty1")
+                        .HasColumnType("bool")
+                        .HasColumnName("bool_prop_1");
+
+                    b.Property<bool?>("BooleanProperty2")
+                        .HasColumnType("bool")
+                        .HasColumnName("bool_prop_2");
+
+                    b.Property<decimal?>("DecimalProperty1")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_1");
+
+                    b.Property<decimal?>("DecimalProperty2")
+                        .HasColumnType("numeric")
+                        .HasColumnName("dec_prop_2");
+
+                    b.Property<int?>("IntegerProperty1")
+                        .HasColumnType("integer")
+                        .HasColumnName("int_prop_1");
+
+                    b.Property<int?>("IntegerProperty2")
+                        .HasColumnType("integer")
+                        .HasColumnName("int_prop_2");
+
+                    b.Property<long?>("LongProperty1")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_1");
+
+                    b.Property<long?>("LongProperty2")
+                        .HasColumnType("bigint")
+                        .HasColumnName("long_prop_2");
+
+                    b.Property<string>("StringProperty1")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_1");
+
+                    b.Property<string>("StringProperty2")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_2");
+
+                    b.Property<string>("StringProperty3")
+                        .HasColumnType("text")
+                        .HasColumnName("str_prop_3");
+
+                    b.Property<string>("TimeZoneId")
+                        .HasColumnType("text")
+                        .HasColumnName("time_zone_id");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("qrtz_simprop_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzSimpleTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<long>("RepeatCount")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_count");
+
+                    b.Property<long>("RepeatInterval")
+                        .HasColumnType("bigint")
+                        .HasColumnName("repeat_interval");
+
+                    b.Property<long>("TimesTriggered")
+                        .HasColumnType("bigint")
+                        .HasColumnName("times_triggered");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.ToTable("qrtz_simple_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", b =>
+                {
+                    b.Property<string>("SchedulerName")
+                        .HasColumnType("text")
+                        .HasColumnName("sched_name");
+
+                    b.Property<string>("TriggerName")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_name");
+
+                    b.Property<string>("TriggerGroup")
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_group");
+
+                    b.Property<string>("CalendarName")
+                        .HasColumnType("text")
+                        .HasColumnName("calendar_name");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text")
+                        .HasColumnName("description");
+
+                    b.Property<long?>("EndTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("end_time");
+
+                    b.Property<byte[]>("JobData")
+                        .HasColumnType("bytea")
+                        .HasColumnName("job_data");
+
+                    b.Property<string>("JobGroup")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_group");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<short?>("MisfireInstruction")
+                        .HasColumnType("smallint")
+                        .HasColumnName("misfire_instr");
+
+                    b.Property<long?>("NextFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("next_fire_time");
+
+                    b.Property<long?>("PreviousFireTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("prev_fire_time");
+
+                    b.Property<int?>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<long>("StartTime")
+                        .HasColumnType("bigint")
+                        .HasColumnName("start_time");
+
+                    b.Property<string>("TriggerState")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_state");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("trigger_type");
+
+                    b.HasKey("SchedulerName", "TriggerName", "TriggerGroup");
+
+                    b.HasIndex("NextFireTime")
+                        .HasDatabaseName("idx_qrtz_t_next_fire_time");
+
+                    b.HasIndex("TriggerState")
+                        .HasDatabaseName("idx_qrtz_t_state");
+
+                    b.HasIndex("NextFireTime", "TriggerState")
+                        .HasDatabaseName("idx_qrtz_t_nft_st");
+
+                    b.HasIndex("SchedulerName", "JobName", "JobGroup");
+
+                    b.ToTable("qrtz_triggers", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.AI.Domain.AIModel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("SettingsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AIModels", "AI");
+                });
+
+            modelBuilder.Entity("Unity.AI.Domain.AIOperation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AIModelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AIPromptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CompletionTokens")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExecutionMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AIModelId");
+
+                    b.HasIndex("AIPromptId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AIOperations", "AI");
+                });
+
+            modelBuilder.Entity("Unity.AI.Domain.AIPrompt", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MetadataJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("SystemPrompt")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UserPrompt")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("VersionNumber")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .HasDatabaseName("IX_AIPrompts_Name");
+
+                    b.HasIndex("TenantId", "Name", "VersionNumber")
+                        .IsUnique();
+
+                    b.ToTable("AIPrompts", "AI");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applicants.ApplicantTenantMap", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime>("LastUpdated")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("OidcSubUsername")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("TenantName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OidcSubUsername");
+
+                    b.HasIndex("OidcSubUsername", "TenantId")
+                        .IsUnique();
+
+                    b.ToTable("ApplicantTenantMaps", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GrantApplications.AIGenerationRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("CompletedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FailureReason")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RequestKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OperationId");
+
+                    b.HasIndex("RequestKey");
+
+                    b.HasIndex("TenantId", "ApplicationId", "OperationId", "Status");
+
+                    b.ToTable("AIRequests", "AI");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Integrations.CasClientCode", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ClientCode")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("character varying(3)");
+
+                    b.Property<string>("ClientId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FinancialMinistry")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTimeOffset?>("LastUpdatedTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("MinistryPrefix")
+                        .IsRequired()
+                        .HasMaxLength(3)
+                        .HasColumnType("character varying(3)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("CasClientCodes", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Integrations.DynamicUrl", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("KeyName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DynamicUrls", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.Community", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RegionalDistrictCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Communities", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.EconomicRegion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("EconomicRegionCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("EconomicRegionName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EconomicRegions", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.ElectoralDistrict", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ElectoralDistrictCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ElectoralDistrictName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ElectoralDistricts", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.RegionalDistrict", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("EconomicRegionCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RegionalDistrictCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RegionalDistrictName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("RegionalDistricts", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.Sector", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("SectorCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SectorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Sectors", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.SubSector", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("SectorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("SubSectorCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubSectorName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectorId");
+
+                    b.ToTable("SubSectors", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Messaging.InboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DataType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Details")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MessageId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Payload")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("ProcessedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("ReceivedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MessageId")
+                        .IsUnique();
+
+                    b.HasIndex("Source", "Status");
+
+                    b.ToTable("InboxMessages", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Messaging.OutboxMessage", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AckStatus")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("CorrelationId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DataType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Details")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MessageId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("OriginalMessageId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime?>("PublishedAt")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Source", "Status");
+
+                    b.ToTable("OutboxMessages", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Tokens.TenantToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("TenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TenantTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationName")
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)")
+                        .HasColumnName("ApplicationName");
+
+                    b.Property<string>("BrowserInfo")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasColumnName("BrowserInfo");
+
+                    b.Property<string>("ClientId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("ClientId");
+
+                    b.Property<string>("ClientIpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("ClientIpAddress");
+
+                    b.Property<string>("ClientName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("ClientName");
+
+                    b.Property<string>("Comments")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("Comments");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("CorrelationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("CorrelationId");
+
+                    b.Property<string>("Exceptions")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ExecutionDuration")
+                        .HasColumnType("integer")
+                        .HasColumnName("ExecutionDuration");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("HttpMethod")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)")
+                        .HasColumnName("HttpMethod");
+
+                    b.Property<int?>("HttpStatusCode")
+                        .HasColumnType("integer")
+                        .HasColumnName("HttpStatusCode");
+
+                    b.Property<Guid?>("ImpersonatorTenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("ImpersonatorTenantId");
+
+                    b.Property<string>("ImpersonatorTenantName")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("ImpersonatorTenantName");
+
+                    b.Property<Guid?>("ImpersonatorUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("ImpersonatorUserId");
+
+                    b.Property<string>("ImpersonatorUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("ImpersonatorUserName");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TenantName")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("TenantName");
+
+                    b.Property<string>("Url")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("Url");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("UserId");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("UserName");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId", "ExecutionTime");
+
+                    b.HasIndex("TenantId", "UserId", "ExecutionTime");
+
+                    b.ToTable("AuditLogs", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLogAction", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AuditLogId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("AuditLogId");
+
+                    b.Property<int>("ExecutionDuration")
+                        .HasColumnType("integer")
+                        .HasColumnName("ExecutionDuration");
+
+                    b.Property<DateTime>("ExecutionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("ExecutionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("MethodName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("MethodName");
+
+                    b.Property<string>("Parameters")
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)")
+                        .HasColumnName("Parameters");
+
+                    b.Property<string>("ServiceName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("ServiceName");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuditLogId");
+
+                    b.HasIndex("TenantId", "ServiceName", "MethodName", "ExecutionTime");
+
+                    b.ToTable("AuditLogActions", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLogExcelFile", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("FileName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("FileName");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AuditLogExcelFiles", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.EntityChange", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AuditLogId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("AuditLogId");
+
+                    b.Property<DateTime>("ChangeTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("ChangeTime");
+
+                    b.Property<byte>("ChangeType")
+                        .HasColumnType("smallint")
+                        .HasColumnName("ChangeType");
+
+                    b.Property<string>("EntityId")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("EntityId");
+
+                    b.Property<Guid?>("EntityTenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EntityTypeFullName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasColumnName("EntityTypeFullName");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuditLogId");
+
+                    b.HasIndex("TenantId", "EntityTypeFullName", "EntityId");
+
+                    b.ToTable("EntityChanges", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.EntityPropertyChange", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("EntityChangeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("NewValue")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasColumnName("NewValue");
+
+                    b.Property<string>("OriginalValue")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasColumnName("OriginalValue");
+
+                    b.Property<string>("PropertyName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("PropertyName");
+
+                    b.Property<string>("PropertyTypeFullName")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasColumnName("PropertyTypeFullName");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EntityChangeId");
+
+                    b.ToTable("EntityPropertyChanges", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.BackgroundJobs.BackgroundJobRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationName")
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsAbandoned")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("JobArgs")
+                        .IsRequired()
+                        .HasMaxLength(1048576)
+                        .HasColumnType("character varying(1048576)");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime?>("LastTryTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("NextTryTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<byte>("Priority")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("smallint")
+                        .HasDefaultValue((byte)15);
+
+                    b.Property<short>("TryCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("smallint")
+                        .HasDefaultValue((short)0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsAbandoned", "NextTryTime");
+
+                    b.ToTable("BackgroundJobs", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.FeatureManagement.FeatureDefinitionRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AllowedProviders")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DefaultValue")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("GroupName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("IsAvailableToHost")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsVisibleToClients")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ParentName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ValueType")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupName");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Features", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.FeatureManagement.FeatureGroupDefinitionRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("FeatureGroups", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.FeatureManagement.FeatureValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ProviderName")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name", "ProviderName", "ProviderKey")
+                        .IsUnique();
+
+                    b.ToTable("FeatureValues", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityClaimType", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsStatic")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("Regex")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("RegexDescription")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("Required")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("ValueType")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ClaimTypes", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityLinkUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("SourceTenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("SourceUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TargetTenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TargetUserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SourceUserId", "SourceTenantId", "TargetUserId", "TargetTenantId")
+                        .IsUnique();
+
+                    b.ToTable("LinkUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityRole", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<int>("EntityVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("boolean")
+                        .HasColumnName("IsDefault");
+
+                    b.Property<bool>("IsPublic")
+                        .HasColumnType("boolean")
+                        .HasColumnName("IsPublic");
+
+                    b.Property<bool>("IsStatic")
+                        .HasColumnType("boolean")
+                        .HasColumnName("IsStatic");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName");
+
+                    b.ToTable("Roles", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityRoleClaim", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ClaimType")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("RoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentitySecurityLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Action")
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<string>("ApplicationName")
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<string>("BrowserInfo")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("ClientId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ClientIpAddress")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("CorrelationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("Identity")
+                        .HasMaxLength(96)
+                        .HasColumnType("character varying(96)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TenantName")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId", "Action");
+
+                    b.HasIndex("TenantId", "ApplicationName");
+
+                    b.HasIndex("TenantId", "Identity");
+
+                    b.HasIndex("TenantId", "UserId");
+
+                    b.ToTable("SecurityLogs", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentitySession", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ClientId")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Device")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("DeviceInfo")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IpAddresses")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<DateTime?>("LastAccessed")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("SessionId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<DateTime>("SignedIn")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Device");
+
+                    b.HasIndex("SessionId");
+
+                    b.HasIndex("TenantId", "UserId");
+
+                    b.ToTable("Sessions", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AccessFailedCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(0)
+                        .HasColumnName("AccessFailedCount");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("Email");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("EmailConfirmed");
+
+                    b.Property<int>("EntityVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean")
+                        .HasColumnName("IsActive");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsExternal")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsExternal");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTimeOffset?>("LastPasswordChangeTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTimeOffset?>("LastSignInTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<bool>("Leaved")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("Leaved");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("LockoutEnabled");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("Name");
+
+                    b.Property<string>("NormalizedEmail")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("NormalizedEmail");
+
+                    b.Property<string>("NormalizedUserName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("NormalizedUserName");
+
+                    b.Property<string>("OidcSub")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PasswordHash")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("PasswordHash");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(16)
+                        .HasColumnType("character varying(16)")
+                        .HasColumnName("PhoneNumber");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("PhoneNumberConfirmed");
+
+                    b.Property<string>("SecurityStamp")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("SecurityStamp");
+
+                    b.Property<bool>("ShouldChangePasswordOnNextLogin")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Surname")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)")
+                        .HasColumnName("Surname");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("TwoFactorEnabled");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("UserName");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Email");
+
+                    b.HasIndex("NormalizedEmail");
+
+                    b.HasIndex("NormalizedUserName");
+
+                    b.HasIndex("UserName");
+
+                    b.ToTable("Users", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserClaim", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ClaimType")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ClaimValue")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserDelegation", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("SourceUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("StartTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("TargetUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("UserDelegations", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserLogin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .IsRequired()
+                        .HasMaxLength(196)
+                        .HasColumnType("character varying(196)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("UserId", "LoginProvider");
+
+                    b.HasIndex("LoginProvider", "ProviderKey");
+
+                    b.ToTable("UserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserOrganizationUnit", b =>
+                {
+                    b.Property<Guid>("OrganizationUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("OrganizationUnitId", "UserId");
+
+                    b.HasIndex("UserId", "OrganizationUnitId");
+
+                    b.ToTable("UserOrganizationUnits", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserPasskey", b =>
+                {
+                    b.Property<byte[]>("CredentialId")
+                        .HasMaxLength(1024)
+                        .HasColumnType("bytea");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("CredentialId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserPasskeys", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserPasswordHistory", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("UserId", "Password");
+
+                    b.ToTable("UserPasswordHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserRole", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId", "UserId");
+
+                    b.ToTable("UserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserToken", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("LoginProvider")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("UserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.OrganizationUnit", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasMaxLength(95)
+                        .HasColumnType("character varying(95)")
+                        .HasColumnName("Code");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)")
+                        .HasColumnName("DisplayName");
+
+                    b.Property<int>("EntityVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Code");
+
+                    b.HasIndex("ParentId");
+
+                    b.ToTable("OrganizationUnits", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.OrganizationUnitRole", b =>
+                {
+                    b.Property<Guid>("OrganizationUnitId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("RoleId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("OrganizationUnitId", "RoleId");
+
+                    b.HasIndex("RoleId", "OrganizationUnitId");
+
+                    b.ToTable("OrganizationUnitRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.PermissionManagement.PermissionDefinitionRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("GroupName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<bool>("IsEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ManagementPermissionName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<byte>("MultiTenancySide")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ParentName")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Providers")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ResourceName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("StateCheckers")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupName");
+
+                    b.HasIndex("ResourceName", "Name")
+                        .IsUnique();
+
+                    b.ToTable("Permissions", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.PermissionManagement.PermissionGrant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ProviderName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId", "Name", "ProviderName", "ProviderKey")
+                        .IsUnique();
+
+                    b.ToTable("PermissionGrants", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.PermissionManagement.PermissionGroupDefinitionRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("PermissionGroups", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.PermissionManagement.ResourcePermissionGrant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ProviderName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ResourceKey")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ResourceName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId", "Name", "ResourceName", "ResourceKey", "ProviderName", "ProviderKey")
+                        .IsUnique();
+
+                    b.ToTable("ResourcePermissionGrants", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.SettingManagement.Setting", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ProviderKey")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("ProviderName")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name", "ProviderName", "ProviderKey")
+                        .IsUnique();
+
+                    b.ToTable("Settings", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.SettingManagement.SettingDefinitionRecord", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DefaultValue")
+                        .HasMaxLength(2048)
+                        .HasColumnType("character varying(2048)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("ExtraProperties")
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsEncrypted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsInherited")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsVisibleToClients")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Providers")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("SettingDefinitions", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.TenantManagement.Tenant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<int>("EntityVersion")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.HasIndex("NormalizedName");
+
+                    b.ToTable("Tenants", (string)null);
+                });
+
+            modelBuilder.Entity("Volo.Abp.TenantManagement.TenantConnectionString", b =>
+                {
+                    b.Property<Guid>("TenantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("TenantId", "Name");
+
+                    b.ToTable("TenantConnectionStrings", (string)null);
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzBlobTrigger", b =>
+                {
+                    b.HasOne("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", "Trigger")
+                        .WithMany("BlobTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzCronTrigger", b =>
+                {
+                    b.HasOne("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", "Trigger")
+                        .WithMany("CronTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzSimplePropertyTrigger", b =>
+                {
+                    b.HasOne("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", "Trigger")
+                        .WithMany("SimplePropertyTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzSimpleTrigger", b =>
+                {
+                    b.HasOne("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", "Trigger")
+                        .WithMany("SimpleTriggers")
+                        .HasForeignKey("SchedulerName", "TriggerName", "TriggerGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", b =>
+                {
+                    b.HasOne("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzJobDetail", "JobDetail")
+                        .WithMany("Triggers")
+                        .HasForeignKey("SchedulerName", "JobName", "JobGroup")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JobDetail");
+                });
+
+            modelBuilder.Entity("Unity.AI.Domain.AIOperation", b =>
+                {
+                    b.HasOne("Unity.AI.Domain.AIModel", "AIModel")
+                        .WithMany()
+                        .HasForeignKey("AIModelId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Unity.AI.Domain.AIPrompt", "AIPrompt")
+                        .WithMany()
+                        .HasForeignKey("AIPromptId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("AIModel");
+
+                    b.Navigation("AIPrompt");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GrantApplications.AIGenerationRequest", b =>
+                {
+                    b.HasOne("Unity.AI.Domain.AIOperation", null)
+                        .WithMany()
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.SubSector", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Locality.Sector", "Sector")
+                        .WithMany("SubSectors")
+                        .HasForeignKey("SectorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Sector");
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLogAction", b =>
+                {
+                    b.HasOne("Volo.Abp.AuditLogging.AuditLog", null)
+                        .WithMany("Actions")
+                        .HasForeignKey("AuditLogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.EntityChange", b =>
+                {
+                    b.HasOne("Volo.Abp.AuditLogging.AuditLog", null)
+                        .WithMany("EntityChanges")
+                        .HasForeignKey("AuditLogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.EntityPropertyChange", b =>
+                {
+                    b.HasOne("Volo.Abp.AuditLogging.EntityChange", null)
+                        .WithMany("PropertyChanges")
+                        .HasForeignKey("EntityChangeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityRoleClaim", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityRole", null)
+                        .WithMany("Claims")
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserClaim", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("Claims")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserLogin", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("Logins")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserOrganizationUnit", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.OrganizationUnit", null)
+                        .WithMany()
+                        .HasForeignKey("OrganizationUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("OrganizationUnits")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserPasskey", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("Passkeys")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("Volo.Abp.Identity.IdentityPasskeyData", "Data", b1 =>
+                        {
+                            b1.Property<byte[]>("IdentityUserPasskeyCredentialId");
+
+                            b1.Property<byte[]>("AttestationObject");
+
+                            b1.Property<byte[]>("ClientDataJson");
+
+                            b1.Property<DateTimeOffset>("CreatedAt");
+
+                            b1.Property<bool>("IsBackedUp");
+
+                            b1.Property<bool>("IsBackupEligible");
+
+                            b1.Property<bool>("IsUserVerified");
+
+                            b1.Property<string>("Name");
+
+                            b1.Property<byte[]>("PublicKey");
+
+                            b1.Property<long>("SignCount");
+
+                            b1.PrimitiveCollection<string>("Transports");
+
+                            b1.HasKey("IdentityUserPasskeyCredentialId");
+
+                            b1.ToTable("UserPasskeys");
+
+                            b1
+                                .ToJson("Data")
+                                .HasColumnType("jsonb");
+
+                            b1.WithOwner()
+                                .HasForeignKey("IdentityUserPasskeyCredentialId");
+                        });
+
+                    b.Navigation("Data");
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserPasswordHistory", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("PasswordHistories")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserRole", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("Roles")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUserToken", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.IdentityUser", null)
+                        .WithMany("Tokens")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.OrganizationUnit", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.OrganizationUnit", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId");
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.OrganizationUnitRole", b =>
+                {
+                    b.HasOne("Volo.Abp.Identity.OrganizationUnit", null)
+                        .WithMany("Roles")
+                        .HasForeignKey("OrganizationUnitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Volo.Abp.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Volo.Abp.TenantManagement.TenantConnectionString", b =>
+                {
+                    b.HasOne("Volo.Abp.TenantManagement.Tenant", null)
+                        .WithMany("ConnectionStrings")
+                        .HasForeignKey("TenantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzJobDetail", b =>
+                {
+                    b.Navigation("Triggers");
+                });
+
+            modelBuilder.Entity("AppAny.Quartz.EntityFrameworkCore.Migrations.QuartzTrigger", b =>
+                {
+                    b.Navigation("BlobTriggers");
+
+                    b.Navigation("CronTriggers");
+
+                    b.Navigation("SimplePropertyTriggers");
+
+                    b.Navigation("SimpleTriggers");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Locality.Sector", b =>
+                {
+                    b.Navigation("SubSectors");
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.AuditLog", b =>
+                {
+                    b.Navigation("Actions");
+
+                    b.Navigation("EntityChanges");
+                });
+
+            modelBuilder.Entity("Volo.Abp.AuditLogging.EntityChange", b =>
+                {
+                    b.Navigation("PropertyChanges");
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityRole", b =>
+                {
+                    b.Navigation("Claims");
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.IdentityUser", b =>
+                {
+                    b.Navigation("Claims");
+
+                    b.Navigation("Logins");
+
+                    b.Navigation("OrganizationUnits");
+
+                    b.Navigation("Passkeys");
+
+                    b.Navigation("PasswordHistories");
+
+                    b.Navigation("Roles");
+
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("Volo.Abp.Identity.OrganizationUnit", b =>
+                {
+                    b.Navigation("Roles");
+                });
+
+            modelBuilder.Entity("Volo.Abp.TenantManagement.Tenant", b =>
+                {
+                    b.Navigation("ConnectionStrings");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
new file mode 100644
index 0000000000..941b46a531
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -0,0 +1,21 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.HostMigrations
+{
+    /// <inheritdoc />
+    public partial class RefreshAiSchema : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
index 822f2a4b2e..fb414ed178 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
@@ -467,7 +467,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("qrtz_triggers", (string)null);
                 });
 
-            modelBuilder.Entity("Unity.AI.Domain.AIPrompt", b =>
+            modelBuilder.Entity("Unity.AI.Domain.AIModel", b =>
                 {
                     b.Property<Guid>("Id")
                         .HasColumnType("uuid");
@@ -487,10 +487,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("CreatorId");
 
-                    b.Property<string>("Description")
-                        .HasMaxLength(2000)
-                        .HasColumnType("character varying(2000)");
-
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -512,26 +508,32 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasMaxLength(200)
                         .HasColumnType("character varying(200)");
 
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
+                    b.Property<string>("SettingsJson")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
 
                     b.HasKey("Id");
 
                     b.HasIndex("Name")
                         .IsUnique();
 
-                    b.ToTable("AIPrompts", "AI");
+                    b.ToTable("AIModels", "AI");
                 });
 
-            modelBuilder.Entity("Unity.AI.Domain.AIPromptVersion", b =>
+            modelBuilder.Entity("Unity.AI.Domain.AIOperation", b =>
                 {
                     b.Property<Guid>("Id")
                         .HasColumnType("uuid");
 
+                    b.Property<Guid>("AIModelId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AIPromptId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("CompletionTokens")
+                        .HasColumnType("integer");
+
                     b.Property<string>("ConcurrencyStamp")
                         .IsConcurrencyToken()
                         .IsRequired()
@@ -547,18 +549,17 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("CreatorId");
 
-                    b.Property<string>("DeveloperNotes")
-                        .HasColumnType("text");
+                    b.Property<string>("ExecutionMode")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
 
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
                         .HasColumnName("ExtraProperties");
 
-                    b.Property<bool>("IsDeprecated")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsPublished")
+                    b.Property<bool>("IsActive")
                         .HasColumnType("boolean");
 
                     b.Property<DateTime?>("LastModificationTime")
@@ -569,35 +570,76 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("LastModifierId");
 
-                    b.Property<int?>("MaxTokens")
-                        .HasColumnType("integer");
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
 
-                    b.Property<string>("MetadataJson")
-                        .HasColumnType("jsonb");
+                    b.HasKey("Id");
+
+                    b.HasIndex("AIModelId");
+
+                    b.HasIndex("AIPromptId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("AIOperations", "AI");
+                });
 
-                    b.Property<Guid>("PromptId")
+            modelBuilder.Entity("Unity.AI.Domain.AIPrompt", b =>
+                {
+                    b.Property<Guid>("Id")
                         .HasColumnType("uuid");
 
-                    b.Property<string>("SystemPrompt")
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
                         .IsRequired()
-                        .HasColumnType("text");
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
 
-                    b.Property<string>("TargetModel")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
 
-                    b.Property<string>("TargetProvider")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MetadataJson")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
 
-                    b.Property<double>("Temperature")
-                        .HasColumnType("double precision");
+                    b.Property<string>("SystemPrompt")
+                        .IsRequired()
+                        .HasColumnType("text");
 
                     b.Property<Guid?>("TenantId")
                         .HasColumnType("uuid")
                         .HasColumnName("TenantId");
 
-                    b.Property<string>("UserPromptTemplate")
+                    b.Property<string>("UserPrompt")
                         .IsRequired()
                         .HasColumnType("text");
 
@@ -606,10 +648,10 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
-                    b.HasIndex("PromptId", "VersionNumber")
-                        .IsUnique();
+                    b.HasIndex("TenantId", "Name", "VersionNumber")
+                        .IsUnique();
 
-                    b.ToTable("AIPromptVersions", "AI");
+                    b.ToTable("AIPrompts", "AI");
                 });
 
             modelBuilder.Entity("Unity.GrantManager.Applicants.ApplicantTenantMap", b =>
@@ -718,10 +760,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("LastModifierId");
 
-                    b.Property<string>("OperationType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
 
                     b.Property<string>("RequestKey")
                         .IsRequired()
@@ -740,9 +780,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasKey("Id");
 
+                    b.HasIndex("OperationId");
+
                     b.HasIndex("RequestKey");
 
-                    b.HasIndex("TenantId", "ApplicationId", "OperationType", "Status");
+                    b.HasIndex("TenantId", "ApplicationId", "OperationId", "Status");
 
                     b.ToTable("AIRequests", "AI");
                 });
@@ -3031,15 +3073,32 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("JobDetail");
                 });
 
-            modelBuilder.Entity("Unity.AI.Domain.AIPromptVersion", b =>
+            modelBuilder.Entity("Unity.AI.Domain.AIOperation", b =>
                 {
-                    b.HasOne("Unity.AI.Domain.AIPrompt", "Prompt")
-                        .WithMany("Versions")
-                        .HasForeignKey("PromptId")
-                        .OnDelete(DeleteBehavior.Cascade)
+                    b.HasOne("Unity.AI.Domain.AIModel", "AIModel")
+                        .WithMany()
+                        .HasForeignKey("AIModelId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Unity.AI.Domain.AIPrompt", "AIPrompt")
+                        .WithMany()
+                        .HasForeignKey("AIPromptId")
+                        .OnDelete(DeleteBehavior.Restrict)
                         .IsRequired();
 
-                    b.Navigation("Prompt");
+                    b.Navigation("AIModel");
+
+                    b.Navigation("AIPrompt");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GrantApplications.AIGenerationRequest", b =>
+                {
+                    b.HasOne("Unity.AI.Domain.AIOperation", null)
+                        .WithMany()
+                        .HasForeignKey("OperationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
                 });
 
             modelBuilder.Entity("Unity.GrantManager.Locality.SubSector", b =>
@@ -3249,11 +3308,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("SimpleTriggers");
                 });
 
-            modelBuilder.Entity("Unity.AI.Domain.AIPrompt", b =>
-                {
-                    b.Navigation("Versions");
-                });
-
             modelBuilder.Entity("Unity.GrantManager.Locality.Sector", b =>
                 {
                     b.Navigation("SubSectors");

From 804f187ba3621f2cc74f1d23e831cab4313caba2 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 08:40:48 -0700
Subject: [PATCH 04/61] AB#32307 fix AI generation test regressions

---
 .../Prompts/AIPromptVersionAppService.cs                  | 1 -
 .../GrantApplications/AIGenerationStatusAppService.cs     | 8 +++-----
 .../Automation/ApplicationAIGenerationQueue.cs            | 5 ++++-
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
index 7084c9cc10..c213c5067d 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
@@ -85,7 +85,6 @@ public override async Task<AIPromptVersionDto> CreateAsync(CreateUpdateAIPromptV
                     input.SystemPrompt,
                     input.UserPrompt)
                 {
-                    TenantId = prompt.TenantId,
                     MetadataJson = input.MetadataJson,
                     IsActive = input.IsActive
                 });
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index 92b930052c..1162fbea33 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -62,13 +62,11 @@ public class AIGenerationStatusAppService(
     private async Task<AIOperation?> ResolveOperationAsync(string operationName)
     {
         var operations = await operationRepository.GetQueryableAsync();
-        var activeOperations = operations
-            .Where(operation => operation.IsActive)
-            .ToList();
+        var allOperations = (operations ?? Enumerable.Empty<AIOperation>()).ToList();
 
-        return activeOperations.FirstOrDefault(operation =>
+        return allOperations.FirstOrDefault(operation =>
                    string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
-               ?? activeOperations.FirstOrDefault(operation =>
+               ?? allOperations.FirstOrDefault(operation =>
                    string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index d564ccba88..3a891123af 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -187,7 +187,10 @@ private static string ResolveOperationName(string operationType)
     private async Task<AIOperation> ResolveOperationAsync(string operationType)
     {
         var operationName = ResolveOperationName(operationType);
-        var activeOperations = await operationRepository.GetListAsync(operation => operation.IsActive);
+        var operations = await operationRepository.GetQueryableAsync();
+        var activeOperations = (operations ?? Enumerable.Empty<AIOperation>())
+            .Where(operation => operation.IsActive)
+            .ToList();
 
         var operation = activeOperations.FirstOrDefault(operation =>
             string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))

From 73e444606c9cb0b370245db09ffff14094d05fc8 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 09:15:24 -0700
Subject: [PATCH 05/61] AB#32307 address Copilot review fixes

---
 .../AI/Runtime/AIPromptTemplateProvider.cs           |  3 ++-
 .../Prompts/AIPromptVersionAppService.cs             |  3 ++-
 .../Automation/ApplicationAIGenerationQueue.cs       | 12 ++++++++----
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
index d744c67c6b..c502fd5de6 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIPromptTemplateProvider.cs
@@ -23,7 +23,8 @@ public async Task<AIPromptTemplateSnapshot> GetRequiredPromptAsync(
 
         using (multiTenantDataFilter.Disable())
         {
-            var prompt = await promptRepository.FindAsync(p => p.Name == promptType && p.VersionNumber == versionNumber);
+            var prompt = await promptRepository.FindAsync(p =>
+                p.TenantId == null && p.Name == promptType && p.VersionNumber == versionNumber);
             if (prompt == null || !prompt.IsActive)
             {
                 throw new InvalidOperationException(
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
index c213c5067d..94349658ee 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
@@ -83,7 +83,8 @@ public override async Task<AIPromptVersionDto> CreateAsync(CreateUpdateAIPromptV
                     prompt.Name,
                     input.VersionNumber,
                     input.SystemPrompt,
-                    input.UserPrompt)
+                    input.UserPrompt,
+                    prompt.TenantId)
                 {
                     MetadataJson = input.MetadataJson,
                     IsActive = input.IsActive
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index 3a891123af..e847a57a5b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -188,13 +188,12 @@ private async Task<AIOperation> ResolveOperationAsync(string operationType)
     {
         var operationName = ResolveOperationName(operationType);
         var operations = await operationRepository.GetQueryableAsync();
-        var activeOperations = (operations ?? Enumerable.Empty<AIOperation>())
-            .Where(operation => operation.IsActive)
+        var allOperations = (operations ?? Enumerable.Empty<AIOperation>())
             .ToList();
 
-        var operation = activeOperations.FirstOrDefault(operation =>
+        var operation = allOperations.FirstOrDefault(operation =>
             string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
-            ?? activeOperations.FirstOrDefault(operation =>
+            ?? allOperations.FirstOrDefault(operation =>
                 string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
 
         if (operation == null)
@@ -202,6 +201,11 @@ private async Task<AIOperation> ResolveOperationAsync(string operationType)
             throw new UserFriendlyException($"AI operation '{operationType}' is not configured.");
         }
 
+        if (!operation.IsActive)
+        {
+            throw new UserFriendlyException($"AI operation '{operationType}' is not configured.");
+        }
+
         return operation;
     }
 

From c971382f08ff73f045b08aaa8bef76f84f2e1d11 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 09:22:53 -0700
Subject: [PATCH 06/61] AB#32307 fix payload validator formatting

---
 .../AI/Runtime/AIProviderPayloadValidator.cs         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
index 99ecee6f77..eabab49597 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
@@ -26,12 +26,12 @@ public static AIResponseValidationResult ValidateApplicationAnalysisJson(string
                 return AIResponseValidationResult.Invalid($"Application analysis response is missing or invalid required field '{AIJsonKeys.Decision}' (expected string).");
             }
 
-             var normalizedDecision = (decision.GetString() ?? string.Empty).Trim().ToUpperInvariant();
-             if (normalizedDecision != "PROCEED" && normalizedDecision != "HOLD")
-             {
-                 return AIResponseValidationResult.Invalid(
-                     $"Application analysis response has invalid '{AIJsonKeys.Decision}' value. Expected 'PROCEED' or 'HOLD'.");
-             }
+            var normalizedDecision = (decision.GetString() ?? string.Empty).Trim().ToUpperInvariant();
+            if (normalizedDecision != "PROCEED" && normalizedDecision != "HOLD")
+            {
+                return AIResponseValidationResult.Invalid(
+                    $"Application analysis response has invalid '{AIJsonKeys.Decision}' value. Expected 'PROCEED' or 'HOLD'.");
+            }
 
             if (!root.TryGetProperty(AIJsonKeys.Errors, out var errors) || errors.ValueKind != JsonValueKind.Array)
             {

From e471a5285d3472e2c8aff8a6325646bbb54adc99 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 09:40:35 -0700
Subject: [PATCH 07/61] AB#32307 add forward AI schema repair migration

---
 ...0618203824_AddUniqueIndexToAIPromptName.cs |  17 +--
 .../20260624191335_RefreshAiSchema.cs         | 138 ++++++++++++++++++
 2 files changed, 141 insertions(+), 14 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
index 68c43ad654..75b13a5f7e 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618203824_AddUniqueIndexToAIPromptName.cs
@@ -10,22 +10,11 @@ public partial class AddUniqueIndexToAIPromptName : Migration
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
-            migrationBuilder.Sql(
-                """
-                ALTER TABLE "AI"."AIPrompts"
-                ADD COLUMN IF NOT EXISTS "VersionNumber" integer NOT NULL DEFAULT 1;
-                """);
-
-            migrationBuilder.Sql(
-                """
-                DROP INDEX IF EXISTS "AI"."IX_AIPrompts_Name";
-                """);
-
             migrationBuilder.CreateIndex(
-                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
+                name: "IX_AIPrompts_Name",
                 schema: "AI",
                 table: "AIPrompts",
-                columns: new[] { "TenantId", "Name", "VersionNumber" },
+                column: "Name",
                 unique: true);
         }
 
@@ -33,7 +22,7 @@ ALTER TABLE "AI"."AIPrompts"
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropIndex(
-                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
+                name: "IX_AIPrompts_Name",
                 schema: "AI",
                 table: "AIPrompts");
         }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 941b46a531..1bc60b6449 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -11,11 +11,149 @@ public partial class RefreshAiSchema : Migration
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.Sql(
+                """
+                DROP INDEX IF EXISTS "AI"."IX_AIPrompts_Name";
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ADD COLUMN IF NOT EXISTS "OperationId" uuid;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                UPDATE "AI"."AIRequests" r
+                SET "OperationId" = o."Id"
+                FROM "AI"."AIOperations" o
+                WHERE r."OperationId" IS NULL
+                  AND (
+                      (r."OperationType" = 'application-analysis' AND o."Name" = 'ApplicationAnalysis')
+                      OR (r."OperationType" = 'attachment-summary' AND o."Name" = 'AttachmentSummary')
+                      OR (r."OperationType" = 'application-scoring' AND o."Name" = 'ApplicationScoring')
+                      OR (r."OperationType" = 'pipeline' AND o."Name" = 'Default')
+                  );
+                """);
+
+            migrationBuilder.Sql(
+                """
+                DO $$
+                BEGIN
+                    IF EXISTS (
+                        SELECT 1
+                        FROM "AI"."AIRequests"
+                        WHERE "OperationId" IS NULL
+                    ) THEN
+                        RAISE EXCEPTION 'AIRequests contains rows that cannot be mapped to OperationId.';
+                    END IF;
+                END $$;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ALTER COLUMN "OperationId" SET NOT NULL;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                DROP INDEX IF EXISTS "AI"."IX_AIRequests_TenantId_ApplicationId_OperationType_Status";
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                DROP COLUMN IF EXISTS "OperationType";
+                """);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIRequests_TenantId_ApplicationId_OperationId_Status",
+                schema: "AI",
+                table: "AIRequests",
+                columns: new[] { "TenantId", "ApplicationId", "OperationId", "Status" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AIRequests_OperationId",
+                schema: "AI",
+                table: "AIRequests",
+                column: "OperationId");
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ADD CONSTRAINT "FK_AIRequests_AIOperations_OperationId"
+                FOREIGN KEY ("OperationId") REFERENCES "AI"."AIOperations" ("Id") ON DELETE RESTRICT;
+                """);
         }
 
         /// <inheritdoc />
         protected override void Down(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.Sql(
+                """
+                DROP INDEX IF EXISTS "AI"."IX_AIRequests_TenantId_ApplicationId_OperationType_Status";
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                DROP CONSTRAINT IF EXISTS "FK_AIRequests_AIOperations_OperationId";
+                """);
+
+            migrationBuilder.DropIndex(
+                name: "IX_AIRequests_OperationId",
+                schema: "AI",
+                table: "AIRequests");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AIRequests_TenantId_ApplicationId_OperationId_Status",
+                schema: "AI",
+                table: "AIRequests");
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ADD COLUMN IF NOT EXISTS "OperationType" character varying(64) NOT NULL DEFAULT '';
+                """);
+
+            migrationBuilder.Sql(
+                """
+                UPDATE "AI"."AIRequests"
+                SET "OperationType" = CASE
+                    WHEN "OperationId" IS NOT NULL THEN
+                        COALESCE(
+                            (SELECT CASE o."Name"
+                                WHEN 'ApplicationAnalysis' THEN 'application-analysis'
+                                WHEN 'AttachmentSummary' THEN 'attachment-summary'
+                                WHEN 'ApplicationScoring' THEN 'application-scoring'
+                                WHEN 'Default' THEN 'pipeline'
+                            END
+                            FROM "AI"."AIOperations" o
+                            WHERE o."Id" = "OperationId"),
+                            'application-analysis'
+                        )
+                    ELSE 'application-analysis'
+                END;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ALTER COLUMN "OperationType" DROP DEFAULT;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                ALTER TABLE "AI"."AIRequests"
+                ALTER COLUMN "OperationType" SET NOT NULL;
+                """);
+
+            migrationBuilder.Sql(
+                """
+                CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIRequests_TenantId_ApplicationId_OperationType_Status"
+                ON "AI"."AIRequests" ("TenantId", "ApplicationId", "OperationType", "Status");
+                """);
         }
     }
 }

From b4c9154f6b01bd19ab0a97f7caf0765b0f58d37f Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 10:11:48 -0700
Subject: [PATCH 08/61] AB#32307 tighten AI operation resolution

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs      | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index a1fbefa6dc..be191ce6f3 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -201,13 +201,19 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
 
     private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
-        var activeOperations = await _operationRepository.GetListAsync(operation => operation.IsActive);
+        var operations = await _operationRepository.GetListAsync();
+        var activeOperations = operations.Where(operation => operation.IsActive).ToList();
 
-        var specificOperation = activeOperations.FirstOrDefault(operation =>
+        var configuredOperation = operations.FirstOrDefault(operation =>
             string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
-        if (specificOperation != null)
+        if (configuredOperation != null)
         {
-            return specificOperation;
+            if (!configuredOperation.IsActive)
+            {
+                return null;
+            }
+
+            return configuredOperation;
         }
 
         return activeOperations.FirstOrDefault(operation =>

From c3bbf2c7a95000c0405a7ed810ee4a960e1090ef Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 26 Jun 2026 14:38:32 -0700
Subject: [PATCH 09/61] AB#32307 restore historical AI migrations

---
 .../20260324221338_AddAIPromptTables.cs       | 102 +++--------
 ...18210000_RefreshBuiltInAIPromptVersions.cs | 159 ++++++++++++++++++
 2 files changed, 182 insertions(+), 79 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
index 2f973c1542..e390d9dc19 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260324221338_AddAIPromptTables.cs
@@ -22,11 +22,8 @@ protected override void Up(MigrationBuilder migrationBuilder)
                     Id = table.Column<Guid>(type: "uuid", nullable: false),
                     TenantId = table.Column<Guid>(type: "uuid", nullable: true),
                     Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    VersionNumber = table.Column<int>(type: "integer", nullable: false),
-                    SystemPrompt = table.Column<string>(type: "text", nullable: false),
-                    UserPrompt = table.Column<string>(type: "text", nullable: false),
-                    MetadataJson = table.Column<string>(type: "jsonb", nullable: true),
-                    SeedHash = table.Column<string>(type: "character varying(64)", maxLength: 64, nullable: true),
+                    Description = table.Column<string>(type: "character varying(2000)", maxLength: 2000, nullable: true),
+                    Type = table.Column<int>(type: "integer", nullable: false),
                     IsActive = table.Column<bool>(type: "boolean", nullable: false),
                     ExtraProperties = table.Column<string>(type: "text", nullable: false),
                     ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
@@ -41,54 +38,24 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 });
 
             migrationBuilder.CreateTable(
-                name: "AIModels",
+                name: "AIPromptVersions",
                 schema: "AI",
                 columns: table => new
                 {
                     Id = table.Column<Guid>(type: "uuid", nullable: false),
                     TenantId = table.Column<Guid>(type: "uuid", nullable: true),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    IsActive = table.Column<bool>(type: "boolean", nullable: false),
-                    SettingsJson = table.Column<string>(type: "jsonb", nullable: false),
-                    ExtraProperties = table.Column<string>(type: "text", nullable: false),
-                    ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
-                    CreationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
-                    CreatorId = table.Column<Guid>(type: "uuid", nullable: true),
-                    LastModificationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: true),
-                    LastModifierId = table.Column<Guid>(type: "uuid", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_AIModels", x => x.Id);
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AIPrompts_TenantId_Name_VersionNumber",
-                schema: "AI",
-                table: "AIPrompts",
-                columns: new[] { "TenantId", "Name", "VersionNumber" },
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AIModels_Name",
-                schema: "AI",
-                table: "AIModels",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateTable(
-                name: "AIOperations",
-                schema: "AI",
-                columns: table => new
-                {
-                    Id = table.Column<Guid>(type: "uuid", nullable: false),
-                    TenantId = table.Column<Guid>(type: "uuid", nullable: true),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    AIModelId = table.Column<Guid>(type: "uuid", nullable: false),
-                    AIPromptId = table.Column<Guid>(type: "uuid", nullable: false),
-                    ExecutionMode = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
-                    CompletionTokens = table.Column<int>(type: "integer", nullable: false),
-                    IsActive = table.Column<bool>(type: "boolean", nullable: false),
+                    PromptId = table.Column<Guid>(type: "uuid", nullable: false),
+                    VersionNumber = table.Column<int>(type: "integer", nullable: false),
+                    SystemPrompt = table.Column<string>(type: "text", nullable: false),
+                    UserPromptTemplate = table.Column<string>(type: "text", nullable: false),
+                    DeveloperNotes = table.Column<string>(type: "text", nullable: true),
+                    TargetModel = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
+                    TargetProvider = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
+                    Temperature = table.Column<double>(type: "double precision", nullable: false),
+                    MaxTokens = table.Column<int>(type: "integer", nullable: true),
+                    IsPublished = table.Column<bool>(type: "boolean", nullable: false),
+                    IsDeprecated = table.Column<bool>(type: "boolean", nullable: false),
+                    MetadataJson = table.Column<string>(type: "jsonb", nullable: true),
                     ExtraProperties = table.Column<string>(type: "text", nullable: false),
                     ConcurrencyStamp = table.Column<string>(type: "character varying(40)", maxLength: 40, nullable: false),
                     CreationTime = table.Column<DateTime>(type: "timestamp without time zone", nullable: false),
@@ -98,40 +65,21 @@ protected override void Up(MigrationBuilder migrationBuilder)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("PK_AIOperations", x => x.Id);
+                    table.PrimaryKey("PK_AIPromptVersions", x => x.Id);
                     table.ForeignKey(
-                        name: "FK_AIOperations_AIModels_AIModelId",
-                        column: x => x.AIModelId,
-                        principalSchema: "AI",
-                        principalTable: "AIModels",
-                        principalColumn: "Id",
-                        onDelete: ReferentialAction.Restrict);
-                    table.ForeignKey(
-                        name: "FK_AIOperations_AIPrompts_AIPromptId",
-                        column: x => x.AIPromptId,
+                        name: "FK_AIPromptVersions_AIPrompts_PromptId",
+                        column: x => x.PromptId,
                         principalSchema: "AI",
                         principalTable: "AIPrompts",
                         principalColumn: "Id",
-                        onDelete: ReferentialAction.Restrict);
+                        onDelete: ReferentialAction.Cascade);
                 });
 
             migrationBuilder.CreateIndex(
-                name: "IX_AIOperations_AIModelId",
-                schema: "AI",
-                table: "AIOperations",
-                column: "AIModelId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AIOperations_AIPromptId",
+                name: "IX_AIPromptVersions_PromptId_VersionNumber",
                 schema: "AI",
-                table: "AIOperations",
-                column: "AIPromptId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AIOperations_Name",
-                schema: "AI",
-                table: "AIOperations",
-                column: "Name",
+                table: "AIPromptVersions",
+                columns: new[] { "PromptId", "VersionNumber" },
                 unique: true);
         }
 
@@ -139,11 +87,7 @@ protected override void Up(MigrationBuilder migrationBuilder)
         protected override void Down(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.DropTable(
-                name: "AIOperations",
-                schema: "AI");
-
-            migrationBuilder.DropTable(
-                name: "AIModels",
+                name: "AIPromptVersions",
                 schema: "AI");
 
             migrationBuilder.DropTable(
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
index 4aacd26ff8..7efc8de94b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260618210000_RefreshBuiltInAIPromptVersions.cs
@@ -1,18 +1,177 @@
+using Microsoft.EntityFrameworkCore.Infrastructure;
 using Microsoft.EntityFrameworkCore.Migrations;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using Unity.GrantManager.EntityFrameworkCore;
 
 #nullable disable
 
 namespace Unity.GrantManager.Migrations.HostMigrations
 {
+    [DbContext(typeof(GrantManagerDbContext))]
     [Migration("20260618210000_RefreshBuiltInAIPromptVersions")]
     public partial class RefreshBuiltInAIPromptVersions : Migration
     {
+        private static readonly Guid AnalysisPromptId = new("4a100001-1000-4000-a000-000000000001");
+        private static readonly Guid AttachmentPromptId = new("4a100001-1000-4000-a000-000000000002");
+        private static readonly Guid ScoringPromptId = new("4a100001-1000-4000-a000-000000000003");
+
         protected override void Up(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.Sql(
+                """
+                UPDATE "AI"."AIPrompts"
+                SET "Name" = 'ApplicationAnalysis',
+                    "Description" = 'Grant application analysis and review',
+                    "Type" = 1,
+                    "IsActive" = TRUE
+                WHERE "Id" = '4a100001-1000-4000-a000-000000000001';
+
+                UPDATE "AI"."AIPrompts"
+                SET "Name" = 'AttachmentSummary',
+                    "Description" = 'Attachment summarization for grant review',
+                    "Type" = 1,
+                    "IsActive" = TRUE
+                WHERE "Id" = '4a100001-1000-4000-a000-000000000002';
+
+                UPDATE "AI"."AIPrompts"
+                SET "Name" = 'ApplicationScoring',
+                    "Description" = 'Scoresheet section answering assistant',
+                    "Type" = 1,
+                    "IsActive" = TRUE
+                WHERE "Id" = '4a100001-1000-4000-a000-000000000003';
+                """);
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                AnalysisPromptId,
+                0,
+                ReadPromptFile("v0", "application-analysis.system.txt"),
+                ReadPromptFile("v0", "application-analysis.user.txt"),
+                "v0 - initial single-file analysis prompt",
+                null);
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                AnalysisPromptId,
+                1,
+                ReadPromptFile("v1", "application-analysis.system.txt"),
+                ReadPromptFile("v1", "application-analysis.user.txt"),
+                "v1 - modular prompt with separate rubric, score, output, and rules sections",
+                BuildSectionsJson(new Dictionary<string, string>
+                {
+                    ["RUBRIC"] = ReadPromptFile("v1", "application-analysis.rubric.txt"),
+                    ["SCORE"] = ReadPromptFile("v1", "application-analysis.score.txt"),
+                    ["OUTPUT"] = ReadPromptFile("v1", "application-analysis.output.txt"),
+                    ["RULES"] = ReadPromptFile("v1", "application-analysis.rules.txt"),
+                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
+                }));
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                AttachmentPromptId,
+                0,
+                ReadPromptFile("v0", "attachment-summary.system.txt"),
+                ReadPromptFile("v0", "attachment-summary.user.txt"),
+                "v0 - initial single-file attachment prompt",
+                null);
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                AttachmentPromptId,
+                1,
+                ReadPromptFile("v1", "attachment-summary.system.txt"),
+                ReadPromptFile("v1", "attachment-summary.user.txt"),
+                "v1 - modular prompt with separate output and rules sections",
+                BuildSectionsJson(new Dictionary<string, string>
+                {
+                    ["OUTPUT"] = ReadPromptFile("v1", "attachment-summary.output.txt"),
+                    ["RULES"] = ReadPromptFile("v1", "attachment-summary.rules.txt"),
+                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
+                }));
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                ScoringPromptId,
+                0,
+                ReadPromptFile("v0", "application-scoring.system.txt"),
+                ReadPromptFile("v0", "application-scoring.user.txt"),
+                "v0 - initial single-file scoresheet prompt",
+                null);
+
+            UpdatePromptVersion(
+                migrationBuilder,
+                ScoringPromptId,
+                1,
+                ReadPromptFile("v1", "application-scoring.system.txt"),
+                ReadPromptFile("v1", "application-scoring.user.txt"),
+                "v1 - modular prompt with separate output and rules sections",
+                BuildSectionsJson(new Dictionary<string, string>
+                {
+                    ["OUTPUT"] = ReadPromptFile("v1", "application-scoring.output.txt"),
+                    ["RULES"] = ReadPromptFile("v1", "application-scoring.rules.txt"),
+                    ["COMMON_RULES"] = ReadPromptFile("v1", "common.rules.txt")
+                }));
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)
         {
+            // No-op: prompt version content is managed by seeded defaults.
+        }
+
+        private static void UpdatePromptVersion(
+            MigrationBuilder migrationBuilder,
+            Guid promptId,
+            int versionNumber,
+            string systemPrompt,
+            string userPromptTemplate,
+            string developerNotes,
+            string metadataJson)
+        {
+            migrationBuilder.Sql($"""
+                UPDATE "AI"."AIPromptVersions"
+                SET "SystemPrompt" = '{EscapeSqlLiteral(systemPrompt)}',
+                    "UserPromptTemplate" = '{EscapeSqlLiteral(userPromptTemplate)}',
+                    "DeveloperNotes" = '{EscapeSqlLiteral(developerNotes)}',
+                    "IsPublished" = TRUE,
+                    "IsDeprecated" = FALSE,
+                    "MetadataJson" = {FormatNullableSqlString(metadataJson)}
+                WHERE "PromptId" = '{promptId}'
+                  AND "VersionNumber" = {versionNumber};
+                """);
+        }
+
+        private static string ReadPromptFile(string version, string fileName)
+        {
+            var path = Path.Combine(AppContext.BaseDirectory, "AI", "Prompts", "Versions", version, fileName);
+            if (!File.Exists(path))
+            {
+                throw new InvalidOperationException($"Missing prompt asset required by migration: {path}");
+            }
+
+            return File.ReadAllText(path);
+        }
+
+        private static string BuildSectionsJson(Dictionary<string, string> sections)
+        {
+            return JsonSerializer.Serialize(new { sections });
+        }
+
+        private static string EscapeSqlLiteral(string value)
+        {
+            return value.Replace("'", "''", StringComparison.Ordinal);
+        }
+
+        private static string FormatNullableSqlString(string value)
+        {
+            if (value == null)
+            {
+                return "NULL";
+            }
+
+            return $"'{EscapeSqlLiteral(value)}'";
         }
     }
 }

From b83aa896bbbe826b2e10af9033e81f43326157b6 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 29 Jun 2026 09:57:16 -0700
Subject: [PATCH 10/61] [AB#33555] Add ExternalStatusVisibility to Applications
 and UI

---
 .../CreateUpdateApplicationResultsDto.cs      |    3 +-
 .../GrantApplications/GrantApplicationDto.cs  |    1 +
 .../GrantApplicationAppService.cs             |    5 +-
 .../appsettings.json                          |    6 +-
 .../Localization/GrantManager/en.json         |    1 +
 .../Applications/Application.cs               |    5 +-
 ...lStatusVisibilityToApplication.Designer.cs | 5230 +++++++++++++++++
 ...ddExternalStatusVisibilityToApplication.cs |   29 +
 .../GrantTenantDbContextModelSnapshot.cs      |  253 +-
 .../AssessmentResults/AssessmentResults.cs    |    1 +
 .../AssessmentResultsViewModel.cs             |    3 +
 .../AssessmentResults/Default.cshtml          |    5 +
 .../Components/AssessmentResults/Default.js   |    3 +-
 13 files changed, 5442 insertions(+), 103 deletions(-)
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
index d399a559a4..578a7e8295 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
@@ -20,6 +20,7 @@ public class CreateUpdateAssessmentResultsDto : CustomDataFieldDto
         public decimal? RecommendedAmount { get; set; }
         public string? DeclineRational { get; set; }
         public string? AssessmentResultStatus { get; set; }
-        public string? RiskRanking { get; set;} 
+        public string? RiskRanking { get; set; }
+        public bool ExternalStatusVisibility { get; set; } = false;
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationDto.cs
index 53fda330fa..bcd98265cf 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationDto.cs
@@ -39,6 +39,7 @@ public class GrantApplicationDto : AuditedEntityDto<Guid>
     public string? DeclineRational { get; set; } = string.Empty;
     public string? Notes { get; set; } = string.Empty;
     public string? AssessmentResultStatus { get; set; } = string.Empty;
+    public bool ExternalStatusVisibility { get; set; } = false;
     public DateTime? AssessmentResultDate { get; set; }
     public GrantApplicationState StatusCode { get; set; }
     public DateTime? FinalDecisionDate { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 87a4db3b4b..651fabbab2 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -380,7 +380,8 @@ public async Task<GrantApplicationDto> UpdateAssessmentResultsAsync(Guid id, Cre
             input.LikelihoodOfFunding,
             input.TotalProjectBudget,
             input.NotificationDate,
-            input.RiskRanking
+            input.RiskRanking,
+            input.ExternalStatusVisibility
         );
 
         if (application.IsInFinalDecisionState())
@@ -508,6 +509,7 @@ private async Task SanitizeAssessmentResultsZoneInputs(CreateUpdateAssessmentRes
             input.DueDiligenceStatus ??= application.DueDiligenceStatus;
             input.AssessmentResultStatus ??= application.AssessmentResultStatus;
             input.DeclineRational ??= application.DeclineRational;
+            input.ExternalStatusVisibility = application.ExternalStatusVisibility;
 
             input.NotificationDate ??= application.NotificationDate;
             input.DueDate ??= application.DueDate;
@@ -522,6 +524,7 @@ private async Task SanitizeAssessmentResultsZoneInputs(CreateUpdateAssessmentRes
                 input.DueDiligenceStatus ??= application.DueDiligenceStatus;
                 input.AssessmentResultStatus ??= application.AssessmentResultStatus;
                 input.DeclineRational ??= application.DeclineRational;
+                input.ExternalStatusVisibility = application.ExternalStatusVisibility;
             }
         }
     }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
index 2d97676b33..9239fc32ef 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
@@ -1,8 +1,8 @@
 {
   "ConnectionStrings": {
-    "Default": "Host=localhost;port=5432;Database=UnityGrantManager;Username=postgres;",
-    "Tenant": "Host=localhost;port=5432;Database=UnityGrantTenant;Username=postgres;",
-    "Onboarding": "Host=localhost;port=5432;Database=Onboarding;Username=postgres;"
+    "Default": "Host=localhost;port=5435;Database=UnityGrantManager;Username=postgres;Password=admin",
+    "Tenant": "Host=localhost;port=5435;Database=UnityGrantTenant;Username=postgres;Password=admin",
+    "Onboarding": "Host=localhost;port=5435;Database=Onboarding;Username=postgres;Password=admin"
   },
   "StringEncryption": {
     "DefaultPassPhrase": "g2IuZx7PwXDvCmlW"
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
index ec090bfc29..17551a73fc 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
@@ -285,6 +285,7 @@
     "AssessmentResultsView:AssessmentResultsForm.DueDate": "Due Date",
     "AssessmentResultsView:AssessmentResultsForm.NotificationDate": "Notification Date",
     "AssessmentResultsView:AssessmentResultsForm.RiskRanking": "Risk Ranking",
+    "AssessmentResultsView:AssessmentResultsForm.Published": "Published",
 
     "GrantApplication:ActionButtonName": "Status Actions",
     "GrantApplication:ActionButton.RedStopWarning": "This application is from an applicant with a Red-Stop. Status actions are not permitted.",
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
index 7b82663d1e..70cc18a334 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
@@ -84,6 +84,8 @@ public virtual ApplicationStatus ApplicationStatus
 
     public string? SubStatus { get; set; }
 
+    public bool ExternalStatusVisibility { get; set; } = false;
+
     public string? DeclineRational { get; set; }
 
     public string? Notes { get; set; }
@@ -150,7 +152,7 @@ public bool IsInFinalDecisionState()
         return GrantApplicationStateGroups.FinalDecisionStates.Contains(ApplicationStatus.StatusCode);
     }
 
-    public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, string? likelihoodOfFunding, decimal? totalProjectBudget, DateTime? notificationDate, string? riskRanking)
+    public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, string? likelihoodOfFunding, decimal? totalProjectBudget, DateTime? notificationDate, string? riskRanking, bool externalStatusVisibility)
     {
         Notes = notes;
         SubStatus = subStatus;
@@ -158,6 +160,7 @@ public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, strin
         TotalProjectBudget = totalProjectBudget ?? 0;
         NotificationDate = notificationDate;
         RiskRanking = riskRanking;
+        ExternalStatusVisibility = externalStatusVisibility;
 
         // Recalculate percentage when TotalProjectBudget changes
         UpdatePercentageTotalProjectBudget();
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
new file mode 100644
index 0000000000..e1d38ed77f
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
@@ -0,0 +1,5230 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Unity.GrantManager.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    [DbContext(typeof(GrantTenantDbContext))]
+    [Migration("20260629164239_AB33555_AddExternalStatusVisibilityToApplication")]
+    partial class AB33555_AddExternalStatusVisibilityToApplication
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
+                .HasAnnotation("ProductVersion", "10.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("QuestionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScoresheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ScoresheetInstanceId");
+
+                    b.ToTable("Answers", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("Questions", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Scoresheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("CustomFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetInstanceId");
+
+                    b.ToTable("CustomFieldValues", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetCorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorksheetCorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorksheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<long?>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetLinks", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("CustomFields", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Worksheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicantName")
+                        .IsRequired()
+                        .HasMaxLength(600)
+                        .HasColumnType("character varying(600)");
+
+                    b.Property<string>("ApproxNumberOfEmployees")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FiscalDay")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FiscalMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingHistoryComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IndigenousOrgInd")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDuplicated")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IssueTrackingComments")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("MatchPercentage")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("NonRegOrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NonRegisteredBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrganizationType")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("RedStop")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportsComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Sector")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SectorSubSectorIndustryDesc")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("StartedOperatingDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubSector")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UnityApplicantId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantName");
+
+                    b.HasIndex("OrgName");
+
+                    b.HasIndex("OrgNumber");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SupplierId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UnityApplicantId");
+
+                    b.HasIndex("TenantId", "IsDeleted", "CreationTime")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applicants", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Postal")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street2")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicantAddresses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BceidBusinessGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("BceidUserGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidUserName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<int>("ContactOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IdentityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityProvider")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSubUser")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2Extension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneExtension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleForApplicant")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicantAgents", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ApplicantAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AIAnalysis")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AIScoresheetAnswers")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Acquisition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicantElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("AssessmentResultDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AssessmentResultStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("AssessmentStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Community")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("CommunityPopulation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime?>("ContractExecutionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DeclineRational")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DefaultSiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("DueDiligenceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EconomicRegion")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ExternalStatusVisibility")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("FinalDecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Forestry")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ForestryFocus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LikelihoodOfFunding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("NotificationDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("jsonb");
+
+                    b.Property<double?>("PercentageTotalProjectBudget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Place")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProjectEndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ProjectFundingTotal")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ProjectName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("ProjectStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ProjectSummary")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProposalDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal>("RecommendedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RegionalDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("RequestedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RiskRanking")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityBusinessPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityCellPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityFullName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal>("TotalProjectBudget")
+                        .HasColumnType("numeric");
+
+                    b.Property<int?>("TotalScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UnityApplicationId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.HasIndex("ApplicationStatusId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ReferenceNo");
+
+                    b.HasIndex("TenantId", "SubmissionDate")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applications", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssigneeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Duty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssigneeId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationAssignments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AISummary")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsFileId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsSubmissionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationChefsFileAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContactEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactFullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactMobilePhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactWorkPhone")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationContact", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApiKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("AttemptedConnectionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("AutomaticallyGenerateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Category")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsCriteriaFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ConnectionHttpStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("DefaultPaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<int?>("ElectoralDistrictAddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FormHierarchy")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("IntakeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsDirectApproval")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("ManuallyInitiateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ParentFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Payable")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("PaymentApprovalThreshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Prefix")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<bool>("PreventPayment")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("SuffixType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IntakeId");
+
+                    b.HasIndex("ParentFormId");
+
+                    b.HasIndex("TenantId", "IsDeleted")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("ApplicationForms", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationFormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsSubmissionGuid")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("FormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Submission")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormSubmissions", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsFormVersionGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FormSchema")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubmissionHeaderMapping")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormVersion", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LinkType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text")
+                        .HasDefaultValue("Related");
+
+                    b.Property<Guid>("LinkedApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("NotifiedStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StatusCode")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("character varying(250)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode")
+                        .IsUnique();
+
+                    b.ToTable("ApplicationStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TagId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationTags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.ToTable("AssessmentAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("AuditDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AuditNote")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditTrackingNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditorName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("AuditHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal?>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FundingNotes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingYear")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GrantCategory")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("OneTimeConsideration")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("PaidDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ReconsiderationAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool?>("RenewedFunding")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("TotalGrantAmount")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("FundingHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IssueDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IssueHeading")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ResolutionNote")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Resolved")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Year")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("IssueTrackings", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FiscalYear")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IncompleteReport")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Outstanding")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("ReportDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ReportsHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("ApprovalRecommended")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("AssessorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("CleanGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("EconomicImpact")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FinancialAnalysis")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("InclusiveGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAiAssessment")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssessorId");
+
+                    b.ToTable("Assessments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicantComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicationComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("AssessmentComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.Contact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("HomePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MobilePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("WorkPhoneExtension")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("WorkPhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contacts", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("ContactId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("RelatedEntityId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RelatedEntityType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Role")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RelatedEntityType", "RelatedEntityId");
+
+                    b.HasIndex("ContactId", "RelatedEntityType", "RelatedEntityId");
+
+                    b.ToTable("ContactLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GlobalTag.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Identity.Person", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Badge")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcDisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OidcSub");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Persons", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Intakes.Intake", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Budget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IntakeName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Intakes", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("EmailGroupUsers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BCC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesHttpStatusCode")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ChesMsgId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChesResponse")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("EmailType")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FromAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentRequestIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Priority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Recipient")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("RetryAttempts")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("SendOnDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime?>("SentDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Tag")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ToAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailLogs", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<Guid>("EmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmailLogId");
+
+                    b.HasIndex("S3ObjectKey");
+
+                    b.ToTable("EmailLogAttachments", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BodyHTML")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SendFrom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailTemplates", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Subscriber", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Subscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SubscriptionGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("SubscriberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("SubscriberId");
+
+                    b.ToTable("SubscriptionGroupSubscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TemplateVariable", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MapTo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateVariables", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Trigger", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Triggers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("SubscriptionGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("TriggerId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionGroupId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("TriggerId");
+
+                    b.ToTable("TriggerSubscriptions", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.AccountCodings.AccountCoding", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(35)
+                        .HasColumnType("character varying(35)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MinistryClient")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProjectNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Responsibility")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ServiceLine")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Stob")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCodings", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentConfigurations.PaymentConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DefaultAccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentIdPrefix")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentConfigurations", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("DecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("DecisionUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.ToTable("ExpenseApprovals", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("BatchName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("BatchNumber")
+                        .HasColumnType("numeric");
+
+                    b.Property<int?>("CasHttpStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CasResponse")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContractNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FsbApNotified")
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<Guid?>("FsbNotificationEmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("FsbNotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("InvoiceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("InvoiceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsRecon")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PayeeName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReferenceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequesterName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SubmissionConfirmationCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountCodingId");
+
+                    b.HasIndex("FsbNotificationEmailLogId");
+
+                    b.HasIndex("ReferenceNumber")
+                        .IsUnique();
+
+                    b.HasIndex("SiteId");
+
+                    b.ToTable("PaymentRequests", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("PaymentTags", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentThresholds.PaymentThreshold", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("Threshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentThresholds", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AddressLine1")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine3")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BankAccount")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("EFTAdvicePref")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmailAddress")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCas")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("MarkDeletedInUse")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("PaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SiteProtected")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SupplierId");
+
+                    b.ToTable("Sites", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCAS")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("MailingAddress")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SIN")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StandardIndustryClassification")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subcategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierProtected")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Suppliers", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Reporting.Domain.Configuration.ReportColumnsMap", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Mapping")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("RoleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ViewStatus")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ReportColumnsMaps", "Reporting");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Instances")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Question", "Question")
+                        .WithMany("Answers")
+                        .HasForeignKey("QuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ScoresheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.ScoresheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", null)
+                        .WithMany("Values")
+                        .HasForeignKey("WorksheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Links")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.WorksheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicationId");
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithOne("ApplicantAgent")
+                        .HasForeignKey("Unity.GrantManager.Applications.ApplicantAgent", "ApplicationId");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", "ApplicationForm")
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationStatus", "ApplicationStatus")
+                        .WithMany("Applications")
+                        .HasForeignKey("ApplicationStatusId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("ApplicationForm");
+
+                    b.Navigation("ApplicationStatus");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationAssignments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Assignee")
+                        .WithMany()
+                        .HasForeignKey("AssigneeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Assignee");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Intakes.Intake", null)
+                        .WithMany()
+                        .HasForeignKey("IntakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ParentFormId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany("ApplicationLinks")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationTags")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("Assessments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("AssessorId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Contacts.Contact", null)
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
+                        .WithMany()
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.HasOne("Unity.Notifications.Emails.EmailLog", null)
+                        .WithMany()
+                        .HasForeignKey("EmailLogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("Unity.Notifications.Templates.Subscriber", "Subscriber")
+                        .WithMany()
+                        .HasForeignKey("SubscriberId");
+
+                    b.Navigation("Subscriber");
+
+                    b.Navigation("SubscriptionGroup");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.EmailTemplate", "EmailTemplate")
+                        .WithMany()
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.Trigger", "Trigger")
+                        .WithMany()
+                        .HasForeignKey("TriggerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmailTemplate");
+
+                    b.Navigation("SubscriptionGroup");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", "PaymentRequest")
+                        .WithMany("ExpenseApprovals")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PaymentRequest");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.AccountCodings.AccountCoding", "AccountCoding")
+                        .WithMany()
+                        .HasForeignKey("AccountCodingId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Site", "Site")
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("AccountCoding");
+
+                    b.Navigation("Site");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", null)
+                        .WithMany("PaymentTags")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Supplier", "Supplier")
+                        .WithMany("Sites")
+                        .HasForeignKey("SupplierId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Supplier");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Navigation("Instances");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Navigation("Values");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Navigation("Links");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+
+                    b.Navigation("ApplicantAgent");
+
+                    b.Navigation("ApplicationAssignments");
+
+                    b.Navigation("ApplicationLinks");
+
+                    b.Navigation("ApplicationTags");
+
+                    b.Navigation("Assessments");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Navigation("Applications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Navigation("ExpenseApprovals");
+
+                    b.Navigation("PaymentTags");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Navigation("Sites");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs
new file mode 100644
index 0000000000..dde7768fba
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    /// <inheritdoc />
+    public partial class AB33555_AddExternalStatusVisibilityToApplication : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "ExternalStatusVisibility",
+                table: "Applications",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ExternalStatusVisibility",
+                table: "Applications");
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
index 595756df54..eabfeae2ed 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
@@ -1290,6 +1290,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("ElectoralDistrict")
                         .HasColumnType("text");
 
+                    b.Property<bool>("ExternalStatusVisibility")
+                        .HasColumnType("boolean");
+
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -3047,6 +3050,142 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Intakes", (string)null);
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3249,6 +3388,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("RetryAttempts")
                         .HasColumnType("integer");
 
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
                     b.Property<DateTime?>("SendOnDateTime")
                         .HasColumnType("timestamp without time zone");
 
@@ -3358,102 +3500,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("EmailLogAttachments", "Notifications");
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("text");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
             modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
                 {
                     b.Property<Guid>("Id")
@@ -4969,6 +5015,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
                 {
                     b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
index e1861fd94d..8ae354c95b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
@@ -88,6 +88,7 @@ public async Task<IViewComponentResult> InvokeAsync(Guid applicationId, Guid app
                     NotificationDate = application.NotificationDate,
                     DueDate = application.DueDate,
                     ProjectSummary = application.ProjectSummary,
+                    ExternalStatusVisibility = application.ExternalStatusVisibility,
                 };
             }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
index 0d35c45fac..15ce5611cc 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
@@ -88,6 +88,9 @@ public class AssessmentResultsModel
             [Display(Name = "AssessmentResultsView:AssessmentResultsForm.RiskRanking")]
             [SelectItems(nameof(RiskRankingList))]
             public string? RiskRanking { get; set; }
+
+            [Display(Name = "AssessmentResultsView:AssessmentResultsForm.Published")]
+            public bool ExternalStatusVisibility { get; set; } = false;
         }
 
         public List<SelectListItem> FundingRiskList { get; set; } = FormatOptionsList(AssessmentResultsOptionsList.FundingList);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
index d849163af3..4d50756ca4 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
@@ -139,6 +139,11 @@
                             <abp-input type="date" asp-for="@Model.AssessmentResultsView.DueDate" onchange="validateDueDate();" abp-data-datepicker="false">
                             </abp-input>
                         </abp-column>
+                        <abp-column size="_4" class="px-1 d-flex align-items-center">
+                            <abp-input asp-for="@Model.AssessmentResultsView.ExternalStatusVisibility"
+                                       onchange="enableAssessmentResultsSaveBtn(this)"
+                                       disabled="@(!Model.IsEditGranted)" />
+                        </abp-column>
                     </abp-row>
                 </abp-column>
             </abp-row>
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.js
index bc77bf1c35..d42cf25888 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.js
@@ -38,7 +38,8 @@
 
         // Update checkboxes which are serialized if unchecked
         $(`#assessmentResultForm input:checkbox`).each(function () {
-            assessmentResultObj[this.name] = (this.checked).toString();
+            let propertyName = this.name.includes('.') ? this.name.split('.').pop() : this.name;
+            assessmentResultObj[propertyName] = this.checked;
         });
 
 

From 5b612e730fa121763aad9139c13a06ffee1013f2 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 29 Jun 2026 10:07:37 -0700
Subject: [PATCH 11/61] [AB#33555] Add ExternalStatusVisibility to breadcrumb
 widget

---
 .../GrantApplications/ApplicationApplicantInfoDto.cs   |  1 +
 .../ApplicationApplicantAppService.cs                  |  1 +
 .../ApplicationBreadcrumbWidget.cs                     |  1 +
 .../ApplicationBreadcrumbWidgetViewModel.cs            |  1 +
 .../ApplicationBreadcrumbWidget/Default.cshtml         |  6 +++++-
 .../Components/ApplicationBreadcrumbWidget/Default.css | 10 ++++++++++
 6 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/ApplicationApplicantInfoDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/ApplicationApplicantInfoDto.cs
index 502af75bcc..53d68e3670 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/ApplicationApplicantInfoDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/ApplicationApplicantInfoDto.cs
@@ -20,6 +20,7 @@ public class ApplicationApplicantInfoDto : GrantApplicationApplicantDto
     public string SigningAuthorityCellPhone { get; set; } = string.Empty;
     public string ApplicationReferenceNo { get; set; } = string.Empty;
     public string ApplicationStatus { get; set; } = string.Empty;
+    public bool ExternalStatusVisibility { get; set; } = false;
     public GrantApplicationState ApplicationStatusCode { get; set; }
     public List<ApplicantAddressDto> ApplicantAddresses { get; set; } = [];
     public Guid ApplicationFormId { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/ApplicationApplicantAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/ApplicationApplicantAppService.cs
index e2043e9a16..a1a83b12db 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/ApplicationApplicantAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/ApplicationApplicantAppService.cs
@@ -106,6 +106,7 @@ public async Task<ApplicationApplicantInfoDto> GetApplicantInfoBasicAsync(Guid a
             ApplicantName = applicantInfo.Applicant?.ApplicantName ?? string.Empty,
             ApplicationReferenceNo = applicantInfo.ReferenceNo,
             ApplicationStatus = applicantInfo.ApplicationStatus.InternalStatus,
+            ExternalStatusVisibility = applicantInfo.ExternalStatusVisibility,
             ApplicationStatusCode = applicantInfo.ApplicationStatus.StatusCode
         };
     }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidget.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidget.cs
index aafb08a420..e2a9c9030a 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidget.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidget.cs
@@ -29,6 +29,7 @@ public async Task<IViewComponentResult> InvokeAsync(Guid applicationId)
                 ApplicantId = applicationApplicant.ApplicantId,
                 ApplicantName = applicationApplicant.ApplicantName ?? string.Empty,
                 ApplicationStatus = applicationApplicant.ApplicationStatus,
+                ExternalStatusVisibility = applicationApplicant.ExternalStatusVisibility,
                 ReferenceNo = applicationApplicant.ApplicationReferenceNo,
 
                 ApplicationFormId = formDetails.ApplicationFormId,
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidgetViewModel.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidgetViewModel.cs
index 5a664ddc66..24b96f595f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidgetViewModel.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/ApplicationBreadcrumbWidgetViewModel.cs
@@ -8,6 +8,7 @@ public class ApplicationBreadcrumbWidgetViewModel
         public Guid ApplicantId { get; set; } = Guid.Empty;
         public string ApplicantName { get; set; } = string.Empty;
         public string ApplicationStatus { get; set; } = string.Empty;
+        public bool ExternalStatusVisibility { get; set; } = false;
 
         public Guid ApplicationFormId { get; set; } = Guid.Empty;
         public string ApplicationFormName { get; set; } = string.Empty;
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
index 3b9d1d321e..3156f161c3 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
@@ -29,7 +29,11 @@
             }
         </div>
         <div class="form-version pr-1">@Model.SubmissionFormDescription</div>
-        <div class="application-status">@Model.ApplicationStatus</div>    
+        <div class="application-status">@Model.ApplicationStatus</div>
+        @if (Model.ExternalStatusVisibility)
+        {
+            <div class="published-status">Status Published</div>
+        }
     </div>
 </div>
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.css b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.css
index f92c40d013..91a1807a41 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.css
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.css
@@ -41,3 +41,13 @@
     margin-top: 2px;
 }
 
+.application-details-breadcrumb .published-status {
+    font-weight: 700;
+    color: #2f6f3e;
+    border: 3px solid #2f6f3e;
+    border-radius: 1rem;
+    font-size: 0.8rem;
+    padding: 0.125rem 0.5rem;
+    margin-top: 2px;
+}
+

From 3c5a9f049faa17703d892e2a6ce64b33728ed05e Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 29 Jun 2026 13:18:33 -0700
Subject: [PATCH 12/61] [AB#33555] Change External Status Label

---
 .../Localization/GrantManager/en.json                           | 2 +-
 .../Pages/ApplicantPortalSettings/Index.cshtml                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
index 17551a73fc..5a69633cff 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
@@ -525,7 +525,7 @@
     "ApplicantPortalSettings:PortalStatusHeading": "Applicant Portal Status",
     "ApplicantPortalSettings:InternalStatus": "Internal Status",
     "ApplicantPortalSettings:PortalStatusLabel": "External Status",
-    "ApplicantPortalSettings:PortalNotifiedStatusLabel": "Notified Status",
+    "ApplicantPortalSettings:PortalPublishedStatusLabel": "Published Status",
     "ApplicantPortalSettings:SaveChanges": "Save Changes",
     "ApplicantPortalSettings:ResetChanges": "Reset",
     "ApplicantPortalSettings:NoChanges": "No changes to save.",
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicantPortalSettings/Index.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicantPortalSettings/Index.cshtml
index d9c8912392..1bb47de3d3 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicantPortalSettings/Index.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicantPortalSettings/Index.cshtml
@@ -45,7 +45,7 @@
                                 <tr>
                                     <th>@L["ApplicantPortalSettings:InternalStatus"]</th>
                                     <th>@L["ApplicantPortalSettings:PortalStatusLabel"]</th>
-                                    <th>@L["ApplicantPortalSettings:PortalNotifiedStatusLabel"]</th>
+                                    <th>@L["ApplicantPortalSettings:PortalPublishedStatusLabel"]</th>
                                 </tr>
                             </thead>
                             <tbody>

From 632d2e924f214704d2964557e0ed4fa13b078667 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 29 Jun 2026 14:02:29 -0700
Subject: [PATCH 13/61] [AB#33555] Implement external status visibility updates

---
 .../CreateUpdateApplicationResultsDto.cs      |  1 -
 .../IGrantApplicationAppService.cs            | 29 ++++++-----
 .../GrantApplicationAppService.cs             | 14 +++--
 .../Localization/GrantManager/en.json         |  9 ++++
 .../Applications/Application.cs               |  3 +-
 .../Default.cshtml                            |  2 +-
 .../AssessmentResults/AssessmentResults.cs    |  1 -
 .../AssessmentResultsViewModel.cs             |  3 --
 .../AssessmentResults/Default.cshtml          |  5 --
 .../DetailsActionBar/Default.cshtml           | 10 +++-
 .../Components/DetailsActionBar/Default.js    | 52 +++++++++++++++++++
 .../DetailsActionBar/DetailsActionBar.cs      | 30 +++++++++--
 .../DetailsActionBarViewModel.cs              | 10 ++++
 13 files changed, 134 insertions(+), 35 deletions(-)
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBarViewModel.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
index 578a7e8295..e2273582f6 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/CreateUpdateApplicationResultsDto.cs
@@ -21,6 +21,5 @@ public class CreateUpdateAssessmentResultsDto : CustomDataFieldDto
         public string? DeclineRational { get; set; }
         public string? AssessmentResultStatus { get; set; }
         public string? RiskRanking { get; set; }
-        public bool ExternalStatusVisibility { get; set; } = false;
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
index 2b6421fd8a..2cecd069ab 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
@@ -1,18 +1,19 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Unity.Modules.Shared;
-using Volo.Abp.Application.Dtos;
-
-namespace Unity.GrantManager.GrantApplications;
-
-public interface IGrantApplicationAppService
-{
-    Task<ApplicationStatusDto> GetApplicationStatusAsync(Guid id);
-    Task<ListResultDto<ApplicationActionDto>> GetActions(Guid applicationId, bool includeInternal = false);        
-    Task<GrantApplicationDto> UpdateProjectInfoAsync(Guid id, CreateUpdateProjectInfoDto input);
-    Task<GrantApplicationDto> UpdatePartialProjectInfoAsync(Guid id, PartialUpdateDto<UpdateProjectInfoDto> input);        
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Unity.Modules.Shared;
+using Volo.Abp.Application.Dtos;
+
+namespace Unity.GrantManager.GrantApplications;
+
+public interface IGrantApplicationAppService
+{
+    Task<ApplicationStatusDto> GetApplicationStatusAsync(Guid id);
+    Task<ListResultDto<ApplicationActionDto>> GetActions(Guid applicationId, bool includeInternal = false);        
+    Task<GrantApplicationDto> UpdateProjectInfoAsync(Guid id, CreateUpdateProjectInfoDto input);
+    Task<GrantApplicationDto> UpdatePartialProjectInfoAsync(Guid id, PartialUpdateDto<UpdateProjectInfoDto> input);        
     Task<GrantApplicationDto> UpdateAssessmentResultsAsync(Guid id, CreateUpdateAssessmentResultsDto input);
+    Task<GrantApplicationDto> UpdateExternalStatusVisibilityAsync(Guid id, bool externalStatusVisibility);
     Task UpdateSupplierNumberAsync(Guid applicationId, string supplierNumber);
     Task<List<GrantApplicationLiteDto>> GetAllApplicationsAsync();
     Task<IList<GrantApplicationDto>> GetApplicationDetailsListAsync(List<Guid> applicationIds);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 651fabbab2..b1bd1fcad9 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -380,8 +380,7 @@ public async Task<GrantApplicationDto> UpdateAssessmentResultsAsync(Guid id, Cre
             input.LikelihoodOfFunding,
             input.TotalProjectBudget,
             input.NotificationDate,
-            input.RiskRanking,
-            input.ExternalStatusVisibility
+            input.RiskRanking
         );
 
         if (application.IsInFinalDecisionState())
@@ -423,6 +422,15 @@ public async Task<GrantApplicationDto> UpdateAssessmentResultsAsync(Guid id, Cre
         return ObjectMapper.Map<Application, GrantApplicationDto>(application);
     }
 
+    [Authorize(UnitySelector.Review.AssessmentResults.Update.Default)]
+    public async Task<GrantApplicationDto> UpdateExternalStatusVisibilityAsync(Guid id, bool externalStatusVisibility)
+    {
+        var application = await applicationRepository.GetAsync(id);
+        application.ExternalStatusVisibility = externalStatusVisibility;
+        await applicationRepository.UpdateAsync(application);
+        return ObjectMapper.Map<Application, GrantApplicationDto>(application);
+    }
+
     private async Task PublishCustomFieldsAsync(Guid applicationId, UpdateProjectInfoDto dto)
     {
         if (dto.WorksheetIds?.Count > 0)
@@ -509,7 +517,6 @@ private async Task SanitizeAssessmentResultsZoneInputs(CreateUpdateAssessmentRes
             input.DueDiligenceStatus ??= application.DueDiligenceStatus;
             input.AssessmentResultStatus ??= application.AssessmentResultStatus;
             input.DeclineRational ??= application.DeclineRational;
-            input.ExternalStatusVisibility = application.ExternalStatusVisibility;
 
             input.NotificationDate ??= application.NotificationDate;
             input.DueDate ??= application.DueDate;
@@ -524,7 +531,6 @@ private async Task SanitizeAssessmentResultsZoneInputs(CreateUpdateAssessmentRes
                 input.DueDiligenceStatus ??= application.DueDiligenceStatus;
                 input.AssessmentResultStatus ??= application.AssessmentResultStatus;
                 input.DeclineRational ??= application.DeclineRational;
-                input.ExternalStatusVisibility = application.ExternalStatusVisibility;
             }
         }
     }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
index 5a69633cff..28c0bdd3d9 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
@@ -286,6 +286,15 @@
     "AssessmentResultsView:AssessmentResultsForm.NotificationDate": "Notification Date",
     "AssessmentResultsView:AssessmentResultsForm.RiskRanking": "Risk Ranking",
     "AssessmentResultsView:AssessmentResultsForm.Published": "Published",
+    "DetailsActionBar:PublishButton": "Publish",
+    "DetailsActionBar:UnpublishButton": "Unpublish",
+    "DetailsActionBar:ConfirmActionTitle": "Confirm Action",
+    "DetailsActionBar:PublishConfirmationText": "Are you sure you want to publish this application status?",
+    "DetailsActionBar:UnpublishConfirmationText": "Are you sure you want to unpublish this application status?",
+    "DetailsActionBar:ConfirmButton": "Confirm",
+    "DetailsActionBar:CancelButton": "Cancel",
+    "DetailsActionBar:PublishStatusUpdated": "Publish status has been updated.",
+    "DetailsActionBar:PublishStatusUpdateFailed": "Failed to update publish status.",
 
     "GrantApplication:ActionButtonName": "Status Actions",
     "GrantApplication:ActionButton.RedStopWarning": "This application is from an applicant with a Red-Stop. Status actions are not permitted.",
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
index 70cc18a334..ff5f68410b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/Application.cs
@@ -152,7 +152,7 @@ public bool IsInFinalDecisionState()
         return GrantApplicationStateGroups.FinalDecisionStates.Contains(ApplicationStatus.StatusCode);
     }
 
-    public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, string? likelihoodOfFunding, decimal? totalProjectBudget, DateTime? notificationDate, string? riskRanking, bool externalStatusVisibility)
+    public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, string? likelihoodOfFunding, decimal? totalProjectBudget, DateTime? notificationDate, string? riskRanking)
     {
         Notes = notes;
         SubStatus = subStatus;
@@ -160,7 +160,6 @@ public void UpdateAlwaysChangeableFields(string? notes, string? subStatus, strin
         TotalProjectBudget = totalProjectBudget ?? 0;
         NotificationDate = notificationDate;
         RiskRanking = riskRanking;
-        ExternalStatusVisibility = externalStatusVisibility;
 
         // Recalculate percentage when TotalProjectBudget changes
         UpdatePercentageTotalProjectBudget();
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
index 3156f161c3..5b3f136d2a 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicationBreadcrumbWidget/Default.cshtml
@@ -32,7 +32,7 @@
         <div class="application-status">@Model.ApplicationStatus</div>
         @if (Model.ExternalStatusVisibility)
         {
-            <div class="published-status">Status Published</div>
+            <div class="published-status">STATUS PUBLISHED</div>
         }
     </div>
 </div>
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
index 8ae354c95b..e1861fd94d 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResults.cs
@@ -88,7 +88,6 @@ public async Task<IViewComponentResult> InvokeAsync(Guid applicationId, Guid app
                     NotificationDate = application.NotificationDate,
                     DueDate = application.DueDate,
                     ProjectSummary = application.ProjectSummary,
-                    ExternalStatusVisibility = application.ExternalStatusVisibility,
                 };
             }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
index 15ce5611cc..0d35c45fac 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/AssessmentResultsViewModel.cs
@@ -88,9 +88,6 @@ public class AssessmentResultsModel
             [Display(Name = "AssessmentResultsView:AssessmentResultsForm.RiskRanking")]
             [SelectItems(nameof(RiskRankingList))]
             public string? RiskRanking { get; set; }
-
-            [Display(Name = "AssessmentResultsView:AssessmentResultsForm.Published")]
-            public bool ExternalStatusVisibility { get; set; } = false;
         }
 
         public List<SelectListItem> FundingRiskList { get; set; } = FormatOptionsList(AssessmentResultsOptionsList.FundingList);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
index 4d50756ca4..d849163af3 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentResults/Default.cshtml
@@ -139,11 +139,6 @@
                             <abp-input type="date" asp-for="@Model.AssessmentResultsView.DueDate" onchange="validateDueDate();" abp-data-datepicker="false">
                             </abp-input>
                         </abp-column>
-                        <abp-column size="_4" class="px-1 d-flex align-items-center">
-                            <abp-input asp-for="@Model.AssessmentResultsView.ExternalStatusVisibility"
-                                       onchange="enableAssessmentResultsSaveBtn(this)"
-                                       disabled="@(!Model.IsEditGranted)" />
-                        </abp-column>
                     </abp-row>
                 </abp-column>
             </abp-row>
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.cshtml
index e43cb89266..e47847b901 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.cshtml
@@ -1,15 +1,23 @@
 @using Unity.GrantManager.Localization;
 @using Microsoft.Extensions.Localization;
 @using Unity.GrantManager.Web.Views.Shared.Components.ApplicationActionWidget;
+@using Unity.GrantManager.Web.Views.Shared.Components.DetailsActionBar;
 
 @inject IStringLocalizer<GrantManagerResource> L
+@model DetailsActionBarViewModel
 
 <div class="action-bar p-2 fade-in-load" id="detailsActionBar">
     <div id="DetailsActionBarStart" class="d-flex align-items-stretch justify-content-start gap-2">
         <div class="order-first">
             @await Component.InvokeAsync(typeof(ApplicationActionWidget), new { applicationId = @Model.ApplicationId })
         </div>
-        @* Items are included here through the Review List JS*@   
+        <abp-button id="togglePublishStatusBtn"
+                    data-selector="applications-table-actions"
+                    data-is-published="@Model.ExternalStatusVisibility.ToString().ToLowerInvariant()"
+                    text='@(Model.ExternalStatusVisibility ? L["DetailsActionBar:UnpublishButton"].Value : L["DetailsActionBar:PublishButton"].Value)'
+                    icon-type="Other"
+                    button-type="Light"
+                    disabled="@(!Model.CanUpdateExternalStatusVisibility)" />
     </div>
     <div id="DetailsActionBarEnd" class="d-flex align-items-stretch justify-content-end gap-2 margin-left-auto">
         <abp-button id="tagApplication"
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.js
index 649d84ad61..b0f02c82ad 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/Default.js
@@ -1,4 +1,5 @@
 $(function () {
+    const l = abp.localization.getResource('GrantManager');
     let selectedApplicationIds = decodeURIComponent($("#DetailsViewApplicationId").val());    
     
     let approveApplicationsModal = new abp.ModalManager({
@@ -258,4 +259,55 @@ $(function () {
                 console.error('Error storing application IDs:', error);
             });
     });
+
+    $('#togglePublishStatusBtn').on('click', function () {
+        let $publishButton = $(this);
+        let isPublished = $publishButton.attr('data-is-published') === 'true';
+        let confirmationDetails = getPublishConfirmationDetails(isPublished);
+
+        Swal.fire({
+            title: confirmationDetails.title,
+            text: confirmationDetails.text,
+            showCancelButton: true,
+            confirmButtonText: confirmationDetails.confirmButtonText,
+            cancelButtonText: l('DetailsActionBar:CancelButton'),
+            customClass: {
+                confirmButton: 'btn btn-primary',
+                cancelButton: 'btn btn-secondary'
+            }
+        }).then((result) => {
+            if (!result.isConfirmed) {
+                return;
+            }
+
+            let nextPublishedState = !isPublished;
+
+            unity.grantManager.grantApplications.grantApplication
+                .updateExternalStatusVisibility(selectedApplicationIds, nextPublishedState)
+                .then(function () {
+                    $publishButton.attr('data-is-published', nextPublishedState.toString());
+                    $publishButton.text(nextPublishedState
+                        ? l('DetailsActionBar:UnpublishButton')
+                        : l('DetailsActionBar:PublishButton'));
+
+                    abp.notify.success(l('DetailsActionBar:PublishStatusUpdated'));
+                    PubSub.publish('application_status_changed', nextPublishedState ? 'Publish' : 'Unpublish');
+                    PubSub.publish('refresh_detail_panel_summary');
+                })
+                .catch(function (error) {
+                    abp.notify.error(l('DetailsActionBar:PublishStatusUpdateFailed'));
+                    console.error('Error updating publish status:', error);
+                });
+        });
+    });
+
+    function getPublishConfirmationDetails(isPublished) {
+        return {
+            title: l('DetailsActionBar:ConfirmActionTitle'),
+            text: isPublished
+                ? l('DetailsActionBar:UnpublishConfirmationText')
+                : l('DetailsActionBar:PublishConfirmationText'),
+            confirmButtonText: l('DetailsActionBar:ConfirmButton')
+        };
+    }
 });
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
index 03c0ece84f..dc9893a026 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
@@ -1,5 +1,9 @@
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
 using System;
+using System.Threading.Tasks;
+using Unity.GrantManager.GrantApplications;
+using Unity.Modules.Shared;
 using Volo.Abp.AspNetCore.Mvc;
 using Volo.Abp.AspNetCore.Mvc.UI.Widgets;
 
@@ -12,9 +16,29 @@ public class DetailsActionBar : AbpViewComponent
     [BindProperty]
     public Guid SelectedApplicationId { get; set; }
 
-    public IViewComponentResult Invoke(Guid applicationId)
+    private readonly IGrantApplicationAppService _grantApplicationAppService;
+    private readonly IAuthorizationService _authorizationService;
+
+    public DetailsActionBar(
+        IGrantApplicationAppService grantApplicationAppService,
+        IAuthorizationService authorizationService)
+    {
+        _grantApplicationAppService = grantApplicationAppService;
+        _authorizationService = authorizationService;
+    }
+
+    public async Task<IViewComponentResult> InvokeAsync(Guid applicationId)
     {
         SelectedApplicationId = applicationId;
-        return View();
+
+        var application = await _grantApplicationAppService.GetAsync(applicationId);
+        var canUpdateExternalStatusVisibility = await _authorizationService.IsGrantedAsync(UnitySelector.Review.AssessmentResults.Update.Default);
+
+        return View(new DetailsActionBarViewModel
+        {
+            ApplicationId = applicationId,
+            ExternalStatusVisibility = application.ExternalStatusVisibility,
+            CanUpdateExternalStatusVisibility = canUpdateExternalStatusVisibility
+        });
     }
 }
\ No newline at end of file
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBarViewModel.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBarViewModel.cs
new file mode 100644
index 0000000000..9bb87e8c81
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBarViewModel.cs
@@ -0,0 +1,10 @@
+using System;
+
+namespace Unity.GrantManager.Web.Views.Shared.Components.DetailsActionBar;
+
+public class DetailsActionBarViewModel
+{
+    public Guid ApplicationId { get; set; }
+    public bool ExternalStatusVisibility { get; set; }
+    public bool CanUpdateExternalStatusVisibility { get; set; }
+}

From 8ca2445fc54d8a96756800f3390f0f7f1bd53b11 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 29 Jun 2026 14:10:04 -0700
Subject: [PATCH 14/61] [AB#33555] Update database connection ports in
 appsettings

---
 .../src/Unity.GrantManager.DbMigrator/appsettings.json      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
index 9239fc32ef..79b4f9af85 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
@@ -1,8 +1,8 @@
 {
   "ConnectionStrings": {
-    "Default": "Host=localhost;port=5435;Database=UnityGrantManager;Username=postgres;Password=admin",
-    "Tenant": "Host=localhost;port=5435;Database=UnityGrantTenant;Username=postgres;Password=admin",
-    "Onboarding": "Host=localhost;port=5435;Database=Onboarding;Username=postgres;Password=admin"
+    "Default": "Host=localhost;port=5432;Database=UnityGrantManager;Username=postgres",
+    "Tenant": "Host=localhost;port=5432;Database=UnityGrantTenant;Username=postgres",
+    "Onboarding": "Host=localhost;port=5432;Database=Onboarding;Username=postgres"
   },
   "StringEncryption": {
     "DefaultPassPhrase": "g2IuZx7PwXDvCmlW"

From 64e25f146f06d8c8d64acb27e779f0a7ea1c493d Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Tue, 30 Jun 2026 07:59:11 -0700
Subject: [PATCH 15/61] [AB#33555] Revert EF migration for fix

---
 ...lStatusVisibilityToApplication.Designer.cs | 5230 -----------------
 ...ddExternalStatusVisibilityToApplication.cs |   29 -
 .../GrantTenantDbContextModelSnapshot.cs      |  157 -
 3 files changed, 5416 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
deleted file mode 100644
index e1d38ed77f..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
+++ /dev/null
@@ -1,5230 +0,0 @@
-// <auto-generated />
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-using Unity.GrantManager.EntityFrameworkCore;
-using Volo.Abp.EntityFrameworkCore;
-
-#nullable disable
-
-namespace Unity.GrantManager.Migrations.TenantMigrations
-{
-    [DbContext(typeof(GrantTenantDbContext))]
-    [Migration("20260629164239_AB33555_AddExternalStatusVisibilityToApplication")]
-    partial class AB33555_AddExternalStatusVisibilityToApplication
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
-                .HasAnnotation("ProductVersion", "10.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Value")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ScoresheetId");
-
-                    b.ToTable("ScoresheetInstances", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("QuestionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ScoresheetInstanceId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("QuestionId");
-
-                    b.HasIndex("ScoresheetInstanceId");
-
-                    b.ToTable("Answers", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("Enabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<string>("Label")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("SectionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SectionId");
-
-                    b.ToTable("Questions", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsArchived")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Scoresheets", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ScoresheetId");
-
-                    b.ToTable("ScoresheetSections", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid>("CustomFieldId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("WorksheetInstanceId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetInstanceId");
-
-                    b.ToTable("CustomFieldValues", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UiAnchor")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetCorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("WorksheetCorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("WorksheetInstances", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<long?>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UiAnchor")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetId");
-
-                    b.ToTable("WorksheetLinks", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("Enabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<string>("Key")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Label")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("SectionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SectionId");
-
-                    b.ToTable("CustomFields", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsArchived")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Worksheets", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetId");
-
-                    b.ToTable("WorksheetSections", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicantName")
-                        .IsRequired()
-                        .HasMaxLength(600)
-                        .HasColumnType("character varying(600)");
-
-                    b.Property<string>("ApproxNumberOfEmployees")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("BusinessNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FiscalDay")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("FiscalMonth")
-                        .HasColumnType("text");
-
-                    b.Property<string>("FundingHistoryComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IndigenousOrgInd")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDuplicated")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("IssueTrackingComments")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<decimal?>("MatchPercentage")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("NonRegOrgName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("NonRegisteredBusinessName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrganizationType")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("RedStop")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportsComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Sector")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SectorSubSectorIndustryDesc")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly?>("StartedOperatingDate")
-                        .HasColumnType("date");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubSector")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("SupplierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UnityApplicantId")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantName");
-
-                    b.HasIndex("OrgName");
-
-                    b.HasIndex("OrgNumber");
-
-                    b.HasIndex("Status");
-
-                    b.HasIndex("SupplierId");
-
-                    b.HasIndex("TenantId");
-
-                    b.HasIndex("UnityApplicantId");
-
-                    b.HasIndex("TenantId", "IsDeleted", "CreationTime")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("Applicants", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("AddressType")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("Country")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Postal")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Street")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Street2")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Unit")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicantAddresses", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("BceidBusinessGuid")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BceidBusinessName")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("BceidUserGuid")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BceidUserName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<int>("ContactOrder")
-                        .HasColumnType("integer");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IdentityEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IdentityName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IdentityProvider")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("OidcSubUser")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone2")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone2Extension")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneExtension")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleForApplicant")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationId")
-                        .IsUnique();
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicantAgents", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("ApplicantAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AIAnalysis")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AIScoresheetAnswers")
-                        .HasColumnType("jsonb");
-
-                    b.Property<string>("Acquisition")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicantElectoralDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal>("ApprovedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<DateTime?>("AssessmentResultDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("AssessmentResultStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("AssessmentStartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Community")
-                        .HasColumnType("text");
-
-                    b.Property<int?>("CommunityPopulation")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime?>("ContractExecutionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ContractNumber")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DeclineRational")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("DefaultSiteId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime?>("DueDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("DueDiligenceStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("EconomicRegion")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ElectoralDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("ExternalStatusVisibility")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("FinalDecisionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("Forestry")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ForestryFocus")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LikelihoodOfFunding")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("NotificationDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("OwnerId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Payload")
-                        .HasColumnType("jsonb");
-
-                    b.Property<double?>("PercentageTotalProjectBudget")
-                        .HasColumnType("double precision");
-
-                    b.Property<string>("Place")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("ProjectEndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal?>("ProjectFundingTotal")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ProjectName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<DateTime?>("ProjectStartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ProjectSummary")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("ProposalDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal>("RecommendedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ReferenceNo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("RegionalDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<decimal>("RequestedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("RiskRanking")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityBusinessPhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityCellPhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityFullName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityTitle")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("SubmissionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal>("TotalProjectBudget")
-                        .HasColumnType("numeric");
-
-                    b.Property<int?>("TotalScore")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("UnityApplicationId")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.HasIndex("ApplicationStatusId");
-
-                    b.HasIndex("OwnerId");
-
-                    b.HasIndex("ReferenceNo");
-
-                    b.HasIndex("TenantId", "SubmissionDate")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("Applications", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssigneeId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Duty")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("AssigneeId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationAssignments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AISummary")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChefsFileId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsSubmissionId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationChefsFileAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContactEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactFullName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactMobilePhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactTitle")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactWorkPhone")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationContact", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("AccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApiKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicationFormDescription")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicationFormName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<DateTime?>("AttemptedConnectionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<bool>("AutomaticallyGenerateAIAnalysis")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("AvailableChefsFields")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Category")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsApplicationFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsCriteriaFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ConnectionHttpStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<int?>("DefaultPaymentGroup")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<int?>("ElectoralDistrictAddressType")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FormHierarchy")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid>("IntakeId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<bool>("IsDirectApproval")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<bool>("ManuallyInitiateAIAnalysis")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("ParentFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("Payable")
-                        .HasColumnType("boolean");
-
-                    b.Property<decimal?>("PaymentApprovalThreshold")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("Prefix")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<bool>("PreventPayment")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int?>("SuffixType")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int?>("Version")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("IntakeId");
-
-                    b.HasIndex("ParentFormId");
-
-                    b.HasIndex("TenantId", "IsDeleted")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("ApplicationForms", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationFormVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChefsSubmissionGuid")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid?>("FormVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("OidcSub")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<string>("Submission")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.ToTable("ApplicationFormSubmissions", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AvailableChefsFields")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsApplicationFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsFormVersionGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FormSchema")
-                        .HasColumnType("jsonb");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubmissionHeaderMapping")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int?>("Version")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.ToTable("ApplicationFormVersion", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LinkType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("text")
-                        .HasDefaultValue("Related");
-
-                    b.Property<Guid>("LinkedApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationLinks", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExternalStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("InternalStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("NotifiedStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("StatusCode")
-                        .IsRequired()
-                        .HasMaxLength(250)
-                        .HasColumnType("character varying(250)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StatusCode")
-                        .IsUnique();
-
-                    b.ToTable("ApplicationStatuses", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("TagId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("TagId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationTags", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AssessmentId");
-
-                    b.ToTable("AssessmentAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("AuditDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("AuditNote")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditTrackingNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditorName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("AuditHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal?>("ApprovedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FundingNotes")
-                        .HasColumnType("text");
-
-                    b.Property<string>("FundingYear")
-                        .HasColumnType("text");
-
-                    b.Property<string>("GrantCategory")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<decimal?>("OneTimeConsideration")
-                        .HasColumnType("numeric");
-
-                    b.Property<DateTime?>("PaidDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal?>("ReconsiderationAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<bool?>("RenewedFunding")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal?>("TotalGrantAmount")
-                        .HasColumnType("numeric");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("FundingHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IssueDescription")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IssueHeading")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ResolutionNote")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("Resolved")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Year")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("IssueTrackings", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FiscalYear")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("IncompleteReport")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Note")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("Outstanding")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("ReportDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("ReportsHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool?>("ApprovalRecommended")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid>("AssessorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int?>("CleanGrowth")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<int?>("EconomicImpact")
-                        .HasColumnType("integer");
-
-                    b.Property<DateTime?>("EndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FinancialAnalysis")
-                        .HasColumnType("integer");
-
-                    b.Property<int?>("InclusiveGrowth")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsAiAssessment")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsComplete")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("AssessorId");
-
-                    b.ToTable("Assessments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("ApplicantComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("ApplicationComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AssessmentId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("AssessmentComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.Contact", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("HomePhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MobilePhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<string>("WorkPhoneExtension")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<string>("WorkPhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Contacts", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("ContactId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsPrimary")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("RelatedEntityId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("RelatedEntityType")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<string>("Role")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RelatedEntityType", "RelatedEntityId");
-
-                    b.HasIndex("ContactId", "RelatedEntityType", "RelatedEntityId");
-
-                    b.ToTable("ContactLinks", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.GlobalTag.Tag", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Tags", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Identity.Person", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Badge")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FullName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("OidcDisplayName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("OidcSub")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("OidcSub");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("Persons", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Intakes.Intake", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<double>("Budget")
-                        .HasColumnType("double precision");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime>("EndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IntakeName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime>("StartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Intakes", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("character varying(1000)");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("DateField")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime>("NotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CreationTime");
-
-                    b.HasIndex("ScheduledNotificationId");
-
-                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
-                        .IsUnique();
-
-                    b.ToTable("ScheduledNotificationTracking", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Type")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailGroups", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("GroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("GroupId");
-
-                    b.ToTable("EmailGroupUsers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLog", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BCC")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Body")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("BodyType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("CC")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChesHttpStatusCode")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("ChesMsgId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChesResponse")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChesStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("EmailType")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FromAddress")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("PaymentRequestIds")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Priority")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Recipient")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
-                    b.Property<int>("RetryAttempts")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("SendOnDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<DateTime?>("SentDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subject")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Tag")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("TemplateName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("ToAddress")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailLogs", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContentType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<Guid>("EmailLogId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<long>("FileSize")
-                        .HasColumnType("bigint");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("EmailLogId");
-
-                    b.HasIndex("S3ObjectKey");
-
-                    b.ToTable("EmailLogAttachments", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BodyHTML")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("BodyText")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SendFrom")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subject")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailTemplates", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.Subscriber", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Subscribers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroup", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("SubscriptionGroups", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid?>("GroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("SubscriberId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("GroupId");
-
-                    b.HasIndex("SubscriberId");
-
-                    b.ToTable("SubscriptionGroupSubscribers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TemplateVariable", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MapTo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Token")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("TemplateVariables", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.Trigger", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("Active")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("InternalName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Triggers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("SubscriptionGroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("TemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("TriggerId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SubscriptionGroupId");
-
-                    b.HasIndex("TemplateId");
-
-                    b.HasIndex("TriggerId");
-
-                    b.ToTable("TriggerSubscriptions", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.AccountCodings.AccountCoding", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(35)
-                        .HasColumnType("character varying(35)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MinistryClient")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProjectNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Responsibility")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ServiceLine")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Stob")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("AccountCodings", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentConfigurations.PaymentConfiguration", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DefaultAccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("PaymentIdPrefix")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("PaymentConfigurations", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("DecisionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("DecisionUserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("PaymentRequestId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("Status")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PaymentRequestId");
-
-                    b.ToTable("ExpenseApprovals", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("AccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal>("Amount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("BatchName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<decimal>("BatchNumber")
-                        .HasColumnType("numeric");
-
-                    b.Property<int?>("CasHttpStatusCode")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("CasResponse")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContractNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FsbApNotified")
-                        .HasMaxLength(10)
-                        .HasColumnType("character varying(10)");
-
-                    b.Property<Guid?>("FsbNotificationEmailLogId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("FsbNotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("InvoiceNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("InvoiceStatus")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<bool>("IsRecon")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Note")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PayeeName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentDate")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReferenceNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("RequesterName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("SiteId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("Status")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("SubmissionConfirmationCode")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AccountCodingId");
-
-                    b.HasIndex("FsbNotificationEmailLogId");
-
-                    b.HasIndex("ReferenceNumber")
-                        .IsUnique();
-
-                    b.HasIndex("SiteId");
-
-                    b.ToTable("PaymentRequests", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("PaymentRequestId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("TagId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PaymentRequestId");
-
-                    b.HasIndex("TagId");
-
-                    b.ToTable("PaymentTags", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentThresholds.PaymentThreshold", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal?>("Threshold")
-                        .HasColumnType("numeric");
-
-                    b.Property<Guid?>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("PaymentThresholds", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AddressLine1")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AddressLine2")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AddressLine3")
-                        .HasColumnType("text");
-
-                    b.Property<string>("BankAccount")
-                        .HasColumnType("text");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Country")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("EFTAdvicePref")
-                        .HasColumnType("text");
-
-                    b.Property<string>("EmailAddress")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("LastUpdatedInCas")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<bool>("MarkDeletedInUse")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Number")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("PaymentGroup")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("PostalCode")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SiteProtected")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("SupplierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SupplierId");
-
-                    b.ToTable("Sites", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BusinessNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("LastUpdatedInCAS")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("MailingAddress")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Number")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PostalCode")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SIN")
-                        .HasColumnType("text");
-
-                    b.Property<string>("StandardIndustryClassification")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subcategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierProtected")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Suppliers", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Reporting.Domain.Configuration.ReportColumnsMap", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Mapping")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<int>("RoleStatus")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("ViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("ViewStatus")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("ReportColumnsMaps", "Reporting");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
-                        .WithMany("Instances")
-                        .HasForeignKey("ScoresheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Scoresheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Question", "Question")
-                        .WithMany("Answers")
-                        .HasForeignKey("QuestionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", null)
-                        .WithMany("Answers")
-                        .HasForeignKey("ScoresheetInstanceId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Question");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.ScoresheetSection", "Section")
-                        .WithMany("Fields")
-                        .HasForeignKey("SectionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Section");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
-                        .WithMany("Sections")
-                        .HasForeignKey("ScoresheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Scoresheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", null)
-                        .WithMany("Values")
-                        .HasForeignKey("WorksheetInstanceId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
-                        .WithMany("Links")
-                        .HasForeignKey("WorksheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Worksheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.WorksheetSection", "Section")
-                        .WithMany("Fields")
-                        .HasForeignKey("SectionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Section");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
-                        .WithMany("Sections")
-                        .HasForeignKey("WorksheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Worksheet");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
-                        .WithMany("ApplicantAddresses")
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicantAddresses")
-                        .HasForeignKey("ApplicationId");
-
-                    b.Navigation("Applicant");
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithOne("ApplicantAgent")
-                        .HasForeignKey("Unity.GrantManager.Applications.ApplicantAgent", "ApplicationId");
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", "ApplicationForm")
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationStatus", "ApplicationStatus")
-                        .WithMany("Applications")
-                        .HasForeignKey("ApplicationStatusId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("Applicant");
-
-                    b.Navigation("ApplicationForm");
-
-                    b.Navigation("ApplicationStatus");
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicationAssignments")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", "Assignee")
-                        .WithMany()
-                        .HasForeignKey("AssigneeId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-
-                    b.Navigation("Assignee");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Intakes.Intake", null)
-                        .WithMany()
-                        .HasForeignKey("IntakeId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ParentFormId")
-                        .OnDelete(DeleteBehavior.NoAction);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany("ApplicationLinks")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicationTags")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
-                        .WithMany()
-                        .HasForeignKey("TagId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-
-                    b.Navigation("Tag");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
-                        .WithMany()
-                        .HasForeignKey("AssessmentId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("Assessments")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("AssessorId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
-                        .WithMany()
-                        .HasForeignKey("AssessmentId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Contacts.Contact", null)
-                        .WithMany()
-                        .HasForeignKey("ContactId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
-                        .WithMany()
-                        .HasForeignKey("ScheduledNotificationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
-                {
-                    b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
-                        .WithMany()
-                        .HasForeignKey("GroupId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
-                {
-                    b.HasOne("Unity.Notifications.Emails.EmailLog", null)
-                        .WithMany()
-                        .HasForeignKey("EmailLogId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
-                {
-                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
-                        .WithMany()
-                        .HasForeignKey("GroupId");
-
-                    b.HasOne("Unity.Notifications.Templates.Subscriber", "Subscriber")
-                        .WithMany()
-                        .HasForeignKey("SubscriberId");
-
-                    b.Navigation("Subscriber");
-
-                    b.Navigation("SubscriptionGroup");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
-                {
-                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
-                        .WithMany()
-                        .HasForeignKey("SubscriptionGroupId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Notifications.Templates.EmailTemplate", "EmailTemplate")
-                        .WithMany()
-                        .HasForeignKey("TemplateId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Notifications.Templates.Trigger", "Trigger")
-                        .WithMany()
-                        .HasForeignKey("TriggerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("EmailTemplate");
-
-                    b.Navigation("SubscriptionGroup");
-
-                    b.Navigation("Trigger");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", "PaymentRequest")
-                        .WithMany("ExpenseApprovals")
-                        .HasForeignKey("PaymentRequestId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("PaymentRequest");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.AccountCodings.AccountCoding", "AccountCoding")
-                        .WithMany()
-                        .HasForeignKey("AccountCodingId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.HasOne("Unity.Payments.Domain.Suppliers.Site", "Site")
-                        .WithMany()
-                        .HasForeignKey("SiteId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("AccountCoding");
-
-                    b.Navigation("Site");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", null)
-                        .WithMany("PaymentTags")
-                        .HasForeignKey("PaymentRequestId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
-                        .WithMany()
-                        .HasForeignKey("TagId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Tag");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.Suppliers.Supplier", "Supplier")
-                        .WithMany("Sites")
-                        .HasForeignKey("SupplierId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Supplier");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.Navigation("Answers");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.Navigation("Answers");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
-                {
-                    b.Navigation("Instances");
-
-                    b.Navigation("Sections");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.Navigation("Fields");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
-                {
-                    b.Navigation("Values");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
-                {
-                    b.Navigation("Links");
-
-                    b.Navigation("Sections");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.Navigation("Fields");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
-                {
-                    b.Navigation("ApplicantAddresses");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.Navigation("ApplicantAddresses");
-
-                    b.Navigation("ApplicantAgent");
-
-                    b.Navigation("ApplicationAssignments");
-
-                    b.Navigation("ApplicationLinks");
-
-                    b.Navigation("ApplicationTags");
-
-                    b.Navigation("Assessments");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
-                {
-                    b.Navigation("Applications");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.Navigation("ExpenseApprovals");
-
-                    b.Navigation("PaymentTags");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
-                {
-                    b.Navigation("Sites");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs
deleted file mode 100644
index dde7768fba..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260629164239_AB33555_AddExternalStatusVisibilityToApplication.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Unity.GrantManager.Migrations.TenantMigrations
-{
-    /// <inheritdoc />
-    public partial class AB33555_AddExternalStatusVisibilityToApplication : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<bool>(
-                name: "ExternalStatusVisibility",
-                table: "Applications",
-                type: "boolean",
-                nullable: false,
-                defaultValue: false);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "ExternalStatusVisibility",
-                table: "Applications");
-        }
-    }
-}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
index eabfeae2ed..396dd9ff5b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
@@ -1290,9 +1290,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("ElectoralDistrict")
                         .HasColumnType("text");
 
-                    b.Property<bool>("ExternalStatusVisibility")
-                        .HasColumnType("boolean");
-
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -3050,142 +3047,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Intakes", (string)null);
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("character varying(1000)");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("DateField")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime>("NotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CreationTime");
-
-                    b.HasIndex("ScheduledNotificationId");
-
-                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
-                        .IsUnique();
-
-                    b.ToTable("ScheduledNotificationTracking", "Notifications");
-                });
-
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3388,9 +3249,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("RetryAttempts")
                         .HasColumnType("integer");
 
-                    b.Property<Guid?>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
                     b.Property<DateTime?>("SendOnDateTime")
                         .HasColumnType("timestamp without time zone");
 
@@ -5015,21 +4873,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
-                        .WithMany()
-                        .HasForeignKey("ScheduledNotificationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
                 {
                     b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)

From 8695b8c0f09b44e0502f38829aab73b077dfe342 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Tue, 30 Jun 2026 08:48:52 -0700
Subject: [PATCH 16/61] [AB#33555] Add back ExternalStatusVisibility migration

---
 ...lStatusVisibilityToApplication.Designer.cs | 5239 +++++++++++++++++
 ...ddExternalStatusVisibilityToApplication.cs |   29 +
 .../GrantTenantDbContextModelSnapshot.cs      |  157 +
 3 files changed, 5425 insertions(+)
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
new file mode 100644
index 0000000000..c7835d268d
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
@@ -0,0 +1,5239 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Unity.GrantManager.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    [DbContext(typeof(GrantTenantDbContext))]
+    [Migration("20260630150247_AB33555_AddExternalStatusVisibilityToApplication")]
+    partial class AB33555_AddExternalStatusVisibilityToApplication
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
+                .HasAnnotation("ProductVersion", "10.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("QuestionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScoresheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ScoresheetInstanceId");
+
+                    b.ToTable("Answers", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("Questions", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Scoresheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("CustomFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetInstanceId");
+
+                    b.ToTable("CustomFieldValues", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetCorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorksheetCorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorksheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<long?>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetLinks", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("CustomFields", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Worksheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicantName")
+                        .IsRequired()
+                        .HasMaxLength(600)
+                        .HasColumnType("character varying(600)");
+
+                    b.Property<string>("ApproxNumberOfEmployees")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FiscalDay")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FiscalMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingHistoryComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IndigenousOrgInd")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDuplicated")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IssueTrackingComments")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("MatchPercentage")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("NonRegOrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NonRegisteredBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrganizationType")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("RedStop")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportsComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Sector")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SectorSubSectorIndustryDesc")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("StartedOperatingDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubSector")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UnityApplicantId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantName");
+
+                    b.HasIndex("OrgName");
+
+                    b.HasIndex("OrgNumber");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SupplierId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UnityApplicantId");
+
+                    b.HasIndex("TenantId", "IsDeleted", "CreationTime")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applicants", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Postal")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street2")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicantAddresses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BceidBusinessGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("BceidUserGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidUserName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<int>("ContactOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IdentityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityProvider")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSubUser")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2Extension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneExtension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleForApplicant")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicantAgents", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ApplicantAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AIAnalysis")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AIScoresheetAnswers")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Acquisition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicantElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("AssessmentResultDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AssessmentResultStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("AssessmentStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Community")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("CommunityPopulation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime?>("ContractExecutionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DeclineRational")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DefaultSiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("DueDiligenceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EconomicRegion")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("ExternalStatusVisibility")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("FinalDecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Forestry")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ForestryFocus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LikelihoodOfFunding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("NotificationDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("jsonb");
+
+                    b.Property<double?>("PercentageTotalProjectBudget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Place")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProjectEndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ProjectFundingTotal")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ProjectName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("ProjectStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ProjectSummary")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProposalDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal>("RecommendedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RegionalDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("RequestedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RiskRanking")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityBusinessPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityCellPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityFullName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal>("TotalProjectBudget")
+                        .HasColumnType("numeric");
+
+                    b.Property<int?>("TotalScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UnityApplicationId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.HasIndex("ApplicationStatusId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ReferenceNo");
+
+                    b.HasIndex("TenantId", "SubmissionDate")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applications", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssigneeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Duty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssigneeId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationAssignments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AISummary")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsFileId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsSubmissionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationChefsFileAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContactEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactFullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactMobilePhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactWorkPhone")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationContact", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApiKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("AttemptedConnectionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("AutomaticallyGenerateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Category")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsCriteriaFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ConnectionHttpStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("DefaultPaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<int?>("ElectoralDistrictAddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FormHierarchy")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("IntakeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsDirectApproval")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("ManuallyInitiateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ParentFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Payable")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("PaymentApprovalThreshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Prefix")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<bool>("PreventPayment")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("SuffixType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IntakeId");
+
+                    b.HasIndex("ParentFormId");
+
+                    b.HasIndex("TenantId", "IsDeleted")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("ApplicationForms", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationFormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsSubmissionGuid")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("FormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Submission")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormSubmissions", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsFormVersionGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FormSchema")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubmissionHeaderMapping")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormVersion", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LinkType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text")
+                        .HasDefaultValue("Related");
+
+                    b.Property<Guid>("LinkedApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("NotifiedStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StatusCode")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("character varying(250)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode")
+                        .IsUnique();
+
+                    b.ToTable("ApplicationStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TagId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationTags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.ToTable("AssessmentAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("AuditDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AuditNote")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditTrackingNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditorName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("AuditHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal?>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FundingNotes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingYear")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GrantCategory")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("OneTimeConsideration")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("PaidDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ReconsiderationAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool?>("RenewedFunding")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("TotalGrantAmount")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("FundingHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IssueDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IssueHeading")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ResolutionNote")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Resolved")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Year")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("IssueTrackings", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FiscalYear")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IncompleteReport")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Outstanding")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("ReportDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ReportsHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("ApprovalRecommended")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("AssessorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("CleanGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("EconomicImpact")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FinancialAnalysis")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("InclusiveGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAiAssessment")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssessorId");
+
+                    b.ToTable("Assessments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicantComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicationComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("AssessmentComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.Contact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("HomePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MobilePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("WorkPhoneExtension")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("WorkPhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contacts", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("ContactId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("RelatedEntityId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RelatedEntityType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Role")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RelatedEntityType", "RelatedEntityId");
+
+                    b.HasIndex("ContactId", "RelatedEntityType", "RelatedEntityId");
+
+                    b.ToTable("ContactLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GlobalTag.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Identity.Person", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Badge")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcDisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OidcSub");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Persons", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Intakes.Intake", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Budget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IntakeName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Intakes", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("EmailGroupUsers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BCC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesHttpStatusCode")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ChesMsgId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChesResponse")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("EmailType")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FromAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentRequestIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Priority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Recipient")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("RetryAttempts")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("SendOnDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime?>("SentDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Tag")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ToAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailLogs", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<Guid>("EmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmailLogId");
+
+                    b.HasIndex("S3ObjectKey");
+
+                    b.ToTable("EmailLogAttachments", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BodyHTML")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SendFrom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailTemplates", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Subscriber", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Subscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SubscriptionGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("SubscriberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("SubscriberId");
+
+                    b.ToTable("SubscriptionGroupSubscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TemplateVariable", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MapTo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateVariables", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Trigger", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Triggers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("SubscriptionGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("TriggerId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionGroupId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("TriggerId");
+
+                    b.ToTable("TriggerSubscriptions", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.AccountCodings.AccountCoding", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(35)
+                        .HasColumnType("character varying(35)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MinistryClient")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProjectNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Responsibility")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ServiceLine")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Stob")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCodings", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentConfigurations.PaymentConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DefaultAccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentIdPrefix")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentConfigurations", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("DecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("DecisionUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.ToTable("ExpenseApprovals", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("BatchName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("BatchNumber")
+                        .HasColumnType("numeric");
+
+                    b.Property<int?>("CasHttpStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CasResponse")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContractNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FsbApNotified")
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<Guid?>("FsbNotificationEmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("FsbNotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("InvoiceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("InvoiceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsRecon")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PayeeName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReferenceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequesterName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SubmissionConfirmationCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountCodingId");
+
+                    b.HasIndex("CorrelationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("FsbNotificationEmailLogId");
+
+                    b.HasIndex("ReferenceNumber")
+                        .IsUnique();
+
+                    b.HasIndex("SiteId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TenantId", "CreationTime")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("PaymentRequests", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("PaymentTags", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentThresholds.PaymentThreshold", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("Threshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentThresholds", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AddressLine1")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine3")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BankAccount")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("EFTAdvicePref")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmailAddress")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCas")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("MarkDeletedInUse")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("PaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SiteProtected")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SupplierId");
+
+                    b.ToTable("Sites", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCAS")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("MailingAddress")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SIN")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StandardIndustryClassification")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subcategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierProtected")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Suppliers", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Reporting.Domain.Configuration.ReportColumnsMap", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Mapping")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("RoleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ViewStatus")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ReportColumnsMaps", "Reporting");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Instances")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Question", "Question")
+                        .WithMany("Answers")
+                        .HasForeignKey("QuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ScoresheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.ScoresheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", null)
+                        .WithMany("Values")
+                        .HasForeignKey("WorksheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Links")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.WorksheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicationId");
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithOne("ApplicantAgent")
+                        .HasForeignKey("Unity.GrantManager.Applications.ApplicantAgent", "ApplicationId");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", "ApplicationForm")
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationStatus", "ApplicationStatus")
+                        .WithMany("Applications")
+                        .HasForeignKey("ApplicationStatusId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("ApplicationForm");
+
+                    b.Navigation("ApplicationStatus");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationAssignments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Assignee")
+                        .WithMany()
+                        .HasForeignKey("AssigneeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Assignee");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Intakes.Intake", null)
+                        .WithMany()
+                        .HasForeignKey("IntakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ParentFormId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany("ApplicationLinks")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationTags")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("Assessments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("AssessorId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Contacts.Contact", null)
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
+                        .WithMany()
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.HasOne("Unity.Notifications.Emails.EmailLog", null)
+                        .WithMany()
+                        .HasForeignKey("EmailLogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("Unity.Notifications.Templates.Subscriber", "Subscriber")
+                        .WithMany()
+                        .HasForeignKey("SubscriberId");
+
+                    b.Navigation("Subscriber");
+
+                    b.Navigation("SubscriptionGroup");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.EmailTemplate", "EmailTemplate")
+                        .WithMany()
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.Trigger", "Trigger")
+                        .WithMany()
+                        .HasForeignKey("TriggerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmailTemplate");
+
+                    b.Navigation("SubscriptionGroup");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", "PaymentRequest")
+                        .WithMany("ExpenseApprovals")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PaymentRequest");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.AccountCodings.AccountCoding", "AccountCoding")
+                        .WithMany()
+                        .HasForeignKey("AccountCodingId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Site", "Site")
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("AccountCoding");
+
+                    b.Navigation("Site");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", null)
+                        .WithMany("PaymentTags")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Supplier", "Supplier")
+                        .WithMany("Sites")
+                        .HasForeignKey("SupplierId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Supplier");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Navigation("Instances");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Navigation("Values");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Navigation("Links");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+
+                    b.Navigation("ApplicantAgent");
+
+                    b.Navigation("ApplicationAssignments");
+
+                    b.Navigation("ApplicationLinks");
+
+                    b.Navigation("ApplicationTags");
+
+                    b.Navigation("Assessments");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Navigation("Applications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Navigation("ExpenseApprovals");
+
+                    b.Navigation("PaymentTags");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Navigation("Sites");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs
new file mode 100644
index 0000000000..dde7768fba
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    /// <inheritdoc />
+    public partial class AB33555_AddExternalStatusVisibilityToApplication : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "ExternalStatusVisibility",
+                table: "Applications",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "ExternalStatusVisibility",
+                table: "Applications");
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
index 38dad53484..f702d3824d 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
@@ -1290,6 +1290,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("ElectoralDistrict")
                         .HasColumnType("text");
 
+                    b.Property<bool>("ExternalStatusVisibility")
+                        .HasColumnType("boolean");
+
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -3047,6 +3050,142 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Intakes", (string)null);
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3249,6 +3388,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("RetryAttempts")
                         .HasColumnType("integer");
 
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
                     b.Property<DateTime?>("SendOnDateTime")
                         .HasColumnType("timestamp without time zone");
 
@@ -4882,6 +5024,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
                 {
                     b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)

From fac7855d59fc97350442e88178b6baf15098f66f Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Tue, 30 Jun 2026 09:37:25 -0700
Subject: [PATCH 17/61] [AB#33555] Fix connection string edit

---
 .../src/Unity.GrantManager.DbMigrator/appsettings.json      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
index 79b4f9af85..2d97676b33 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.DbMigrator/appsettings.json
@@ -1,8 +1,8 @@
 {
   "ConnectionStrings": {
-    "Default": "Host=localhost;port=5432;Database=UnityGrantManager;Username=postgres",
-    "Tenant": "Host=localhost;port=5432;Database=UnityGrantTenant;Username=postgres",
-    "Onboarding": "Host=localhost;port=5432;Database=Onboarding;Username=postgres"
+    "Default": "Host=localhost;port=5432;Database=UnityGrantManager;Username=postgres;",
+    "Tenant": "Host=localhost;port=5432;Database=UnityGrantTenant;Username=postgres;",
+    "Onboarding": "Host=localhost;port=5432;Database=Onboarding;Username=postgres;"
   },
   "StringEncryption": {
     "DefaultPassPhrase": "g2IuZx7PwXDvCmlW"

From cb56da6dea96d3b21c565349802ac88344dd9b21 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 12:20:47 -0700
Subject: [PATCH 18/61] AB#32307 repair AI schema and seeding

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs |   3 +-
 .../DataSeed/AIDataSeeder.cs                  |  18 ++
 .../DataSeed/AIModelDataSeeder.cs             |  91 +++-----
 .../DataSeed/AIOperationDataSeeder.cs         | 180 ++++++---------
 .../DataSeed/AIPromptDataSeeder.cs            |   2 +-
 .../AIGenerationRequestDto.cs                 |   2 +-
 .../AIGenerationStatusAppService.cs           |   2 +-
 .../GrantApplications/AIGenerationRequest.cs  |   2 +-
 .../GrantManagerDbContext.cs                  |  20 +-
 .../20260624191335_RefreshAiSchema.cs         | 212 +++++++++++-------
 10 files changed, 254 insertions(+), 278 deletions(-)
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIDataSeeder.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index be191ce6f3..5b3cc353f9 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -256,8 +256,7 @@ private static AIModelSettings ResolveModelSettings(AIModel model)
             }
         }
 
-        return activeModels.FirstOrDefault(model =>
-            string.Equals(model.Name, "Default", StringComparison.OrdinalIgnoreCase));
+        return null;
     }
 
     private string Required(string key)
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIDataSeeder.cs
new file mode 100644
index 0000000000..07b0a29f08
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIDataSeeder.cs
@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+using Volo.Abp.Data;
+using Volo.Abp.DependencyInjection;
+
+namespace Unity.AI.DataSeed;
+
+public class AIDataSeeder(
+    AIPromptDataSeeder promptDataSeeder,
+    AIModelDataSeeder modelDataSeeder,
+    AIOperationDataSeeder operationDataSeeder) : IDataSeedContributor, ITransientDependency
+{
+    public async Task SeedAsync(DataSeedContext context)
+    {
+        await promptDataSeeder.SeedAsync(context);
+        await modelDataSeeder.SeedAsync(context);
+        await operationDataSeeder.SeedAsync(context);
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
index 68cce573ed..facd43663e 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
@@ -1,12 +1,8 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Configuration;
 using Unity.AI.Domain;
-using Unity.AI.Prompts;
 using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
@@ -14,9 +10,15 @@
 namespace Unity.AI.DataSeed;
 
 public class AIModelDataSeeder(
-    IRepository<AIModel, Guid> modelRepository,
-    IConfiguration configuration) : IDataSeedContributor, ITransientDependency
+    IRepository<AIModel, Guid> modelRepository) : ITransientDependency
 {
+    private static readonly BuiltInModelDefinition[] BuiltInModels =
+    [
+        new("Gpt4oMini", true, 0.3d),
+        new("Gpt5Mini", false, null),
+        new("Gpt5Nano", false, null)
+    ];
+
     public async Task SeedAsync(DataSeedContext context)
     {
         if (context.TenantId != null)
@@ -24,48 +26,21 @@ public async Task SeedAsync(DataSeedContext context)
             return;
         }
 
-        var providerName = Optional("Azure:Operations:Defaults:Provider");
-        var defaultProfileName = Optional("Azure:Operations:Defaults:Profile");
-        if (providerName == null || defaultProfileName == null)
-        {
-            return;
-        }
-
-        var profilesSection = configuration.GetSection($"Azure:{providerName}:Profiles");
-        var profileNames = profilesSection
-            .GetChildren()
-            .Select(section => section.Key)
-            .Where(name => !string.IsNullOrWhiteSpace(name))
-            .Distinct(StringComparer.OrdinalIgnoreCase)
-            .ToList();
-
-        if (!profileNames.Contains(defaultProfileName, StringComparer.OrdinalIgnoreCase))
+        foreach (var model in BuiltInModels)
         {
-            profileNames.Add(defaultProfileName);
-        }
-
-        foreach (var profileName in profileNames)
-        {
-            var deploymentName = Optional($"Azure:{providerName}:Profiles:{profileName}:DeploymentName");
-            if (deploymentName == null)
-            {
-                continue;
-            }
-
-            await EnsureModelAsync(
-                profileName,
-                new AIModelSettings
-                {
-                    MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
-                    Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
-                });
+            await EnsureModelAsync(model);
         }
-
     }
 
-    private async Task EnsureModelAsync(string modelName, AIModelSettings settings)
+    private async Task EnsureModelAsync(BuiltInModelDefinition definition)
     {
-        var existing = await modelRepository.FirstOrDefaultAsync(model => model.Name == modelName);
+        var settings = new AIModelSettings
+        {
+            MaxOutputTokenCountSupported = definition.MaxOutputTokenCountSupported,
+            Temperature = definition.Temperature
+        };
+
+        var existing = await modelRepository.FirstOrDefaultAsync(model => model.Name == definition.Name);
         if (existing != null)
         {
             existing.IsActive = true;
@@ -75,32 +50,16 @@ private async Task EnsureModelAsync(string modelName, AIModelSettings settings)
         }
 
         await modelRepository.InsertAsync(
-            new AIModel(Guid.CreateVersion7(), modelName)
+            new AIModel(Guid.CreateVersion7(), definition.Name)
             {
                 IsActive = true,
                 SettingsJson = JsonSerializer.Serialize(settings)
-            });
-    }
-
-    private string? Optional(string key)
-    {
-        var value = configuration[key];
-        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+            },
+            autoSave: true);
     }
 
-    private bool? OptionalBool(string key)
-    {
-        var value = Optional(key);
-        return value != null && bool.TryParse(value, out var parsedValue)
-            ? parsedValue
-            : null;
-    }
-
-    private double? OptionalDouble(string key)
-    {
-        var value = Optional(key);
-        return value != null && double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var parsedValue)
-            ? parsedValue
-            : null;
-    }
+    private sealed record BuiltInModelDefinition(
+        string Name,
+        bool MaxOutputTokenCountSupported,
+        double? Temperature);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
index ed22ba9ca4..18d3da31e9 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
@@ -1,12 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.AI.Operations;
 using Unity.AI.Prompts;
+using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Data;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
@@ -18,12 +18,19 @@ public class AIOperationDataSeeder(
     IRepository<AIOperation, Guid> operationRepository,
     IRepository<AIModel, Guid> modelRepository,
     IRepository<AIPrompt, Guid> promptRepository,
-    IConfiguration configuration,
+    IRepository<AIGenerationRequest, Guid> requestRepository,
     ICurrentTenant currentTenant,
-    ILogger<AIOperationDataSeeder> logger) : IDataSeedContributor, ITransientDependency
+    ILogger<AIOperationDataSeeder> logger) : ITransientDependency
 {
-    private const string DefaultOperationName = "Default";
-    private const string DefaultOperationPromptType = AIPromptTypes.ApplicationAnalysis;
+    private const string DefaultModelName = "Gpt5Mini";
+
+    private static readonly BuiltInOperationDefinition[] BuiltInOperations =
+    [
+        new("Default", AIPromptTypes.ApplicationAnalysis, 4000, true),
+        new(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, 4000),
+        new(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, 2000),
+        new(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, 8000)
+    ];
 
     public async Task SeedAsync(DataSeedContext context)
     {
@@ -34,124 +41,64 @@ public async Task SeedAsync(DataSeedContext context)
 
         using (currentTenant.Change(null))
         {
-            var model = await EnsureConfiguredDefaultModelAsync();
+            var model = await EnsureModelAsync(DefaultModelName);
             if (model == null)
             {
-                logger.LogWarning("AI operation seeding skipped: no model is configured. Check Azure:Operations:Defaults:Provider and Azure:Operations:Defaults:Profile settings.");
+                logger.LogWarning("AI operation seeding skipped: model '{ModelName}' is missing.", DefaultModelName);
                 return;
             }
 
-            await EnsureOperationAsync(DefaultOperationName, DefaultOperationPromptType, model, isDefaultOperation: true);
-            await EnsureOperationAsync(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, model);
-            await EnsureOperationAsync(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, model);
-            await EnsureOperationAsync(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, model);
+            foreach (var definition in BuiltInOperations)
+            {
+                await EnsureOperationAsync(definition, model);
+            }
+
+            await BackfillRequestOperationIdsAsync();
         }
     }
 
-    private async Task EnsureOperationAsync(
-        string operationName,
-        string promptName,
-        AIModel model,
-        bool isDefaultOperation = false)
+    private async Task EnsureOperationAsync(BuiltInOperationDefinition definition, AIModel model)
     {
-        var prompt = await ResolveLatestActivePromptAsync(promptName);
+        var prompt = await ResolveLatestActivePromptAsync(definition.PromptName);
         if (prompt == null)
         {
-            if (isDefaultOperation)
-            {
-                logger.LogWarning("AI default operation seeding skipped: no active prompt found for '{PromptName}'.", promptName);
-            }
-            else
-            {
-                logger.LogWarning("AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}'.", operationName, promptName);
-            }
-            return;
-        }
-
-        var completionTokens = ResolveCompletionTokens(promptName);
-        if (completionTokens == null)
-        {
-            if (isDefaultOperation)
+            if (definition.IsDefaultOperation)
             {
-                logger.LogWarning("AI default operation seeding skipped: MaxCompletionTokens not configured for '{PromptName}'.", promptName);
+                logger.LogWarning("AI default operation seeding skipped: no active prompt found for '{PromptName}'.", definition.PromptName);
             }
             else
             {
-                logger.LogWarning("AI operation seeding skipped: MaxCompletionTokens not configured for operation '{OperationName}' (prompt '{PromptName}').", operationName, promptName);
+                logger.LogWarning("AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}'.", definition.OperationName, definition.PromptName);
             }
             return;
         }
 
-        var existing = await operationRepository.FirstOrDefaultAsync(op => op.Name == operationName);
+        var existing = await operationRepository.FirstOrDefaultAsync(op => op.Name == definition.OperationName);
         if (existing != null)
         {
             existing.AIModelId = model.Id;
             existing.AIPromptId = prompt.Id;
             existing.ExecutionMode = AIExecutionMode.Sequential;
-            existing.CompletionTokens = completionTokens.Value;
+            existing.CompletionTokens = definition.CompletionTokens;
             existing.IsActive = true;
             await operationRepository.UpdateAsync(existing);
             return;
         }
 
         await operationRepository.InsertAsync(
-            new AIOperation(Guid.CreateVersion7(), operationName, model.Id, prompt.Id)
+            new AIOperation(Guid.CreateVersion7(), definition.OperationName, model.Id, prompt.Id)
             {
                 ExecutionMode = AIExecutionMode.Sequential,
-                CompletionTokens = completionTokens.Value,
+                CompletionTokens = definition.CompletionTokens,
                 IsActive = true
-            });
+            },
+            autoSave: true);
     }
 
-    private async Task<AIModel?> EnsureConfiguredDefaultModelAsync()
+    private async Task<AIModel?> EnsureModelAsync(string modelName)
     {
-        var providerName = Optional("Azure:Operations:Defaults:Provider");
-        var profileName = Optional("Azure:Operations:Defaults:Profile");
-        if (providerName == null || profileName == null)
-        {
-            return null;
-        }
-
-        var deploymentName = Optional($"Azure:{providerName}:Profiles:{profileName}:DeploymentName");
-        if (deploymentName == null)
-        {
-            return null;
-        }
-
-        var existing = await modelRepository.FirstOrDefaultAsync(model => model.Name == profileName && model.IsActive);
-        if (existing != null)
-        {
-            existing.SettingsJson = System.Text.Json.JsonSerializer.Serialize(new AIModelSettings
-            {
-                MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
-                Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
-            });
-            await modelRepository.UpdateAsync(existing);
-            return existing;
-        }
-
-        var settings = new AIModelSettings
-        {
-            MaxOutputTokenCountSupported = OptionalBool($"Azure:{providerName}:Profiles:{profileName}:MaxOutputTokenCountSupported") ?? true,
-            Temperature = OptionalDouble($"Azure:{providerName}:Profiles:{profileName}:Temperature")
-        };
-
-        var existingInactive = await modelRepository.FirstOrDefaultAsync(model => model.Name == profileName);
-        if (existingInactive != null)
-        {
-            existingInactive.IsActive = true;
-            existingInactive.SettingsJson = System.Text.Json.JsonSerializer.Serialize(settings);
-            return await modelRepository.UpdateAsync(existingInactive);
-        }
-
-        var model = await modelRepository.InsertAsync(
-            new AIModel(Guid.CreateVersion7(), profileName)
-            {
-                IsActive = true,
-                SettingsJson = System.Text.Json.JsonSerializer.Serialize(settings)
-            });
-
-        return model;
+        var models = await modelRepository.GetListAsync(model => model.Name == modelName && model.IsActive);
+        return models.FirstOrDefault();
     }
 
     private async Task<AIPrompt?> ResolveLatestActivePromptAsync(string promptName)
@@ -162,38 +109,45 @@ await operationRepository.InsertAsync(
             .FirstOrDefault();
     }
 
-    private string? Optional(string key)
+    private async Task BackfillRequestOperationIdsAsync()
     {
-        var value = configuration[key];
-        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
-    }
+        var requests = await requestRepository.GetListAsync(request => request.OperationId == null);
+        if (requests.Count == 0)
+        {
+            return;
+        }
 
-    private int? OptionalPositiveInt(string key)
-    {
-        var value = configuration.GetValue<int?>(key);
-        return value is > 0 ? value : null;
-    }
+        var operations = await operationRepository.GetListAsync();
+        var operationsByName = operations.ToDictionary(operation => operation.Name, StringComparer.OrdinalIgnoreCase);
 
-    private int? ResolveCompletionTokens(string operationName)
-    {
-        var value = OptionalPositiveInt($"Azure:Operations:{operationName}:MaxCompletionTokens")
-            ?? OptionalPositiveInt("Azure:Operations:Defaults:MaxCompletionTokens");
-        return value;
-    }
+        foreach (var request in requests)
+        {
+            var operationType = ResolveOperationTypeFromRequestKey(request.RequestKey);
+            if (operationType == null)
+            {
+                continue;
+            }
 
-    private bool? OptionalBool(string key)
-    {
-        var value = Optional(key);
-        return value != null && bool.TryParse(value, out var parsedValue)
-            ? parsedValue
-            : null;
+            var operationName = AIGenerationRequestKeyHelper.ResolveOperationName(operationType);
+            if (operationName == null || !operationsByName.TryGetValue(operationName, out var operation))
+            {
+                continue;
+            }
+
+            request.OperationId = operation.Id;
+            await requestRepository.UpdateAsync(request, autoSave: true);
+        }
     }
 
-    private double? OptionalDouble(string key)
+    private static string? ResolveOperationTypeFromRequestKey(string requestKey)
     {
-        var value = Optional(key);
-        return value != null && double.TryParse(value, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var parsedValue)
-            ? parsedValue
-            : null;
+        var parts = requestKey.Split(':', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        return parts.Length == 3 ? parts[2] : null;
     }
+
+    private sealed record BuiltInOperationDefinition(
+        string OperationName,
+        string PromptName,
+        int CompletionTokens,
+        bool IsDefaultOperation = false);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 13e2896aae..86eef4e885 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -17,7 +17,7 @@ namespace Unity.AI.DataSeed;
 /// </summary>
 public class AIPromptDataSeeder(
     IRepository<AIPrompt, Guid> promptRepository,
-    ICurrentTenant currentTenant) : IDataSeedContributor, ITransientDependency
+    ICurrentTenant currentTenant) : ITransientDependency
 {
     public async Task SeedAsync(DataSeedContext context)
     {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
index 6a5f5b7f66..60232e3acc 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
@@ -6,7 +6,7 @@ namespace Unity.GrantManager.GrantApplications;
 public class AIGenerationRequestDto : EntityDto<Guid>
 {
     public Guid? ApplicationId { get; set; }
-    public Guid OperationId { get; set; }
+    public Guid? OperationId { get; set; }
     public string OperationType { get; set; } = string.Empty;
     public string RequestKey { get; set; } = string.Empty;
     public AIGenerationRequestStatus Status { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index 1162fbea33..9d2fae3b32 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -36,7 +36,7 @@ public class AIGenerationStatusAppService(
         var item = query
             .Where(x =>
                 x.ApplicationId == applicationId &&
-                x.OperationId == operation.Id &&
+            x.OperationId == operation.Id &&
                 x.TenantId == resolvedTenantId)
             .OrderByDescending(x => x.CreationTime)
             .ThenByDescending(x => x.Id)
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
index 94fc5a1bf1..0d01a27416 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
@@ -8,7 +8,7 @@ public class AIGenerationRequest : FullAuditedAggregateRoot<Guid>, IMultiTenant
 {
     public Guid? TenantId { get; set; }
     public Guid? ApplicationId { get; set; }
-    public Guid OperationId { get; set; }
+    public Guid? OperationId { get; set; }
     public string RequestKey { get; set; } = string.Empty;
     public AIGenerationRequestStatus Status { get; set; }
     public DateTime? StartedAt { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
index 06b877d8ee..ed7a01c5ad 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
@@ -239,16 +239,16 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
             b.HasIndex(x => new { x.Source, x.Status });
         });
 
-        modelBuilder.Entity<AIGenerationRequest>(b =>
-        {
-            b.ToTable(GrantManagerConsts.DbTablePrefix + "AIRequests", AIDbProperties.DbSchema);
-            b.ConfigureByConvention();
-            b.Property(x => x.OperationId).IsRequired();
-            b.Property(x => x.RequestKey).IsRequired().HasMaxLength(256);
-            b.Property(x => x.FailureReason).HasMaxLength(2000);
-            b.Property(x => x.Status).IsRequired();
-            b.HasOne<AIOperation>()
-                .WithMany()
+        modelBuilder.Entity<AIGenerationRequest>(b =>
+        {
+            b.ToTable(GrantManagerConsts.DbTablePrefix + "AIRequests", AIDbProperties.DbSchema);
+            b.ConfigureByConvention();
+            b.Property(x => x.OperationId);
+            b.Property(x => x.RequestKey).IsRequired().HasMaxLength(256);
+            b.Property(x => x.FailureReason).HasMaxLength(2000);
+            b.Property(x => x.Status).IsRequired();
+            b.HasOne<AIOperation>()
+                .WithMany()
                 .HasForeignKey(x => x.OperationId)
                 .OnDelete(DeleteBehavior.Restrict);
             b.HasIndex(x => x.RequestKey);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 1bc60b6449..75f6662ddd 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -13,146 +13,192 @@ protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.Sql(
                 """
-                DROP INDEX IF EXISTS "AI"."IX_AIPrompts_Name";
+                DROP TABLE IF EXISTS "AI"."AIPromptVersions";
+                DROP TABLE IF EXISTS "AI"."AIPrompts";
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ADD COLUMN IF NOT EXISTS "OperationId" uuid;
+                CREATE TABLE "AI"."AIModels" (
+                    "Id" uuid NOT NULL,
+                    "Name" character varying(200) NOT NULL,
+                    "IsActive" boolean NOT NULL,
+                    "SettingsJson" jsonb NOT NULL,
+                    "ExtraProperties" text NOT NULL,
+                    "ConcurrencyStamp" character varying(40) NOT NULL,
+                    "CreationTime" timestamp without time zone NOT NULL,
+                    "CreatorId" uuid NULL,
+                    "LastModificationTime" timestamp without time zone NULL,
+                    "LastModifierId" uuid NULL,
+                    "DeleterId" uuid NULL,
+                    "DeletionTime" timestamp without time zone NULL,
+                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
+                    PRIMARY KEY ("Id")
+                );
                 """);
 
             migrationBuilder.Sql(
                 """
-                UPDATE "AI"."AIRequests" r
-                SET "OperationId" = o."Id"
-                FROM "AI"."AIOperations" o
-                WHERE r."OperationId" IS NULL
-                  AND (
-                      (r."OperationType" = 'application-analysis' AND o."Name" = 'ApplicationAnalysis')
-                      OR (r."OperationType" = 'attachment-summary' AND o."Name" = 'AttachmentSummary')
-                      OR (r."OperationType" = 'application-scoring' AND o."Name" = 'ApplicationScoring')
-                      OR (r."OperationType" = 'pipeline' AND o."Name" = 'Default')
-                  );
+                CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIModels_Name"
+                ON "AI"."AIModels" ("Name");
                 """);
 
             migrationBuilder.Sql(
                 """
-                DO $$
-                BEGIN
-                    IF EXISTS (
-                        SELECT 1
-                        FROM "AI"."AIRequests"
-                        WHERE "OperationId" IS NULL
-                    ) THEN
-                        RAISE EXCEPTION 'AIRequests contains rows that cannot be mapped to OperationId.';
-                    END IF;
-                END $$;
+                CREATE TABLE "AI"."AIPrompts" (
+                    "Id" uuid NOT NULL,
+                    "TenantId" uuid NULL,
+                    "Name" character varying(200) NOT NULL,
+                    "VersionNumber" integer NOT NULL,
+                    "SystemPrompt" text NOT NULL,
+                    "UserPrompt" text NOT NULL,
+                    "MetadataJson" jsonb NULL,
+                    "IsActive" boolean NOT NULL,
+                    "ExtraProperties" text NOT NULL,
+                    "ConcurrencyStamp" character varying(40) NOT NULL,
+                    "CreationTime" timestamp without time zone NOT NULL,
+                    "CreatorId" uuid NULL,
+                    "LastModificationTime" timestamp without time zone NULL,
+                    "LastModifierId" uuid NULL,
+                    "DeleterId" uuid NULL,
+                    "DeletionTime" timestamp without time zone NULL,
+                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
+                    PRIMARY KEY ("Id")
+                );
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ALTER COLUMN "OperationId" SET NOT NULL;
+                CREATE UNIQUE INDEX "IX_AIPrompts_Name_VersionNumber"
+                ON "AI"."AIPrompts" ("TenantId", "Name", "VersionNumber");
                 """);
 
             migrationBuilder.Sql(
                 """
-                DROP INDEX IF EXISTS "AI"."IX_AIRequests_TenantId_ApplicationId_OperationType_Status";
+                CREATE TABLE "AI"."AIOperations" (
+                    "Id" uuid NOT NULL,
+                    "Name" character varying(200) NOT NULL,
+                    "AIModelId" uuid NOT NULL,
+                    "AIPromptId" uuid NOT NULL,
+                    "ExecutionMode" character varying(20) NOT NULL,
+                    "CompletionTokens" integer NOT NULL,
+                    "IsActive" boolean NOT NULL,
+                    "ExtraProperties" text NOT NULL,
+                    "ConcurrencyStamp" character varying(40) NOT NULL,
+                    "CreationTime" timestamp without time zone NOT NULL,
+                    "CreatorId" uuid NULL,
+                    "LastModificationTime" timestamp without time zone NULL,
+                    "LastModifierId" uuid NULL,
+                    "DeleterId" uuid NULL,
+                    "DeletionTime" timestamp without time zone NULL,
+                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
+                    PRIMARY KEY ("Id")
+                );
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                DROP COLUMN IF EXISTS "OperationType";
+                CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIOperations_Name"
+                ON "AI"."AIOperations" ("Name");
                 """);
 
-            migrationBuilder.CreateIndex(
-                name: "IX_AIRequests_TenantId_ApplicationId_OperationId_Status",
-                schema: "AI",
-                table: "AIRequests",
-                columns: new[] { "TenantId", "ApplicationId", "OperationId", "Status" });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_AIRequests_OperationId",
-                schema: "AI",
-                table: "AIRequests",
-                column: "OperationId");
-
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ADD CONSTRAINT "FK_AIRequests_AIOperations_OperationId"
-                FOREIGN KEY ("OperationId") REFERENCES "AI"."AIOperations" ("Id") ON DELETE RESTRICT;
+                DO $$
+                BEGIN
+                    IF NOT EXISTS (
+                        SELECT 1
+                        FROM pg_constraint
+                        WHERE conname = 'FK_AIOperations_AIModels_AIModelId'
+                    ) THEN
+                        ALTER TABLE "AI"."AIOperations"
+                        ADD CONSTRAINT "FK_AIOperations_AIModels_AIModelId"
+                        FOREIGN KEY ("AIModelId") REFERENCES "AI"."AIModels" ("Id") ON DELETE RESTRICT;
+                    END IF;
+                END $$;
                 """);
-        }
 
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
             migrationBuilder.Sql(
                 """
-                DROP INDEX IF EXISTS "AI"."IX_AIRequests_TenantId_ApplicationId_OperationType_Status";
+                DO $$
+                BEGIN
+                    IF NOT EXISTS (
+                        SELECT 1
+                        FROM pg_constraint
+                        WHERE conname = 'FK_AIOperations_AIPrompts_AIPromptId'
+                    ) THEN
+                        ALTER TABLE "AI"."AIOperations"
+                        ADD CONSTRAINT "FK_AIOperations_AIPrompts_AIPromptId"
+                        FOREIGN KEY ("AIPromptId") REFERENCES "AI"."AIPrompts" ("Id") ON DELETE RESTRICT;
+                    END IF;
+                END $$;
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                DROP CONSTRAINT IF EXISTS "FK_AIRequests_AIOperations_OperationId";
+                DROP TABLE IF EXISTS "AI"."AIPromptVersions";
                 """);
 
-            migrationBuilder.DropIndex(
-                name: "IX_AIRequests_OperationId",
-                schema: "AI",
-                table: "AIRequests");
-
-            migrationBuilder.DropIndex(
-                name: "IX_AIRequests_TenantId_ApplicationId_OperationId_Status",
-                schema: "AI",
-                table: "AIRequests");
+            migrationBuilder.Sql(
+                """
+                DO $$
+                BEGIN
+                    IF NOT EXISTS (
+                        SELECT 1
+                        FROM information_schema.columns
+                        WHERE table_schema = 'AI'
+                          AND table_name = 'AIRequests'
+                          AND column_name = 'OperationId'
+                    ) THEN
+                        ALTER TABLE "AI"."AIRequests"
+                        ADD COLUMN "OperationId" uuid NULL;
+                    END IF;
+                END $$;
+                """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ADD COLUMN IF NOT EXISTS "OperationType" character varying(64) NOT NULL DEFAULT '';
+                CREATE INDEX IF NOT EXISTS "IX_AIRequests_RequestKey"
+                ON "AI"."AIRequests" ("RequestKey");
                 """);
 
             migrationBuilder.Sql(
                 """
-                UPDATE "AI"."AIRequests"
-                SET "OperationType" = CASE
-                    WHEN "OperationId" IS NOT NULL THEN
-                        COALESCE(
-                            (SELECT CASE o."Name"
-                                WHEN 'ApplicationAnalysis' THEN 'application-analysis'
-                                WHEN 'AttachmentSummary' THEN 'attachment-summary'
-                                WHEN 'ApplicationScoring' THEN 'application-scoring'
-                                WHEN 'Default' THEN 'pipeline'
-                            END
-                            FROM "AI"."AIOperations" o
-                            WHERE o."Id" = "OperationId"),
-                            'application-analysis'
-                        )
-                    ELSE 'application-analysis'
-                END;
+                CREATE INDEX IF NOT EXISTS "IX_AIRequests_OperationId"
+                ON "AI"."AIRequests" ("OperationId");
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ALTER COLUMN "OperationType" DROP DEFAULT;
+                DO $$
+                BEGIN
+                    IF NOT EXISTS (
+                        SELECT 1
+                        FROM pg_constraint
+                        WHERE conname = 'FK_AIRequests_AIOperations_OperationId'
+                    ) THEN
+                        ALTER TABLE "AI"."AIRequests"
+                        ADD CONSTRAINT "FK_AIRequests_AIOperations_OperationId"
+                        FOREIGN KEY ("OperationId") REFERENCES "AI"."AIOperations" ("Id") ON DELETE RESTRICT;
+                    END IF;
+                END $$;
                 """);
 
             migrationBuilder.Sql(
                 """
-                ALTER TABLE "AI"."AIRequests"
-                ALTER COLUMN "OperationType" SET NOT NULL;
+                CREATE INDEX "IX_AIRequests_TenantId_ApplicationId_OperationId_Status"
+                ON "AI"."AIRequests" ("TenantId", "ApplicationId", "OperationId", "Status");
                 """);
+        }
 
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
             migrationBuilder.Sql(
                 """
-                CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIRequests_TenantId_ApplicationId_OperationType_Status"
-                ON "AI"."AIRequests" ("TenantId", "ApplicationId", "OperationType", "Status");
+                DROP TABLE IF EXISTS "AI"."AIRequests";
+                DROP TABLE IF EXISTS "AI"."AIPromptVersions";
+                DROP TABLE IF EXISTS "AI"."AIPrompts";
                 """);
         }
     }

From 9ce185dd8ac898a4569d86133d20a091f5f9899f Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 12:20:58 -0700
Subject: [PATCH 19/61] AB#32307 flatten AI prompt editing

---
 .../Prompts/AIPromptDto.cs                    |   1 -
 .../Prompts/AIPromptVersionDto.cs             |  14 --
 .../Prompts/CreateUpdateAIPromptDto.cs        |   6 +-
 .../Prompts/CreateUpdateAIPromptVersionDto.cs |  27 ----
 .../Prompts/IAIPromptAppService.cs            |   1 +
 .../Prompts/IAIPromptVersionAppService.cs     |  14 --
 .../AI/Prompts/Versions/README.md             |  48 -------
 .../AIApplicationMapperlyProfile.cs           |   9 +-
 .../Prompts/AIPromptAppService.cs             |  40 +++++-
 .../Prompts/AIPromptVersionAppService.cs      | 121 ------------------
 .../CreateEntryModal.cshtml}                  |   8 +-
 .../Entries/CreateEntryModal.cshtml.cs        |  34 +++++
 .../EditEntryModal.cshtml}                    |   8 +-
 .../EditEntryModal.cshtml.cs}                 |  18 +--
 .../Versions/CreateVersionModal.cshtml.cs     |  34 -----
 15 files changed, 94 insertions(+), 289 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptVersionAppService.cs
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/README.md
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
 rename applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/{Versions/CreateVersionModal.cshtml => Entries/CreateEntryModal.cshtml} (70%)
 create mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml.cs
 rename applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/{Versions/EditVersionModal.cshtml => Entries/EditEntryModal.cshtml} (72%)
 rename applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/{Versions/EditVersionModal.cshtml.cs => Entries/EditEntryModal.cshtml.cs} (56%)
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
index 5903cdc248..d5b673b699 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptDto.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using Volo.Abp.Application.Dtos;
 
 namespace Unity.AI.Prompts;
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
deleted file mode 100644
index f21d2e8d4e..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/AIPromptVersionDto.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System;
-using Volo.Abp.Application.Dtos;
-
-namespace Unity.AI.Prompts;
-
-public class AIPromptVersionDto : AuditedEntityDto<Guid>
-{
-    public string Name { get; set; } = string.Empty;
-    public int VersionNumber { get; set; }
-    public string SystemPrompt { get; set; } = string.Empty;
-    public string UserPrompt { get; set; } = string.Empty;
-    public string? MetadataJson { get; set; }
-    public bool IsActive { get; set; }
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
index 37435424f7..e26973030a 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptDto.cs
@@ -1,3 +1,4 @@
+using System;
 using System.ComponentModel;
 using System.ComponentModel.DataAnnotations;
 
@@ -5,10 +6,7 @@ namespace Unity.AI.Prompts;
 
 public class CreateUpdateAIPromptDto
 {
-    [Required]
-    [MaxLength(200)]
-    [DisplayName("PromptName")]
-    public string Name { get; set; } = string.Empty;
+    public Guid PromptId { get; set; }
 
     [DisplayName("VersionNumber")]
     public int VersionNumber { get; set; }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
deleted file mode 100644
index 9ce8423b96..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/CreateUpdateAIPromptVersionDto.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-using System;
-using System.ComponentModel;
-using System.ComponentModel.DataAnnotations;
-
-namespace Unity.AI.Prompts;
-
-public class CreateUpdateAIPromptVersionDto
-{
-    public Guid PromptId { get; set; }
-
-    [DisplayName("VersionNumber")]
-    public int VersionNumber { get; set; }
-
-    [Required]
-    [DisplayName("SystemPrompt")]
-    public string SystemPrompt { get; set; } = string.Empty;
-
-    [Required]
-    [DisplayName("UserPrompt")]
-    public string UserPrompt { get; set; } = string.Empty;
-
-    [DisplayName("MetadataJson")]
-    public string? MetadataJson { get; set; }
-
-    [DisplayName("PromptIsActive")]
-    public bool IsActive { get; set; } = true;
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptAppService.cs
index c259996db0..7aca79853d 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptAppService.cs
@@ -10,4 +10,5 @@ public interface IAIPromptAppService : ICrudAppService<
     PagedAndSortedResultRequestDto,
     CreateUpdateAIPromptDto>
 {
+    System.Threading.Tasks.Task<ListResultDto<AIPromptDto>> GetByPromptAsync(Guid promptId);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptVersionAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptVersionAppService.cs
deleted file mode 100644
index 269029e5ec..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Prompts/IAIPromptVersionAppService.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-using System;
-using Volo.Abp.Application.Dtos;
-using Volo.Abp.Application.Services;
-
-namespace Unity.AI.Prompts;
-
-public interface IAIPromptVersionAppService : ICrudAppService<
-    AIPromptVersionDto,
-    Guid,
-    PagedAndSortedResultRequestDto,
-    CreateUpdateAIPromptVersionDto>
-{
-    System.Threading.Tasks.Task<ListResultDto<AIPromptVersionDto>> GetByPromptAsync(Guid promptId);
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/README.md b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/README.md
deleted file mode 100644
index 0f6146d2ab..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/README.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# Runtime Prompt Templates
-
-Runtime prompts are now resolved from the database-backed `AIPrompts` and `AIPromptVersions` records seeded by the AI module.
-These files are retained as prompt asset references and seed inputs, not as the runtime source of truth.
-
-Current prompt asset references:
-
-- `application-analysis.system.txt`
-- `application-analysis.user.txt`
-- `application-analysis.rubric.txt` (optional, when `{{RUBRIC}}` is used)
-- `application-analysis.score.txt` (optional, when `{{SCORE}}` is used)
-- `application-analysis.output.txt` (optional, when `{{OUTPUT}}` is used)
-- `application-analysis.rules.txt` (optional, when `{{RULES}}` is used)
-- `common.*.txt` (optional shared fragments for `{{COMMON_*}}` placeholders)
-- `attachment-summary.system.txt`
-- `attachment-summary.user.txt`
-- `attachment-summary.output.txt` (optional, when `{{OUTPUT}}` is used)
-- `attachment-summary.rules.txt` (optional, when `{{RULES}}` is used)
-- `application-scoring.system.txt`
-- `application-scoring.user.txt`
-- `application-scoring.output.txt` (optional, when `{{OUTPUT}}` is used)
-- `application-scoring.rules.txt` (optional, when `{{RULES}}` is used)
-
-Placeholders:
-
-- `{{SCHEMA}}`
-- `{{DATA}}`
-- `{{ATTACHMENTS}}`
-- `{{RUBRIC}}`
-- `{{SCORE}}`
-- `{{OUTPUT}}`
-- `{{RULES}}`
-- `{{ATTACHMENT}}`
-- `{{DATA}}`
-- `{{ATTACHMENTS}}`
-- `{{SECTION}}`
-- `{{RESPONSE}}`
-
-Version selection:
-
-- Required: `Azure:Operations:Defaults:PromptVersion = v0|v1`, with optional overrides under `Azure:Operations:<Operation>:PromptVersion`.
-- Unknown or missing version values fail at runtime.
-
-Template loading is strict:
-
-- Core prompt records are required for each version.
-- Missing required prompt records fail fast at runtime with a configuration error.
-- Runtime prompt rendering resolves placeholders from the stored template text plus the version metadata sections.
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
index 589ac6aea2..b799fbd3ea 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AIApplicationMapperlyProfile.cs
@@ -27,6 +27,7 @@ private static AIPrompt CreateAIPrompt() =>
     [MapperIgnoreTarget(nameof(AIPrompt.CreatorId))]
     [MapperIgnoreTarget(nameof(AIPrompt.LastModificationTime))]
     [MapperIgnoreTarget(nameof(AIPrompt.LastModifierId))]
+    [MapperIgnoreTarget(nameof(AIPrompt.Name))]
     public override partial AIPrompt Map(CreateUpdateAIPromptDto source);
 
     [MapperIgnoreTarget(nameof(AIPrompt.TenantId))]
@@ -35,13 +36,7 @@ private static AIPrompt CreateAIPrompt() =>
     [MapperIgnoreTarget(nameof(AIPrompt.CreatorId))]
     [MapperIgnoreTarget(nameof(AIPrompt.LastModificationTime))]
     [MapperIgnoreTarget(nameof(AIPrompt.LastModifierId))]
+    [MapperIgnoreTarget(nameof(AIPrompt.Name))]
     public override partial void Map(CreateUpdateAIPromptDto source, AIPrompt destination);
 }
 
-[Mapper]
-public partial class AIPromptToAIPromptVersionDtoMapper : MapperBase<AIPrompt, AIPromptVersionDto>
-{
-    public override partial AIPromptVersionDto Map(AIPrompt source);
-
-    public override partial void Map(AIPrompt source, AIPromptVersionDto destination);
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
index 9a3f66ec94..de45c9b88e 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.Modules.Shared.Permissions;
@@ -38,6 +40,19 @@ public AIPromptAppService(
         DeletePolicyName = IdentityConsts.ITOperationsPolicyName;
     }
 
+    [HttpGet("by-prompt/{promptId}")]
+    public async Task<ListResultDto<AIPromptDto>> GetByPromptAsync(Guid promptId)
+    {
+        using (_multiTenantDataFilter.Disable())
+        {
+            var selected = await Repository.GetAsync(promptId);
+            var items = await Repository.GetListAsync(v => v.TenantId == selected.TenantId && v.Name == selected.Name);
+            var sorted = items.OrderBy(v => v.VersionNumber).ToList();
+            return new ListResultDto<AIPromptDto>(
+                ObjectMapper.Map<List<AIPrompt>, List<AIPromptDto>>(sorted));
+        }
+    }
+
     [HttpGet("{id}")]
     public override async Task<AIPromptDto> GetAsync(Guid id)
     {
@@ -61,7 +76,21 @@ public override async Task<AIPromptDto> CreateAsync(CreateUpdateAIPromptDto inpu
     {
         using (_multiTenantDataFilter.Disable())
         {
-            return await base.CreateAsync(input);
+            var prompt = await Repository.GetAsync(input.PromptId);
+            var entity = await Repository.InsertAsync(
+                new AIPrompt(
+                    Guid.CreateVersion7(),
+                    prompt.Name,
+                    input.VersionNumber,
+                    input.SystemPrompt,
+                    input.UserPrompt,
+                    prompt.TenantId)
+                {
+                    MetadataJson = input.MetadataJson,
+                    IsActive = input.IsActive
+                });
+
+            return ObjectMapper.Map<AIPrompt, AIPromptDto>(entity);
         }
     }
 
@@ -70,7 +99,14 @@ public override async Task<AIPromptDto> UpdateAsync(Guid id, CreateUpdateAIPromp
     {
         using (_multiTenantDataFilter.Disable())
         {
-            return await base.UpdateAsync(id, input);
+            var entity = await Repository.GetAsync(id);
+            entity.VersionNumber = input.VersionNumber;
+            entity.SystemPrompt = input.SystemPrompt;
+            entity.UserPrompt = input.UserPrompt;
+            entity.MetadataJson = input.MetadataJson;
+            entity.IsActive = input.IsActive;
+            entity = await Repository.UpdateAsync(entity);
+            return ObjectMapper.Map<AIPrompt, AIPromptDto>(entity);
         }
     }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
deleted file mode 100644
index 94349658ee..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptVersionAppService.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Mvc;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Unity.AI.Domain;
-using Unity.Modules.Shared.Permissions;
-using Volo.Abp.Data;
-using Volo.Abp.Application.Dtos;
-using Volo.Abp.Application.Services;
-using Volo.Abp.Domain.Repositories;
-using Volo.Abp.MultiTenancy;
-
-namespace Unity.AI.Prompts;
-
-[Authorize(IdentityConsts.ITOperationsPolicyName)]
-[Route("api/app/ai/prompt-versions")]
-public class AIPromptVersionAppService :
-    CrudAppService<
-        AIPrompt,
-        AIPromptVersionDto,
-        Guid,
-        PagedAndSortedResultRequestDto,
-        CreateUpdateAIPromptVersionDto>,
-    IAIPromptVersionAppService
-{
-    private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter;
-
-    public AIPromptVersionAppService(
-        IRepository<AIPrompt, Guid> repository,
-        IDataFilter<IMultiTenant> multiTenantDataFilter)
-        : base(repository)
-    {
-        _multiTenantDataFilter = multiTenantDataFilter;
-        GetPolicyName = IdentityConsts.ITOperationsPolicyName;
-        GetListPolicyName = IdentityConsts.ITOperationsPolicyName;
-        CreatePolicyName = IdentityConsts.ITOperationsPolicyName;
-        UpdatePolicyName = IdentityConsts.ITOperationsPolicyName;
-        DeletePolicyName = IdentityConsts.ITOperationsPolicyName;
-    }
-
-    [HttpGet("by-prompt/{promptId}")]
-    public async Task<ListResultDto<AIPromptVersionDto>> GetByPromptAsync(Guid promptId)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            var selected = await Repository.GetAsync(promptId);
-            var items = await Repository.GetListAsync(v => v.TenantId == selected.TenantId && v.Name == selected.Name);
-            var sorted = items.OrderBy(v => v.VersionNumber).ToList();
-            return new ListResultDto<AIPromptVersionDto>(
-                ObjectMapper.Map<List<AIPrompt>, List<AIPromptVersionDto>>(sorted));
-        }
-    }
-
-    [HttpGet("{id}")]
-    public override async Task<AIPromptVersionDto> GetAsync(Guid id)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            return await base.GetAsync(id);
-        }
-    }
-
-    [HttpGet]
-    public override async Task<PagedResultDto<AIPromptVersionDto>> GetListAsync(PagedAndSortedResultRequestDto input)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            return await base.GetListAsync(input);
-        }
-    }
-
-    [HttpPost]
-    public override async Task<AIPromptVersionDto> CreateAsync(CreateUpdateAIPromptVersionDto input)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            var prompt = await Repository.GetAsync(input.PromptId);
-            var entity = await Repository.InsertAsync(
-                new AIPrompt(
-                    Guid.CreateVersion7(),
-                    prompt.Name,
-                    input.VersionNumber,
-                    input.SystemPrompt,
-                    input.UserPrompt,
-                    prompt.TenantId)
-                {
-                    MetadataJson = input.MetadataJson,
-                    IsActive = input.IsActive
-                });
-
-            return ObjectMapper.Map<AIPrompt, AIPromptVersionDto>(entity);
-        }
-    }
-
-    [HttpPut("{id}")]
-    public override async Task<AIPromptVersionDto> UpdateAsync(Guid id, CreateUpdateAIPromptVersionDto input)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            var entity = await Repository.GetAsync(id);
-            entity.VersionNumber = input.VersionNumber;
-            entity.SystemPrompt = input.SystemPrompt;
-            entity.UserPrompt = input.UserPrompt;
-            entity.MetadataJson = input.MetadataJson;
-            entity.IsActive = input.IsActive;
-            entity = await Repository.UpdateAsync(entity);
-            return ObjectMapper.Map<AIPrompt, AIPromptVersionDto>(entity);
-        }
-    }
-
-    [HttpDelete("{id}")]
-    public override async Task DeleteAsync(Guid id)
-    {
-        using (_multiTenantDataFilter.Disable())
-        {
-            await base.DeleteAsync(id);
-        }
-    }
-}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml
similarity index 70%
rename from applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml
rename to applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml
index 38acee10e0..85da100816 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml
@@ -1,17 +1,17 @@
 @page
 @using Unity.AI.Localization
-@using Unity.AI.Web.Pages.Prompts.Versions
+@using Unity.AI.Web.Pages.Prompts.Entries
 @using Microsoft.Extensions.Localization
 @using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
-@model CreateVersionModalModel
+@model CreateEntryModalModel
 @inject IStringLocalizer<AIResource> L
 @{
     Layout = null;
 }
 
-<abp-dynamic-form abp-model="Version" asp-page="/Prompts/Versions/CreateVersionModal">
+<abp-dynamic-form abp-model="Prompt" asp-page="/Prompts/Entries/CreateEntryModal">
     <abp-modal>
-        <abp-modal-header title="@L["AIPromptVersion"].Value"></abp-modal-header>
+        <abp-modal-header title="@L["AIPrompt"].Value"></abp-modal-header>
         <abp-modal-body>
             <abp-form-content />
         </abp-modal-body>
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml.cs
new file mode 100644
index 0000000000..ee1e53654a
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/CreateEntryModal.cshtml.cs
@@ -0,0 +1,34 @@
+using Microsoft.AspNetCore.Mvc;
+using System;
+using System.Threading.Tasks;
+using Unity.AI.Prompts;
+using Volo.Abp.AspNetCore.Mvc.UI.RazorPages;
+
+namespace Unity.AI.Web.Pages.Prompts.Entries;
+
+public class CreateEntryModalModel : AbpPageModel
+{
+    [BindProperty]
+    public CreateUpdateAIPromptDto Prompt { get; set; } = new();
+
+    private readonly IAIPromptAppService _promptAppService;
+
+    public CreateEntryModalModel(IAIPromptAppService promptAppService)
+    {
+        _promptAppService = promptAppService;
+    }
+
+    public void OnGet(Guid promptId)
+    {
+        Prompt = new CreateUpdateAIPromptDto
+        {
+            PromptId = promptId
+        };
+    }
+
+    public async Task<IActionResult> OnPostAsync()
+    {
+        await _promptAppService.CreateAsync(Prompt);
+        return NoContent();
+    }
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml
similarity index 72%
rename from applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml
rename to applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml
index 2f1e96ea4f..6ca56cf1c7 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml
@@ -1,17 +1,17 @@
 @page
 @using Unity.AI.Localization
-@using Unity.AI.Web.Pages.Prompts.Versions
+@using Unity.AI.Web.Pages.Prompts.Entries
 @using Microsoft.Extensions.Localization
 @using Volo.Abp.AspNetCore.Mvc.UI.Bootstrap.TagHelpers.Modal
-@model EditVersionModalModel
+@model EditEntryModalModel
 @inject IStringLocalizer<AIResource> L
 @{
     Layout = null;
 }
 
-<abp-dynamic-form abp-model="Version" asp-page="/Prompts/Versions/EditVersionModal">
+<abp-dynamic-form abp-model="Prompt" asp-page="/Prompts/Entries/EditEntryModal">
     <abp-modal>
-        <abp-modal-header title="@L["AIPromptVersion"].Value"></abp-modal-header>
+        <abp-modal-header title="@L["AIPrompt"].Value"></abp-modal-header>
         <abp-modal-body>
             <abp-input asp-for="Id" />
             <abp-form-content />
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml.cs
similarity index 56%
rename from applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs
rename to applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml.cs
index cf9947f77d..b2f2a5dcc0 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/EditVersionModal.cshtml.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Entries/EditEntryModal.cshtml.cs
@@ -4,28 +4,28 @@
 using Unity.AI.Prompts;
 using Volo.Abp.AspNetCore.Mvc.UI.RazorPages;
 
-namespace Unity.AI.Web.Pages.Prompts.Versions;
+namespace Unity.AI.Web.Pages.Prompts.Entries;
 
-public class EditVersionModalModel : AbpPageModel
+public class EditEntryModalModel : AbpPageModel
 {
     [HiddenInput]
     [BindProperty(SupportsGet = true)]
     public Guid Id { get; set; }
 
     [BindProperty]
-    public CreateUpdateAIPromptVersionDto Version { get; set; } = new();
+    public CreateUpdateAIPromptDto Prompt { get; set; } = new();
 
-    private readonly IAIPromptVersionAppService _versionAppService;
+    private readonly IAIPromptAppService _promptAppService;
 
-    public EditVersionModalModel(IAIPromptVersionAppService versionAppService)
+    public EditEntryModalModel(IAIPromptAppService promptAppService)
     {
-        _versionAppService = versionAppService;
+        _promptAppService = promptAppService;
     }
 
     public async Task OnGetAsync()
     {
-        var dto = await _versionAppService.GetAsync(Id);
-        Version = new CreateUpdateAIPromptVersionDto
+        var dto = await _promptAppService.GetAsync(Id);
+        Prompt = new CreateUpdateAIPromptDto
         {
             PromptId = dto.Id,
             VersionNumber = dto.VersionNumber,
@@ -38,7 +38,7 @@ public async Task OnGetAsync()
 
     public async Task<IActionResult> OnPostAsync()
     {
-        await _versionAppService.UpdateAsync(Id, Version);
+        await _promptAppService.UpdateAsync(Id, Prompt);
         return NoContent();
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs
deleted file mode 100644
index 53b3b0c54f..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Versions/CreateVersionModal.cshtml.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-using System;
-using System.Threading.Tasks;
-using Unity.AI.Prompts;
-using Volo.Abp.AspNetCore.Mvc.UI.RazorPages;
-
-namespace Unity.AI.Web.Pages.Prompts.Versions;
-
-public class CreateVersionModalModel : AbpPageModel
-{
-    [BindProperty]
-    public CreateUpdateAIPromptVersionDto Version { get; set; } = new();
-
-    private readonly IAIPromptVersionAppService _versionAppService;
-
-    public CreateVersionModalModel(IAIPromptVersionAppService versionAppService)
-    {
-        _versionAppService = versionAppService;
-    }
-
-    public void OnGet(Guid promptId)
-    {
-        Version = new CreateUpdateAIPromptVersionDto
-        {
-            PromptId = promptId
-        };
-    }
-
-    public async Task<IActionResult> OnPostAsync()
-    {
-        await _versionAppService.CreateAsync(Version);
-        return NoContent();
-    }
-}

From a28ba7c1a8014a7b43e614bb9f1b8f0b18741f45 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 12:21:05 -0700
Subject: [PATCH 20/61] AB#32307 update AI tests for strict seeding

---
 .../AI/DataSeed/AIModelDataSeederTests.cs     | 38 ++++------
 .../AI/DataSeed/AIOperationDataSeederTests.cs | 73 ++++++++-----------
 .../OpenAIConfigurationResolverTests.cs       | 35 +++++++++
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   | 38 ++++------
 4 files changed, 94 insertions(+), 90 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
index ae6380b57b..f0a66345d1 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIModelDataSeederTests.cs
@@ -1,8 +1,8 @@
-using Microsoft.Extensions.Configuration;
 using NSubstitute;
 using Shouldly;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
 using Unity.AI.DataSeed;
@@ -24,7 +24,7 @@ public async Task Should_Seed_All_Configured_Profiles()
             .FirstOrDefaultAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIModel, bool>>>())
             .Returns((AIModel?)null);
         modelRepository
-            .InsertAsync(Arg.Any<AIModel>())
+            .InsertAsync(Arg.Any<AIModel>(), Arg.Any<bool>(), Arg.Any<System.Threading.CancellationToken>())
             .Returns(callInfo =>
             {
                 var model = callInfo.Arg<AIModel>();
@@ -32,35 +32,25 @@ public async Task Should_Seed_All_Configured_Profiles()
                 return Task.FromResult(model);
             });
 
-        var configuration = BuildConfiguration(new Dictionary<string, string?>
-        {
-            ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
-            ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
-            ["Azure:OpenAI:Profiles:Gpt5Mini:Temperature"] = "0.15",
-            ["Azure:OpenAI:Profiles:Gpt5Nano:DeploymentName"] = "gpt-5-nano",
-            ["Azure:OpenAI:Endpoint"] = "https://example.test"
-        });
-
-        var seeder = new AIModelDataSeeder(modelRepository, configuration);
+        var seeder = new AIModelDataSeeder(modelRepository);
 
         await seeder.SeedAsync(new DataSeedContext());
 
-        insertedModels.Count.ShouldBe(2);
+        insertedModels.Count.ShouldBe(3);
+        insertedModels.ShouldContain(model => model.Name == "Gpt4oMini" && model.IsActive);
         insertedModels.ShouldContain(model => model.Name == "Gpt5Mini" && model.IsActive);
         insertedModels.ShouldContain(model => model.Name == "Gpt5Nano" && model.IsActive);
 
-        var gpt5MiniModel = insertedModels.Find(model => model.Name == "Gpt5Mini");
-        gpt5MiniModel.ShouldNotBeNull();
-        DeserializeSettings(gpt5MiniModel.SettingsJson).MaxOutputTokenCountSupported.ShouldBeTrue();
-        DeserializeSettings(gpt5MiniModel.SettingsJson).Temperature.ShouldBe(0.15);
-    }
+        var gpt4oMini = insertedModels.Single(model => model.Name == "Gpt4oMini");
+        var gpt5Mini = insertedModels.Single(model => model.Name == "Gpt5Mini");
+        var gpt5Nano = insertedModels.Single(model => model.Name == "Gpt5Nano");
 
-    private static IConfiguration BuildConfiguration(IReadOnlyDictionary<string, string?> values)
-    {
-        return new ConfigurationBuilder()
-            .AddInMemoryCollection(values)
-            .Build();
+        DeserializeSettings(gpt4oMini.SettingsJson).MaxOutputTokenCountSupported.ShouldBeTrue();
+        DeserializeSettings(gpt4oMini.SettingsJson).Temperature.ShouldBe(0.3);
+        DeserializeSettings(gpt5Mini.SettingsJson).MaxOutputTokenCountSupported.ShouldBeFalse();
+        DeserializeSettings(gpt5Mini.SettingsJson).Temperature.ShouldBeNull();
+        DeserializeSettings(gpt5Nano.SettingsJson).MaxOutputTokenCountSupported.ShouldBeFalse();
+        DeserializeSettings(gpt5Nano.SettingsJson).Temperature.ShouldBeNull();
     }
 
     private static AIModelSettings DeserializeSettings(string settingsJson)
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
index 5cff2c9648..401f1568e8 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
@@ -1,4 +1,3 @@
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
 using Shouldly;
@@ -12,6 +11,7 @@
 using Unity.AI.DataSeed;
 using Unity.AI.Domain;
 using Unity.AI.Prompts;
+using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
@@ -22,26 +22,36 @@ namespace Unity.GrantManager.AI.DataSeed;
 public class AIOperationDataSeederTests
 {
     [Fact]
-    public async Task Should_Seed_Configured_Default_Profile_Model_When_Missing()
+    public async Task Should_Seed_BuiltIn_Model_And_Operations()
     {
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository
             .GetQueryableAsync()
             .Returns(Task.FromResult(new List<AIOperation>().AsQueryable()));
+        operationRepository
+            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIOperation, bool>>>())
+            .Returns(Task.FromResult(new List<AIOperation>()));
 
         var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
-        var insertedModels = new List<AIModel>();
+        var model = new AIModel(Guid.NewGuid(), "Gpt5Mini")
+        {
+            IsActive = true,
+            SettingsJson = """
+            {
+              "MaxOutputTokenCountSupported": true,
+              "Temperature": null
+            }
+            """
+        };
         modelRepository
             .GetQueryableAsync()
-            .Returns(Task.FromResult(new List<AIModel>().AsQueryable()));
+            .Returns(Task.FromResult(new List<AIModel> { model }.AsQueryable()));
         modelRepository
-            .InsertAsync(Arg.Any<AIModel>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo =>
-            {
-                var model = callInfo.Arg<AIModel>();
-                insertedModels.Add(model);
-                return Task.FromResult(model);
-            });
+            .GetListAsync()
+            .Returns(Task.FromResult(new List<AIModel> { model }));
+        modelRepository
+            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIModel, bool>>>())
+            .Returns(Task.FromResult(new List<AIModel> { model }));
 
         var insertedOperations = new List<AIOperation>();
         operationRepository
@@ -68,46 +78,25 @@ public async Task Should_Seed_Configured_Default_Profile_Model_When_Missing()
                 return Task.FromResult(prompts.Where(predicate).ToList());
             });
 
+        var requestRepository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
+        requestRepository
+            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIGenerationRequest, bool>>>())
+            .Returns(Task.FromResult(new List<AIGenerationRequest>()));
         var currentTenant = Substitute.For<ICurrentTenant>();
-        var configuration = BuildConfiguration(new Dictionary<string, string?>
-        {
-            ["Azure:Operations:Defaults:Provider"] = "OpenAI",
-            ["Azure:Operations:Defaults:Profile"] = "Gpt5Mini",
-            ["Azure:OpenAI:Profiles:Gpt5Mini:DeploymentName"] = "gpt-5-mini",
-            ["Azure:OpenAI:Endpoint"] = "https://example.test",
-            ["Azure:Operations:ApplicationAnalysis:MaxCompletionTokens"] = "4000",
-            ["Azure:Operations:AttachmentSummary:MaxCompletionTokens"] = "2000",
-            ["Azure:Operations:ApplicationScoring:MaxCompletionTokens"] = "8000"
-        });
-
         var seeder = new AIOperationDataSeeder(
             operationRepository,
             modelRepository,
             promptRepository,
-            configuration,
+            requestRepository,
             currentTenant,
             Substitute.For<ILogger<AIOperationDataSeeder>>());
 
         await seeder.SeedAsync(new DataSeedContext());
 
-        insertedModels.Count.ShouldBe(1);
-        insertedModels[0].Name.ShouldBe("Gpt5Mini");
-        DeserializeSettings(insertedModels[0].SettingsJson).MaxOutputTokenCountSupported.ShouldBeTrue();
-        DeserializeSettings(insertedModels[0].SettingsJson).Temperature.ShouldBeNull();
-
-    }
-
-    private static IConfiguration BuildConfiguration(IReadOnlyDictionary<string, string?> values)
-    {
-        return new ConfigurationBuilder()
-            .AddInMemoryCollection(values)
-            .Build();
-    }
-
-    private static AIModelSettings DeserializeSettings(string settingsJson)
-    {
-        var settings = JsonSerializer.Deserialize<AIModelSettings>(settingsJson);
-        settings.ShouldNotBeNull();
-        return settings;
+        insertedOperations.Count.ShouldBe(4);
+        insertedOperations.ShouldContain(operation => operation.Name == "Default" && operation.IsActive);
+        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.ApplicationAnalysis && operation.CompletionTokens == 4000);
+        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.AttachmentSummary && operation.CompletionTokens == 2000);
+        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.ApplicationScoring && operation.CompletionTokens == 8000);
     }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index e81d02f899..e0099c5d10 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -52,6 +52,17 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
                 })
             });
 
+        operationRepository
+            .GetListAsync()
+            .Returns(Task.FromResult(new List<AIOperation>
+            {
+                new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                {
+                    ExecutionMode = AIExecutionMode.Sequential,
+                    CompletionTokens = 2222,
+                    IsActive = true
+                }
+            }));
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
             .Returns(callInfo =>
@@ -117,6 +128,17 @@ public async Task Should_Fallback_To_Default_Operation_When_Override_Is_Missing(
                 })
             });
 
+        operationRepository
+            .GetListAsync()
+            .Returns(Task.FromResult(new List<AIOperation>
+            {
+                new(Guid.NewGuid(), "Default", modelId, promptId)
+                {
+                    ExecutionMode = AIExecutionMode.Sequential,
+                    CompletionTokens = 2000,
+                    IsActive = true
+                }
+            }));
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
             .Returns(callInfo =>
@@ -244,6 +266,16 @@ public async Task Should_Resolve_Operation_Settings_From_Host_Context()
                 })
             });
 
+        operationRepository
+            .GetListAsync()
+            .Returns(Task.FromResult(new List<AIOperation>
+            {
+                new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                {
+                    IsActive = true,
+                    CompletionTokens = 2000
+                }
+            }));
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
             .Returns(callInfo =>
@@ -334,6 +366,9 @@ private static IRepository<AIModel, Guid> CreateEmptyModelRepository()
     private static IRepository<AIOperation, Guid> CreateEmptyOperationRepository()
     {
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
+        operationRepository
+            .GetListAsync()
+            .Returns(Task.FromResult(new List<AIOperation>()));
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
             .Returns(Task.FromResult(new List<AIOperation>()));
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index 8c48f3985e..68c07143a9 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -1,15 +1,13 @@
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
 using Shouldly;
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using System.Text.Json;
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.AI.Operations;
-using Unity.AI.Requests;
+using Unity.AI.Prompts;
 using Unity.AI.Runtime;
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
@@ -22,44 +20,36 @@ public class OpenAIRuntimeServiceTests
 {
     [Fact]
     public async Task Should_Throw_When_Analysis_Operation_Is_Not_Configured()
+    {
+        var resolver = CreateResolverWithNoOperations();
+
+        var ex = await Should.ThrowAsync<Exception>(() =>
+            resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
+
+    }
+
+    private static OpenAIConfigurationResolver CreateResolverWithNoOperations()
     {
         var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
         modelRepository
             .GetListAsync(Arg.Any<Expression<Func<AIModel, bool>>>())
-            .Returns(new List<AIModel>());
+            .Returns(Task.FromResult(new List<AIModel>()));
 
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
-            .Returns(new List<AIOperation>());
+            .Returns(Task.FromResult(new List<AIOperation>()));
 
         var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
-        var configuration = new ConfigurationBuilder().Build();
+        var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build();
         var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
         multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
 
-        var resolver = new OpenAIConfigurationResolver(
+        return new OpenAIConfigurationResolver(
             modelRepository,
             operationRepository,
             promptRepository,
             configuration,
             multiTenantDataFilter);
-
-        var logger = Substitute.For<ILogger<OpenAIRuntimeService>>();
-        var runtimeService = new OpenAIRuntimeService(
-            logger,
-            null!,
-            resolver,
-            null!,
-            null!);
-
-        var ex = await Should.ThrowAsync<InvalidOperationException>(() =>
-            runtimeService.GenerateApplicationAnalysisAsync(new ApplicationAnalysisRequest
-            {
-                Schema = JsonSerializer.SerializeToElement(new { project = "x" }),
-                Data = JsonSerializer.SerializeToElement(new { project = "x" })
-            }));
-
-        ex.Message.ShouldContain("AI operation");
     }
 }

From 41722211f2e0a9afd96bc01f251945af3b43e3c6 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 12:27:55 -0700
Subject: [PATCH 21/61] AB#32307 fix prompt edit modal compile break

---
 .../Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs  | 1 -
 1 file changed, 1 deletion(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
index ea394f2c2a..b99da8ecf8 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/EditModal.cshtml.cs
@@ -27,7 +27,6 @@ public async Task OnGetAsync()
         var dto = await _promptAppService.GetAsync(Id);
         Prompt = new CreateUpdateAIPromptDto
         {
-            Name = dto.Name,
             VersionNumber = dto.VersionNumber,
             SystemPrompt = dto.SystemPrompt,
             UserPrompt = dto.UserPrompt,

From 458846c7bf71b965c07a56dd36ad29b23e682074 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 15:19:03 -0700
Subject: [PATCH 22/61] AB#32307 simplify AI schema rebuild

---
 .../20260624191335_RefreshAiSchema.cs         | 46 +++++++++++--------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 75f6662ddd..781ffddf29 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -13,6 +13,9 @@ protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.Sql(
                 """
+                DROP TABLE IF EXISTS "AI"."AIRequests";
+                DROP TABLE IF EXISTS "AI"."AIOperations";
+                DROP TABLE IF EXISTS "AI"."AIModels";
                 DROP TABLE IF EXISTS "AI"."AIPromptVersions";
                 DROP TABLE IF EXISTS "AI"."AIPrompts";
                 """);
@@ -136,24 +139,27 @@ ADD CONSTRAINT "FK_AIOperations_AIPrompts_AIPromptId"
 
             migrationBuilder.Sql(
                 """
-                DROP TABLE IF EXISTS "AI"."AIPromptVersions";
-                """);
-
-            migrationBuilder.Sql(
-                """
-                DO $$
-                BEGIN
-                    IF NOT EXISTS (
-                        SELECT 1
-                        FROM information_schema.columns
-                        WHERE table_schema = 'AI'
-                          AND table_name = 'AIRequests'
-                          AND column_name = 'OperationId'
-                    ) THEN
-                        ALTER TABLE "AI"."AIRequests"
-                        ADD COLUMN "OperationId" uuid NULL;
-                    END IF;
-                END $$;
+                CREATE TABLE "AI"."AIRequests" (
+                    "Id" uuid NOT NULL,
+                    "TenantId" uuid NULL,
+                    "ApplicationId" uuid NULL,
+                    "OperationId" uuid NULL,
+                    "RequestKey" character varying(255) NOT NULL,
+                    "Status" integer NOT NULL,
+                    "StartedAt" timestamp without time zone NULL,
+                    "CompletedAt" timestamp without time zone NULL,
+                    "FailureReason" character varying(2000) NULL,
+                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
+                    "DeleterId" uuid NULL,
+                    "DeletionTime" timestamp without time zone NULL,
+                    "ExtraProperties" text NOT NULL,
+                    "ConcurrencyStamp" character varying(40) NOT NULL,
+                    "CreationTime" timestamp without time zone NOT NULL,
+                    "CreatorId" uuid NULL,
+                    "LastModificationTime" timestamp without time zone NULL,
+                    "LastModifierId" uuid NULL,
+                    PRIMARY KEY ("Id")
+                );
                 """);
 
             migrationBuilder.Sql(
@@ -186,7 +192,7 @@ ADD CONSTRAINT "FK_AIRequests_AIOperations_OperationId"
 
             migrationBuilder.Sql(
                 """
-                CREATE INDEX "IX_AIRequests_TenantId_ApplicationId_OperationId_Status"
+                CREATE INDEX IF NOT EXISTS "IX_AIRequests_TenantId_ApplicationId_OperationId_Status"
                 ON "AI"."AIRequests" ("TenantId", "ApplicationId", "OperationId", "Status");
                 """);
         }
@@ -197,6 +203,8 @@ protected override void Down(MigrationBuilder migrationBuilder)
             migrationBuilder.Sql(
                 """
                 DROP TABLE IF EXISTS "AI"."AIRequests";
+                DROP TABLE IF EXISTS "AI"."AIOperations";
+                DROP TABLE IF EXISTS "AI"."AIModels";
                 DROP TABLE IF EXISTS "AI"."AIPromptVersions";
                 DROP TABLE IF EXISTS "AI"."AIPrompts";
                 """);

From 5badab4bdbff58bf1852e9372b3b0dc92b1d7601 Mon Sep 17 00:00:00 2001
From: aurelio-aot <aurelio.pascual.jr@gmail.com>
Date: Tue, 30 Jun 2026 15:19:58 -0700
Subject: [PATCH 23/61] AB#33228: Cancel Payment Transaction - Initial Draft

---
 .../Enums/PaymentRequestStatus.cs             |    1 +
 .../IPaymentRequestAppService.cs              |    1 +
 .../PaymentRequests/PaymentRequestDto.cs      |    5 +
 .../Domain/PaymentRequests/PaymentRequest.cs  |   13 +
 .../Domain/Services/IPaymentsManager.cs       |    4 +-
 .../Domain/Services/PaymentsManager.cs        |   32 +-
 .../Domain/Shared/PaymentsAction.cs           |    3 +-
 ...aymentsDbContextModelCreatingExtensions.cs |    5 +
 .../Repositories/PaymentRequestRepository.cs  |    1 +
 .../PaymentRequestAppService.cs               |   28 +-
 .../PaymentsPermissionDefinitionProvider.cs   |    1 +
 .../Localization/Payments/en.json             |    2 +
 .../Permissions/PaymentsPermissions.cs        |    1 +
 .../Pages/PaymentRequests/Index.js            |  102 +-
 ...dCancellationToPaymentRequests.Designer.cs | 5249 +++++++++++++++++
 ...211933_AddCancellationToPaymentRequests.cs |   57 +
 .../GrantTenantDbContextModelSnapshot.cs      |  263 +-
 17 files changed, 5667 insertions(+), 101 deletions(-)
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.Designer.cs
 create mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/Enums/PaymentRequestStatus.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/Enums/PaymentRequestStatus.cs
index 9d0bd15462..63d6e4e348 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/Enums/PaymentRequestStatus.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/Enums/PaymentRequestStatus.cs
@@ -19,5 +19,6 @@ public enum PaymentRequestStatus
         Failed = 11,        
         FSB = 12, // Financial Services Branch - Prevent CAS Payment
         HistoricalPayment = 13,
+        Cancelled = 14,
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/IPaymentRequestAppService.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/IPaymentRequestAppService.cs
index d4b8dd0de1..3040e3e8ba 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/IPaymentRequestAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/IPaymentRequestAppService.cs
@@ -25,5 +25,6 @@ public interface IPaymentRequestAppService : IApplicationService
         Task<List<PaymentRequestDto>> GetPaymentPendingListByCorrelationIdsAsync(IEnumerable<Guid> correlationIds);
         Task<ApplicationPaymentRollupDto> GetApplicationPaymentRollupAsync(Guid applicationId);
         Task<Dictionary<Guid, ApplicationPaymentRollupDto>> GetApplicationPaymentRollupBatchAsync(List<Guid> applicationIds);
+        Task<PaymentRequestDto> CancelAsync(Guid paymentRequestId);
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/PaymentRequestDto.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/PaymentRequestDto.cs
index c959af41f9..ac0498a57f 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/PaymentRequestDto.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application.Contracts/PaymentRequests/PaymentRequestDto.cs
@@ -51,6 +51,11 @@ public class PaymentRequestDto : AuditedEntityDto<Guid>, IMultiTenant
         public string? Category { get; set; }
         public Guid? TenantId { get; set; }
 
+        // Cancellation tracking
+        public DateTime? CancelledOn { get; set; }
+        public Guid? CancelledById { get; set; }
+        public string? CancelledBy { get; set; }
+
         public static explicit operator PaymentRequestDto(CreatePaymentRequestDto v)
         {
             throw new NotImplementedException();
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/PaymentRequests/PaymentRequest.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/PaymentRequests/PaymentRequest.cs
index 8a2f4d4314..4742e2178b 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/PaymentRequests/PaymentRequest.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/PaymentRequests/PaymentRequest.cs
@@ -64,6 +64,11 @@ public class PaymentRequest : FullAuditedAggregateRoot<Guid>, IMultiTenant, ICor
         public virtual DateTime? FsbNotificationSentDate { get; private set; }
         public virtual string? FsbApNotified { get; private set; }
 
+        // Cancellation tracking
+        public virtual DateTime? CancelledOn { get; private set; }
+        public virtual Guid? CancelledById { get; private set; }
+        public virtual string? CancelledBy { get; private set; }
+
         protected PaymentRequest()
         {
             ExpenseApprovals = [];
@@ -222,6 +227,14 @@ public PaymentRequest ClearFsbNotificationEmailLog()
             return this;
         }
 
+        public PaymentRequest SetCancellation(DateTime cancelledOn, Guid cancelledById, string cancelledBy)
+        {
+            CancelledOn = cancelledOn;
+            CancelledById = cancelledById;
+            CancelledBy = cancelledBy;
+            return this;
+        }
+
         public PaymentRequest ValidatePaymentRequest()
         {
             if (Amount <= 0)
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/IPaymentsManager.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/IPaymentsManager.cs
index bccb0910c3..a69beb5b69 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/IPaymentsManager.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/IPaymentsManager.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Unity.Payments.Domain.PaymentRequests;
 using Unity.Payments.Domain.Shared;
 
 namespace Unity.Payments.Domain.Services
@@ -7,7 +8,8 @@ namespace Unity.Payments.Domain.Services
     public interface IPaymentsManager
     {
         Task UpdatePaymentStatusAsync(Guid paymentRequestId, PaymentApprovalAction triggerAction);
+        Task<PaymentRequest> CancelPaymentAsync(Guid paymentRequestId);
         Task<bool> GetFormPreventPaymentStatusByPaymentRequestId(Guid paymentRequestId);
-        Task<bool> GetFormPreventPaymentStatusByApplicationId(Guid applicationId);        
+        Task<bool> GetFormPreventPaymentStatusByApplicationId(Guid applicationId);
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
index b7413f3c9d..1c2a57b101 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
@@ -49,10 +49,20 @@ private void ConfigureWorkflow(StateMachine<PaymentRequestStatus, PaymentApprova
 
             paymentStateMachine.Configure(PaymentRequestStatus.L3Pending)
                 .PermitIf(PaymentApprovalAction.Submit, PaymentRequestStatus.Submitted, () => HasPermissionAsync(PaymentsPermissions.Payments.L3ApproveOrDecline).GetAwaiter().GetResult())
-                .PermitIf(PaymentApprovalAction.L3Decline, PaymentRequestStatus.L3Declined, () => HasPermissionAsync(PaymentsPermissions.Payments.L3ApproveOrDecline).GetAwaiter().GetResult());
+                .PermitIf(PaymentApprovalAction.L3Decline, PaymentRequestStatus.L3Declined, () => HasPermissionAsync(PaymentsPermissions.Payments.L3ApproveOrDecline).GetAwaiter().GetResult())
+                .PermitIf(PaymentApprovalAction.Cancel, PaymentRequestStatus.Cancelled, () => HasPermissionAsync(PaymentsPermissions.Payments.CancelPayment).GetAwaiter().GetResult());
 
             paymentStateMachine.Configure(PaymentRequestStatus.L2Declined)
                 .PermitIf(PaymentApprovalAction.Submit, PaymentRequestStatus.Submitted, () => HasPermissionAsync(PaymentsPermissions.Payments.L2ApproveOrDecline).GetAwaiter().GetResult());
+
+            paymentStateMachine.Configure(PaymentRequestStatus.L1Pending)
+                .PermitIf(PaymentApprovalAction.Cancel, PaymentRequestStatus.Cancelled, () => HasPermissionAsync(PaymentsPermissions.Payments.CancelPayment).GetAwaiter().GetResult());
+
+            paymentStateMachine.Configure(PaymentRequestStatus.L2Pending)
+                .PermitIf(PaymentApprovalAction.Cancel, PaymentRequestStatus.Cancelled, () => HasPermissionAsync(PaymentsPermissions.Payments.CancelPayment).GetAwaiter().GetResult());
+
+            paymentStateMachine.Configure(PaymentRequestStatus.HistoricalPayment)
+                .PermitIf(PaymentApprovalAction.Cancel, PaymentRequestStatus.Cancelled, () => HasPermissionAsync(PaymentsPermissions.Payments.CancelPayment).GetAwaiter().GetResult());
         }
 
         private async Task<bool> HasPermissionAsync(string permission)
@@ -194,5 +204,25 @@ public async Task UpdatePaymentStatusAsync(Guid paymentRequestId, PaymentApprova
 
             await uow.SaveChangesAsync();
         }
+
+        [Volo.Abp.Uow.UnitOfWork]
+        public virtual async Task<PaymentRequest> CancelPaymentAsync(Guid paymentRequestId)
+        {
+            var paymentRequest = await paymentRequestRepository.GetAsync(paymentRequestId, true);
+            var statusChange = paymentRequest.Status;
+
+            var workflow = new PaymentsWorkflow<PaymentRequestStatus, PaymentApprovalAction>(
+                () => statusChange, s => statusChange = s, ConfigureWorkflow);
+
+            await workflow.ExecuteActionAsync(PaymentApprovalAction.Cancel);
+
+            paymentRequest.SetPaymentRequestStatus(PaymentRequestStatus.Cancelled);
+            paymentRequest.SetCancellation(
+                Clock.Now,
+                currentUser.GetId(),
+                $"{currentUser.Name} {currentUser.SurName}".Trim());
+
+            return await paymentRequestRepository.UpdateAsync(paymentRequest);
+        }
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Shared/PaymentsAction.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Shared/PaymentsAction.cs
index c449f1402e..26ad4fc611 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Shared/PaymentsAction.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Shared/PaymentsAction.cs
@@ -24,5 +24,6 @@ public enum PaymentApprovalAction
     L2Decline,
     L3Approve,
     L3Decline,
-    Submit
+    Submit,
+    Cancel
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/PaymentsDbContextModelCreatingExtensions.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/PaymentsDbContextModelCreatingExtensions.cs
index 1953c6caf4..2594d6aef9 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/PaymentsDbContextModelCreatingExtensions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/PaymentsDbContextModelCreatingExtensions.cs
@@ -55,6 +55,11 @@ public static void ConfigurePayments(
             b.Property(x => x.FsbNotificationSentDate).IsRequired(false);
             b.Property(x => x.FsbApNotified).IsRequired(false).HasMaxLength(10);
             b.HasIndex(x => x.FsbNotificationEmailLogId);
+
+            // Cancellation tracking
+            b.Property(x => x.CancelledOn).HasColumnName("CancelledOn").IsRequired(false);
+            b.Property(x => x.CancelledById).HasColumnName("CancelledById").IsRequired(false);
+            b.Property(x => x.CancelledBy).HasColumnName("CancelledBy").HasMaxLength(256).IsRequired(false);
         });
 
 
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/Repositories/PaymentRequestRepository.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/Repositories/PaymentRequestRepository.cs
index 98ac8546ee..4910b5e003 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/Repositories/PaymentRequestRepository.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/EntityFrameworkCore/Repositories/PaymentRequestRepository.cs
@@ -58,6 +58,7 @@ public async Task<decimal> GetTotalPaymentRequestAmountByCorrelationIdAsync(Guid
               .Where(p => p.Status != PaymentRequestStatus.L1Declined
                         && p.Status != PaymentRequestStatus.L2Declined
                         && p.Status != PaymentRequestStatus.L3Declined
+                        && p.Status != PaymentRequestStatus.Cancelled
                         && p.InvoiceStatus != CasPaymentRequestStatus.Cancelled
                         && p.InvoiceStatus != CasPaymentRequestStatus.NotFound
                         && p.InvoiceStatus != CasPaymentRequestStatus.ErrorFromCas)
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/PaymentRequests/PaymentRequestAppService.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/PaymentRequests/PaymentRequestAppService.cs
index 58a7ae9520..df3bde3fee 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/PaymentRequests/PaymentRequestAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/PaymentRequests/PaymentRequestAppService.cs
@@ -143,7 +143,10 @@ private static PaymentRequestDto MapToPaymentRequestDto(PaymentRequest result)
                 CreationTime = result.CreationTime,
                 Status = result.Status,
                 ReferenceNumber = result.ReferenceNumber,
-                SubmissionConfirmationCode = result.SubmissionConfirmationCode
+                SubmissionConfirmationCode = result.SubmissionConfirmationCode,
+                CancelledOn = result.CancelledOn,
+                CancelledById = result.CancelledById,
+                CancelledBy = result.CancelledBy
             };
         }
 
@@ -425,5 +428,28 @@ public async Task<Dictionary<Guid, ApplicationPaymentRollupDto>> GetApplicationP
             var childApplicationIdsByParent = await applicationLinksService.Value.GetChildApplicationIdsByParentIdsAsync(applicationIds);
             return await paymentRequestQueryManager.GetApplicationPaymentRollupBatchAsync(applicationIds, childApplicationIdsByParent);
         }
+
+        [Authorize(PaymentsPermissions.Payments.CancelPayment)]
+        public virtual async Task<PaymentRequestDto> CancelAsync(Guid paymentRequestId)
+        {
+            var payment = await paymentRequestQueryManager.GetPaymentRequestByIdAsync(paymentRequestId)
+                ?? throw new BusinessException("Payments:PaymentRequestNotFound")
+                    .WithData("Id", paymentRequestId);
+
+            PaymentRequestStatus[] eligibleStatuses =
+            [
+                PaymentRequestStatus.HistoricalPayment,
+                PaymentRequestStatus.L1Pending,
+                PaymentRequestStatus.L2Pending,
+                PaymentRequestStatus.L3Pending
+            ];
+
+            if (!eligibleStatuses.Contains(payment.Status))
+                throw new BusinessException("Payments:CancellationNotAllowed")
+                    .WithData("Status", payment.Status.ToString());
+
+            var result = await paymentsManager.CancelPaymentAsync(paymentRequestId);
+            return MapToPaymentRequestDto(result);
+        }
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Permissions/PaymentsPermissionDefinitionProvider.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Permissions/PaymentsPermissionDefinitionProvider.cs
index e4186e3b76..9dd29990d0 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Permissions/PaymentsPermissionDefinitionProvider.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Permissions/PaymentsPermissionDefinitionProvider.cs
@@ -20,6 +20,7 @@ public override void Define(IPermissionDefinitionContext context)
         paymentsPermissions.AddChild(PaymentsPermissions.Payments.RequestPayment, L("Permission:Payments.RequestPayment"));
         paymentsPermissions.AddChild(PaymentsPermissions.Payments.AccountCodingOverride, L("Permission:Payments.AccountCodingOverride"));
         paymentsPermissions.AddChild(PaymentsPermissions.Payments.AddHistoricalPayment, L("Permission:Payments.AddHistoricalPayment"));
+        paymentsPermissions.AddChild(PaymentsPermissions.Payments.CancelPayment, L("Permission:Payments.CancelPayment"));
 
         //-- PAYMENT INFO PERMISSIONS
         grantApplicationPermissionsGroup.Add_PaymentInfo_Permissions();
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Localization/Payments/en.json b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Localization/Payments/en.json
index 4dcdee5d03..ff25b18a72 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Localization/Payments/en.json
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Localization/Payments/en.json
@@ -130,6 +130,8 @@
     "Permission:Payments.AccountCodingOverride": "Override Account Coding",
     "Permission:Payments.EditFormPaymentConfiguration": "Edit Form Payment Configuration",
     "Permission:Payments.AddHistoricalPayment": "Add Historical Payment",
+    "Permission:Payments.CancelPayment": "Cancel Payment",
+    "Enum:PaymentRequestStatus.Cancelled": "Cancelled",
     "Enum:PaymentRequestStatus.L1Pending": "L1 Pending",
     "Enum:PaymentRequestStatus.L1Approved": "L1 Approved",
     "Enum:PaymentRequestStatus.L1Declined": "L1 Declined",
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Permissions/PaymentsPermissions.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Permissions/PaymentsPermissions.cs
index a0b470a799..efd2fb0af4 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Permissions/PaymentsPermissions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Shared/Permissions/PaymentsPermissions.cs
@@ -18,6 +18,7 @@ public static class Payments
         public const string EditSupplierInfo = Default + ".EditSupplierInfo";
         public const string EditFormPaymentConfiguration = Default + ".EditFormPaymentConfiguration";
         public const string AddHistoricalPayment = Default + ".AddHistoricalPayment";
+        public const string CancelPayment = Default + ".CancelPayment";
     }
 
     public static string[] GetAll()
diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
index 0c2d346be4..5aa96c5473 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
@@ -91,6 +91,7 @@ $(function () {
                     payment_approve_buttons.disable();
                     payment_check_status_buttons.disable();
                     history_button.disable();
+                    if (cancel_button) cancel_button.disable();
                     selectedPaymentIds = [];
                     PubSub.publish("deselect_batchpayment_application", "reset_data");
                 })
@@ -137,6 +138,38 @@ $(function () {
                     });
             }
         },
+        ...(abp.auth.isGranted('PaymentsPermissions.Payments.CancelPayment') ? [{
+            text: 'Cancel',
+            className: 'custom-table-btn flex-none btn btn-secondary payment-cancel',
+            action: function (e, dt, node, config) {
+                if (!selectedPaymentIds || selectedPaymentIds.length !== 1) return;
+                const rowData = dt.rows({ selected: true }).data().toArray()[0];
+                abp.message.confirm(
+                    `Are you sure you want to cancel the payment: "${rowData.referenceNumber}"?`,
+                    'Cancel Payment',
+                    function (confirmed) {
+                        if (!confirmed) return;
+                        unity.payments.paymentRequests.paymentRequest
+                            .cancel(selectedPaymentIds[0])
+                            .then(function () {
+                                abp.notify.success('Payment has been cancelled successfully.');
+                                $(".select-all-payments").prop("checked", false);
+                                payment_approve_buttons.disable();
+                                payment_check_status_buttons.disable();
+                                history_button.disable();
+                                if (cancel_button) cancel_button.disable();
+                                selectedPaymentIds = [];
+                                PubSub.publish("deselect_batchpayment_application", "reset_data");
+                                dataTable.ajax.reload(null, false);
+                            })
+                            .catch(function (err) {
+                                abp.notify.error('Failed to cancel payment. Please try again.');
+                                console.warn('Cancel payment error:', err);
+                            });
+                    }
+                );
+            }
+        }] : []),
         {
             text: 'History',
             className: 'custom-table-btn flex-none btn btn-secondary history',
@@ -366,10 +399,14 @@ $(function () {
     let payment_approve_buttons = dataTable.buttons(['.payment-status']);
     let payment_check_status_buttons = dataTable.buttons(['.payment-check-status']);
     let history_button = dataTable.buttons(['.history']);
+    let cancel_button = abp.auth.isGranted('PaymentsPermissions.Payments.CancelPayment')
+        ? dataTable.buttons(['.payment-cancel'])
+        : null;
 
     payment_approve_buttons.disable();
     payment_check_status_buttons.disable();
     history_button.disable();
+    if (cancel_button) cancel_button.disable();
     dataTable.on('search.dt', () => handleSearch());
 
     function checkAllRowsHaveState(states) {
@@ -452,7 +489,8 @@ $(function () {
             payment_check_status_buttons.disable();
         }
         let hasHistoricalPayment = dataTable.rows('.selected').data().toArray().some(row => row.status === 'HistoricalPayment');
-        if (dataTable.rows({ selected: true }).indexes().length > 0 && !isInSentState && !hasHistoricalPayment) {
+        let hasCancelledPayment = dataTable.rows('.selected').data().toArray().some(row => row.status === 'Cancelled');
+        if (dataTable.rows({ selected: true }).indexes().length > 0 && !isInSentState && !hasHistoricalPayment && !hasCancelledPayment) {
             if (abp.auth.isGranted('PaymentsPermissions.Payments.L1ApproveOrDecline')
                 || abp.auth.isGranted('PaymentsPermissions.Payments.L2ApproveOrDecline')
                 || abp.auth.isGranted('PaymentsPermissions.Payments.L3ApproveOrDecline')) {
@@ -468,6 +506,21 @@ $(function () {
             payment_approve_buttons.disable();
             checkEnableHistoryButton(dataTable, history_button);
         }
+
+        if (cancel_button) {
+            const eligibleCancelStatuses = ['HistoricalPayment', 'L1Pending', 'L2Pending', 'L3Pending'];
+            const selectedCount = dataTable.rows({ selected: true }).indexes().length;
+            if (selectedCount === 1) {
+                const rowData = dataTable.rows({ selected: true }).data().toArray()[0];
+                if (eligibleCancelStatuses.includes(rowData.status)) {
+                    cancel_button.enable();
+                } else {
+                    cancel_button.disable();
+                }
+            } else {
+                cancel_button.disable();
+            }
+        }
     }
 
     function handleSearch() {
@@ -517,11 +570,53 @@ $(function () {
             getNoteColumn(columnIndex++),
             getAccountDistributionColumn(columnIndex++),
             getFsbNotifiedColumn(columnIndex++),
+            getCancelledColumn(columnIndex++),
+            getCancelledByColumn(columnIndex++),
+            getCancelledOnColumn(columnIndex++),
         ]
 
         return columns.map((column) => ({ ...column, targets: [column.index], orderData: [column.index, 0] }));
     }
 
+    function getCancelledColumn(columnIndex) {
+        return {
+            title: 'Cancelled',
+            name: 'cancelled',
+            data: null,
+            className: 'data-table-header',
+            index: columnIndex,
+            render: function (data, type, row) {
+                return row.status === 'Cancelled' ? 'Cancelled' : '';
+            }
+        };
+    }
+
+    function getCancelledByColumn(columnIndex) {
+        return {
+            title: 'Cancelled By',
+            name: 'cancelledBy',
+            data: 'cancelledBy',
+            className: 'data-table-header',
+            index: columnIndex,
+            render: function (data) {
+                return data ?? '';
+            }
+        };
+    }
+
+    function getCancelledOnColumn(columnIndex) {
+        return {
+            title: 'Cancelled On',
+            name: 'cancelledOn',
+            data: 'cancelledOn',
+            className: 'data-table-header',
+            index: columnIndex,
+            render: function (data, type) {
+                return DateUtils.formatUtcDateToLocal(data, type);
+            }
+        };
+    }
+
     function getPaymentReferenceColumn(columnIndex) {
         return {
             title: l('ApplicationPaymentListTable:PaymentID'),
@@ -994,6 +1089,7 @@ $(function () {
         payment_approve_buttons.disable();
         payment_check_status_buttons.disable();
         history_button.disable();
+        if (cancel_button) cancel_button.disable();
         selectedPaymentIds = [];
         PubSub.publish("deselect_batchpayment_application", "reset_data");
     });
@@ -1028,6 +1124,9 @@ $(function () {
             case "Failed":
                 return "#CE3E39";
 
+            case "Cancelled":
+                return "#6c757d";
+
             default:
                 return "#053662";
         }
@@ -1050,6 +1149,7 @@ $(function () {
             payment_approve_buttons.disable();
             payment_check_status_buttons.disable();
             history_button.disable();
+            if (cancel_button) cancel_button.disable();
             selectedPaymentIds = [];
             PubSub.publish("deselect_batchpayment_application", "reset_data");
             PubSub.publish('clear_selected_payment');
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.Designer.cs
new file mode 100644
index 0000000000..fadcbc3a93
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.Designer.cs
@@ -0,0 +1,5249 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Unity.GrantManager.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    [DbContext(typeof(GrantTenantDbContext))]
+    [Migration("20260630211933_AddCancellationToPaymentRequests")]
+    partial class AddCancellationToPaymentRequests
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
+                .HasAnnotation("ProductVersion", "10.0.3")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("QuestionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ScoresheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("QuestionId");
+
+                    b.HasIndex("ScoresheetInstanceId");
+
+                    b.ToTable("Answers", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("Questions", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Scoresheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScoresheetId");
+
+                    b.ToTable("ScoresheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid>("CustomFieldId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetInstanceId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetInstanceId");
+
+                    b.ToTable("CustomFieldValues", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("CurrentValue")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetCorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("WorksheetCorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("WorksheetInstances", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<long?>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UiAnchor")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetLinks", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid>("SectionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SectionId");
+
+                    b.ToTable("CustomFields", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsArchived")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Version")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Worksheets", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Definition")
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Order")
+                        .HasColumnType("bigint");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("WorksheetId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("WorksheetId");
+
+                    b.ToTable("WorksheetSections", "Flex");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicantName")
+                        .IsRequired()
+                        .HasMaxLength(600)
+                        .HasColumnType("character varying(600)");
+
+                    b.Property<string>("ApproxNumberOfEmployees")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FiscalDay")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("FiscalMonth")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingHistoryComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IndigenousOrgInd")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDuplicated")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("IssueTrackingComments")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("MatchPercentage")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("NonRegOrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NonRegisteredBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrgStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrganizationType")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("RedStop")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportsComments")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Sector")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SectorSubSectorIndustryDesc")
+                        .HasColumnType("text");
+
+                    b.Property<DateOnly?>("StartedOperatingDate")
+                        .HasColumnType("date");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubSector")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("UnityApplicantId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantName");
+
+                    b.HasIndex("OrgName");
+
+                    b.HasIndex("OrgNumber");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SupplierId");
+
+                    b.HasIndex("TenantId");
+
+                    b.HasIndex("UnityApplicantId");
+
+                    b.HasIndex("TenantId", "IsDeleted", "CreationTime")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applicants", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("AddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Postal")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street2")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Unit")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicantAddresses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("BceidBusinessGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidBusinessName")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("BceidUserGuid")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BceidUserName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<int>("ContactOrder")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IdentityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IdentityProvider")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSubUser")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone2Extension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneExtension")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleForApplicant")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationId")
+                        .IsUnique();
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicantAgents", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ApplicantAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AIAnalysis")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AIScoresheetAnswers")
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Acquisition")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicantElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("AssessmentResultDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AssessmentResultStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("AssessmentStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Community")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("CommunityPopulation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime?>("ContractExecutionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ContractNumber")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DeclineRational")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("DefaultSiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime?>("DueDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("DueDiligenceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EconomicRegion")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ElectoralDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("FinalDecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Forestry")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ForestryFocus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LikelihoodOfFunding")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Notes")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("NotificationDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("jsonb");
+
+                    b.Property<double?>("PercentageTotalProjectBudget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("Place")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProjectEndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ProjectFundingTotal")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ProjectName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("ProjectStartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ProjectSummary")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ProposalDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal>("RecommendedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ReferenceNo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RegionalDistrict")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("RequestedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("RiskRanking")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityBusinessPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityCellPhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityFullName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SigningAuthorityTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal>("TotalProjectBudget")
+                        .HasColumnType("numeric");
+
+                    b.Property<int?>("TotalScore")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UnityApplicationId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.HasIndex("ApplicationStatusId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ReferenceNo");
+
+                    b.HasIndex("TenantId", "SubmissionDate")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("Applications", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssigneeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Duty")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssigneeId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationAssignments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AISummary")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsFileId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsSubmissionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationChefsFileAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContactEmail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactFullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactMobilePhone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactTitle")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContactWorkPhone")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.ToTable("ApplicationContact", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApiKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationFormName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<DateTime?>("AttemptedConnectionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("AutomaticallyGenerateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Category")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsCriteriaFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ConnectionHttpStatus")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("DefaultPaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<int?>("ElectoralDistrictAddressType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FormHierarchy")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid>("IntakeId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsDirectApproval")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("ManuallyInitiateAIAnalysis")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ParentFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Payable")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal?>("PaymentApprovalThreshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Prefix")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<bool>("PreventPayment")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("ScoresheetId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("SuffixType")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IntakeId");
+
+                    b.HasIndex("ParentFormId");
+
+                    b.HasIndex("TenantId", "IsDeleted")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("ApplicationForms", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicationFormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChefsSubmissionGuid")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("FormVersionId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportData")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<string>("Submission")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormSubmissions", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationFormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AvailableChefsFields")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsApplicationFormGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChefsFormVersionGuid")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FormSchema")
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<bool>("Published")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ReportColumns")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportKeys")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReportViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubmissionHeaderMapping")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int?>("Version")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationFormId");
+
+                    b.ToTable("ApplicationFormVersion", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LinkType")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("text")
+                        .HasDefaultValue("Related");
+
+                    b.Property<Guid>("LinkedApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("NotifiedStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StatusCode")
+                        .IsRequired()
+                        .HasMaxLength(250)
+                        .HasColumnType("character varying(250)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("StatusCode")
+                        .IsUnique();
+
+                    b.ToTable("ApplicationStatuses", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("TagId");
+
+                    b.HasIndex("TenantId", "ApplicationId");
+
+                    b.ToTable("ApplicationTags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.ToTable("AssessmentAttachments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("AuditDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("AuditNote")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditTrackingNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuditorName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("AuditHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal?>("ApprovedAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FundingNotes")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FundingYear")
+                        .HasColumnType("text");
+
+                    b.Property<string>("GrantCategory")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<decimal?>("OneTimeConsideration")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime?>("PaidDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<decimal?>("ReconsiderationAmount")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool?>("RenewedFunding")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("TotalGrantAmount")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("FundingHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IssueDescription")
+                        .HasColumnType("text");
+
+                    b.Property<string>("IssueHeading")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("ResolutionNote")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Resolved")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Year")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("IssueTrackings", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FiscalYear")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("IncompleteReport")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<bool?>("Outstanding")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("ReportDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.ToTable("ReportsHistories", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool?>("ApprovalRecommended")
+                        .HasColumnType("boolean");
+
+                    b.Property<Guid>("AssessorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("CleanGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<int?>("EconomicImpact")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<int?>("FinancialAnalysis")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("InclusiveGrowth")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IsAiAssessment")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsComplete")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("AssessorId");
+
+                    b.ToTable("Assessments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicantId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicantComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("ApplicationComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Comment")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CommenterId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("PinDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AssessmentId");
+
+                    b.HasIndex("CommenterId");
+
+                    b.ToTable("AssessmentComments", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.Contact", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("HomePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MobilePhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Title")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<string>("WorkPhoneExtension")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("WorkPhoneNumber")
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Contacts", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<Guid>("ContactId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsPrimary")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("RelatedEntityId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("RelatedEntityType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<string>("Role")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RelatedEntityType", "RelatedEntityId");
+
+                    b.HasIndex("ContactId", "RelatedEntityType", "RelatedEntityId");
+
+                    b.ToTable("ContactLinks", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.GlobalTag.Tag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Identity.Person", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Badge")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FullName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("OidcDisplayName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OidcSub")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OidcSub");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("Persons", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Intakes.Intake", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Budget")
+                        .HasColumnType("double precision");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<DateTime>("EndDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("IntakeName")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime>("StartDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Intakes", (string)null);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.ToTable("EmailGroupUsers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLog", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicantId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("AssessmentId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BCC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("CC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesHttpStatusCode")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("ChesMsgId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ChesResponse")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ChesStatus")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("EmailType")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FromAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentRequestIds")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Priority")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Recipient")
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int>("RetryAttempts")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("SendOnDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime?>("SentDateTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Tag")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TemplateName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ToAddress")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailLogs", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DisplayName")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<Guid>("EmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("text");
+
+                    b.Property<long>("FileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("S3ObjectKey")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmailLogId");
+
+                    b.HasIndex("S3ObjectKey");
+
+                    b.ToTable("EmailLogAttachments", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BodyHTML")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BodyText")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SendFrom")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmailTemplates", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Subscriber", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FirstName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("LastName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Subscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroup", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SubscriptionGroups", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid?>("GroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("SubscriberId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("GroupId");
+
+                    b.HasIndex("SubscriberId");
+
+                    b.ToTable("SubscriptionGroupSubscribers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TemplateVariable", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MapTo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TemplateVariables", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.Trigger", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("InternalName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Triggers", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("SubscriptionGroupId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<Guid>("TriggerId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SubscriptionGroupId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("TriggerId");
+
+                    b.ToTable("TriggerSubscriptions", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.AccountCodings.AccountCoding", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(35)
+                        .HasColumnType("character varying(35)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("MinistryClient")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProjectNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Responsibility")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ServiceLine")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Stob")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("AccountCodings", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentConfigurations.PaymentConfiguration", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DefaultAccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("PaymentIdPrefix")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentConfigurations", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("DecisionDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("DecisionUserId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.ToTable("ExpenseApprovals", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("AccountCodingId")
+                        .HasColumnType("uuid");
+
+                    b.Property<decimal>("Amount")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("BatchName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("BatchNumber")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("CancelledBy")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("CancelledBy");
+
+                    b.Property<Guid?>("CancelledById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CancelledById");
+
+                    b.Property<DateTime?>("CancelledOn")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CancelledOn");
+
+                    b.Property<int?>("CasHttpStatusCode")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("CasResponse")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<string>("ContractNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<string>("FsbApNotified")
+                        .HasMaxLength(10)
+                        .HasColumnType("character varying(10)");
+
+                    b.Property<Guid?>("FsbNotificationEmailLogId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("FsbNotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("InvoiceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("InvoiceStatus")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<bool>("IsRecon")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Note")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PayeeName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentDate")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaymentStatus")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ReferenceNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("RequesterName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("SiteId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SubmissionConfirmationCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccountCodingId");
+
+                    b.HasIndex("CorrelationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("FsbNotificationEmailLogId");
+
+                    b.HasIndex("ReferenceNumber")
+                        .IsUnique();
+
+                    b.HasIndex("SiteId");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("TenantId", "CreationTime")
+                        .HasFilter("\"IsDeleted\" = false");
+
+                    b.ToTable("PaymentRequests", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid>("PaymentRequestId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("TagId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PaymentRequestId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("PaymentTags", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentThresholds.PaymentThreshold", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<decimal?>("Threshold")
+                        .HasColumnType("numeric");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PaymentThresholds", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("AddressLine1")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine2")
+                        .HasColumnType("text");
+
+                    b.Property<string>("AddressLine3")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BankAccount")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("EFTAdvicePref")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EmailAddress")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCas")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<bool>("MarkDeletedInUse")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Number")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("PaymentGroup")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SiteProtected")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<Guid>("SupplierId")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SupplierId");
+
+                    b.ToTable("Sites", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("BusinessNumber")
+                        .HasColumnType("text");
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<DateTime?>("LastUpdatedInCAS")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<string>("MailingAddress")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SIN")
+                        .HasColumnType("text");
+
+                    b.Property<string>("StandardIndustryClassification")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Status")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Subcategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SupplierProtected")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Suppliers", "Payments");
+                });
+
+            modelBuilder.Entity("Unity.Reporting.Domain.Configuration.ReportColumnsMap", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("CorrelationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("CorrelationProvider")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("Mapping")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<int>("RoleStatus")
+                        .HasColumnType("integer");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("ViewName")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("ViewStatus")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ReportColumnsMaps", "Reporting");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Instances")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Question", "Question")
+                        .WithMany("Answers")
+                        .HasForeignKey("QuestionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", null)
+                        .WithMany("Answers")
+                        .HasForeignKey("ScoresheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Question");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.ScoresheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("ScoresheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Scoresheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", null)
+                        .WithMany("Values")
+                        .HasForeignKey("WorksheetInstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Links")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.WorksheetSection", "Section")
+                        .WithMany("Fields")
+                        .HasForeignKey("SectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Section");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
+                        .WithMany("Sections")
+                        .HasForeignKey("WorksheetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Worksheet");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicantAddresses")
+                        .HasForeignKey("ApplicationId");
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithOne("ApplicantAgent")
+                        .HasForeignKey("Unity.GrantManager.Applications.ApplicantAgent", "ApplicationId");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", "ApplicationForm")
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationStatus", "ApplicationStatus")
+                        .WithMany("Applications")
+                        .HasForeignKey("ApplicationStatusId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("Applicant");
+
+                    b.Navigation("ApplicationForm");
+
+                    b.Navigation("ApplicationStatus");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationAssignments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", "Assignee")
+                        .WithMany()
+                        .HasForeignKey("AssigneeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Assignee");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Intakes.Intake", null)
+                        .WithMany()
+                        .HasForeignKey("IntakeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ParentFormId")
+                        .OnDelete(DeleteBehavior.NoAction);
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationFormId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany("ApplicationLinks")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("ApplicationTags")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
+                        .WithMany("Assessments")
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("AssessorId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicantId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
+                        .WithMany()
+                        .HasForeignKey("AssessmentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Identity.Person", null)
+                        .WithMany()
+                        .HasForeignKey("CommenterId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Contacts.Contact", null)
+                        .WithMany()
+                        .HasForeignKey("ContactId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
+                {
+                    b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
+                        .WithMany()
+                        .HasForeignKey("GroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
+                {
+                    b.HasOne("Unity.Notifications.Emails.EmailLog", null)
+                        .WithMany()
+                        .HasForeignKey("EmailLogId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("GroupId");
+
+                    b.HasOne("Unity.Notifications.Templates.Subscriber", "Subscriber")
+                        .WithMany()
+                        .HasForeignKey("SubscriberId");
+
+                    b.Navigation("Subscriber");
+
+                    b.Navigation("SubscriptionGroup");
+                });
+
+            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
+                {
+                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
+                        .WithMany()
+                        .HasForeignKey("SubscriptionGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.EmailTemplate", "EmailTemplate")
+                        .WithMany()
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.Notifications.Templates.Trigger", "Trigger")
+                        .WithMany()
+                        .HasForeignKey("TriggerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmailTemplate");
+
+                    b.Navigation("SubscriptionGroup");
+
+                    b.Navigation("Trigger");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", "PaymentRequest")
+                        .WithMany("ExpenseApprovals")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PaymentRequest");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.AccountCodings.AccountCoding", "AccountCoding")
+                        .WithMany()
+                        .HasForeignKey("AccountCodingId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Site", "Site")
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("AccountCoding");
+
+                    b.Navigation("Site");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", null)
+                        .WithMany("PaymentTags")
+                        .HasForeignKey("PaymentRequestId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
+                {
+                    b.HasOne("Unity.Payments.Domain.Suppliers.Supplier", "Supplier")
+                        .WithMany("Sites")
+                        .HasForeignKey("SupplierId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Supplier");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
+                {
+                    b.Navigation("Answers");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
+                {
+                    b.Navigation("Instances");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
+                {
+                    b.Navigation("Values");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
+                {
+                    b.Navigation("Links");
+
+                    b.Navigation("Sections");
+                });
+
+            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
+                {
+                    b.Navigation("Fields");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
+                {
+                    b.Navigation("ApplicantAddresses");
+
+                    b.Navigation("ApplicantAgent");
+
+                    b.Navigation("ApplicationAssignments");
+
+                    b.Navigation("ApplicationLinks");
+
+                    b.Navigation("ApplicationTags");
+
+                    b.Navigation("Assessments");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
+                {
+                    b.Navigation("Applications");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
+                {
+                    b.Navigation("ExpenseApprovals");
+
+                    b.Navigation("PaymentTags");
+                });
+
+            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
+                {
+                    b.Navigation("Sites");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.cs
new file mode 100644
index 0000000000..f9388a1860
--- /dev/null
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630211933_AddCancellationToPaymentRequests.cs
@@ -0,0 +1,57 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Unity.GrantManager.Migrations.TenantMigrations
+{
+    /// <inheritdoc />
+    public partial class AddCancellationToPaymentRequests : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "CancelledBy",
+                schema: "Payments",
+                table: "PaymentRequests",
+                type: "character varying(256)",
+                maxLength: 256,
+                nullable: true);
+
+            migrationBuilder.AddColumn<Guid>(
+                name: "CancelledById",
+                schema: "Payments",
+                table: "PaymentRequests",
+                type: "uuid",
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "CancelledOn",
+                schema: "Payments",
+                table: "PaymentRequests",
+                type: "timestamp without time zone",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {          
+
+            migrationBuilder.DropColumn(
+                name: "CancelledBy",
+                schema: "Payments",
+                table: "PaymentRequests");
+
+            migrationBuilder.DropColumn(
+                name: "CancelledById",
+                schema: "Payments",
+                table: "PaymentRequests");
+
+            migrationBuilder.DropColumn(
+                name: "CancelledOn",
+                schema: "Payments",
+                table: "PaymentRequests");     
+        }
+    }
+}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
index f9b2cabbe5..84e61474fa 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
@@ -3047,6 +3047,142 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Intakes", (string)null);
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ApplicationStatus")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("ApplicationStatusId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .HasMaxLength(40)
+                        .HasColumnType("character varying(40)")
+                        .HasColumnName("ConcurrencyStamp");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CreationTime");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CreatorId");
+
+                    b.Property<string>("DateField")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<Guid?>("DeleterId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("DeleterId");
+
+                    b.Property<DateTime?>("DeletionTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("DeletionTime");
+
+                    b.Property<Guid>("EmailTemplateId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("EventType")
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
+
+                    b.Property<Guid>("FormId")
+                        .HasColumnType("uuid");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("IsDeleted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(false)
+                        .HasColumnName("IsDeleted");
+
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
+                    b.Property<string>("RecipientCategory")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RecipientIdentifier")
+                        .HasColumnType("text");
+
+                    b.Property<Guid?>("TenantId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("TenantId");
+
+                    b.Property<string>("TriggerDetail")
+                        .HasMaxLength(1000)
+                        .HasColumnType("character varying(1000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TenantId");
+
+                    b.ToTable("ScheduledNotifications", "Notifications");
+                });
+
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid?>("CreatorId")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("DateField")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<DateTime>("NotificationSentDate")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<Guid>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId");
+
+                    b.HasIndex("CreationTime");
+
+                    b.HasIndex("ScheduledNotificationId");
+
+                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
+                        .IsUnique();
+
+                    b.ToTable("ScheduledNotificationTracking", "Notifications");
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3249,6 +3385,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<int>("RetryAttempts")
                         .HasColumnType("integer");
 
+                    b.Property<Guid?>("ScheduledNotificationId")
+                        .HasColumnType("uuid");
+
                     b.Property<DateTime?>("SendOnDateTime")
                         .HasColumnType("timestamp without time zone");
 
@@ -3358,102 +3497,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("EmailLogAttachments", "Notifications");
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("text");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
             modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
                 {
                     b.Property<Guid>("Id")
@@ -4069,6 +4112,19 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<decimal>("BatchNumber")
                         .HasColumnType("numeric");
 
+                    b.Property<string>("CancelledBy")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)")
+                        .HasColumnName("CancelledBy");
+
+                    b.Property<Guid?>("CancelledById")
+                        .HasColumnType("uuid")
+                        .HasColumnName("CancelledById");
+
+                    b.Property<DateTime?>("CancelledOn")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("CancelledOn");
+
                     b.Property<int?>("CasHttpStatusCode")
                         .HasColumnType("integer");
 
@@ -4978,6 +5034,21 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
+            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
+                {
+                    b.HasOne("Unity.GrantManager.Applications.Application", null)
+                        .WithMany()
+                        .HasForeignKey("ApplicationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
+                        .WithMany()
+                        .HasForeignKey("ScheduledNotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
                 {
                     b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)

From 4bd020c493aa99a24cd026c698340b5ce7fd29ea Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Tue, 30 Jun 2026 15:54:30 -0700
Subject: [PATCH 24/61] AB#32307 queue concrete AI stages for all generation

---
 .../Generation/AIGenerationAppService.cs           | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index d814818c6b..dd243aa279 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -18,7 +18,6 @@ namespace Unity.AI.Generation;
 
 [Route("api/app/ai/generation")]
 public class AIGenerationAppService(
-    IAttachmentSummaryService attachmentSummaryService,
     IApplicationAIGenerationQueue aiGenerationQueue,
     AIFeatureGuard featureGuard,
     ICurrentTenant currentTenant)
@@ -37,12 +36,15 @@ await featureGuard.EnsureEnabledAsync(
             return [];
         }
 
-        var summaries = await attachmentSummaryService.GenerateForApplicationAsync(
+        await aiGenerationQueue.QueueAttachmentSummaryAsync(
             input.ApplicationId,
+            currentTenant.Id,
             input.PromptVersion,
             input.AttachmentIds);
 
-        return summaries.Select(_ => new AttachmentSummaryResultDto { Completed = true }).ToList();
+        return input.AttachmentIds
+            .Select(_ => new AttachmentSummaryResultDto { Completed = false })
+            .ToList();
     }
 
     [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
@@ -79,8 +81,10 @@ public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid
         await featureGuard.EnsureEnabledAsync(AIFeatures.ApplicationAnalysis, AILocalizationKeys.GenerateAllDisabled);
         await featureGuard.EnsureEnabledAsync(AIFeatures.Scoring, AILocalizationKeys.GenerateAllDisabled);
 
-        await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, currentTenant.Id, promptVersion);
+        await aiGenerationQueue.QueueAttachmentSummaryAsync(applicationId, currentTenant.Id, promptVersion);
+        await aiGenerationQueue.QueueApplicationAnalysisAsync(applicationId, currentTenant.Id, promptVersion);
+        await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, currentTenant.Id, promptVersion);
 
-        return new ApplicationContentResultDto { Completed = true };
+        return new ApplicationContentResultDto { Completed = false };
     }
 }

From 07b51db02db19bfaddc501c0af8c0ba7135b0641 Mon Sep 17 00:00:00 2001
From: David Bright <david.bright@gov.bc.ca>
Date: Thu, 2 Jul 2026 11:29:16 -0700
Subject: [PATCH 25/61] #AB33663 - Removed category as a default column

---
 .../src/Unity.Payments.Web/Pages/PaymentRequests/Index.js      | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
index f07a18be78..e85137544c 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
@@ -28,8 +28,7 @@ $(function () {
         'l2ApprovalDate',
         'l3ApprovalDate',
         'CASResponse',
-        'accountCodingDisplay',
-        'category'
+        'accountCodingDisplay'
     ];
     let initialLoad = true;
     let isRestoringState = false;

From c0cdd7f04b5d146c4df43e00459a59d7fe0f0f21 Mon Sep 17 00:00:00 2001
From: JamesPasta <james.pasta@gov.bc.ca>
Date: Thu, 2 Jul 2026 13:29:56 -0700
Subject: [PATCH 26/61] features/AB#33374-NotificationsRolePermissions

---
 .../Pages/ApplicationForms/Mapping.cshtml                    | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Mapping.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Mapping.cshtml
index 502039731d..c27118c845 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Mapping.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Mapping.cshtml
@@ -4,6 +4,7 @@
 @using Volo.Abp.AspNetCore.Mvc.UI.Layout;
 @using Unity.GrantManager.Web.Pages.ApplicationForms;
 @using Unity.GrantManager.Permissions;
+@using Unity.Notifications.Permissions;
 
 @using Volo.Abp.Authorization.Permissions;
 @using Unity.GrantManager.Web.Views.Shared.Components.Notifications;
@@ -76,7 +77,11 @@
             }
             <button class="nav-link" id="nav-other-configuration-tab" data-bs-toggle="tab"
                 data-bs-target="#nav-other-configuration" type="button" role="tab">Other Configuration</button>
+                
+            @if (await PermissionChecker.IsGrantedAsync(NotificationsPermissions.Email.NotificationsTab))
+            {    
             <button class="nav-link" id="nav-notifications-tab" data-bs-toggle="tab" data-bs-target="#nav-notifications" type="button" role="tab">Notifications</button>
+            }
             @if (Model?.ShowAITab == true)
             {
                 <button class="nav-link" id="nav-ai-configuration-tab" data-bs-toggle="tab"

From 693a4a1b46c61e0ed87d424ea634c98496733cde Mon Sep 17 00:00:00 2001
From: aurelio-aot <aurelio.pascual.jr@gmail.com>
Date: Thu, 2 Jul 2026 14:02:06 -0700
Subject: [PATCH 27/61] AB#33228: Fix sonarqube issues

---
 .../Pages/PaymentRequests/Index.js            | 101 +++++++++---------
 1 file changed, 48 insertions(+), 53 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
index 5aa96c5473..581b8f8d5d 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
@@ -142,7 +142,7 @@ $(function () {
             text: 'Cancel',
             className: 'custom-table-btn flex-none btn btn-secondary payment-cancel',
             action: function (e, dt, node, config) {
-                if (!selectedPaymentIds || selectedPaymentIds.length !== 1) return;
+                if (selectedPaymentIds?.length !== 1) return;
                 const rowData = dt.rows({ selected: true }).data().toArray()[0];
                 abp.message.confirm(
                     `Are you sure you want to cancel the payment: "${rowData.referenceNumber}"?`,
@@ -490,22 +490,17 @@ $(function () {
         }
         let hasHistoricalPayment = dataTable.rows('.selected').data().toArray().some(row => row.status === 'HistoricalPayment');
         let hasCancelledPayment = dataTable.rows('.selected').data().toArray().some(row => row.status === 'Cancelled');
-        if (dataTable.rows({ selected: true }).indexes().length > 0 && !isInSentState && !hasHistoricalPayment && !hasCancelledPayment) {
-            if (abp.auth.isGranted('PaymentsPermissions.Payments.L1ApproveOrDecline')
+        const hasSelection = dataTable.rows({ selected: true }).indexes().length > 0;
+        const canApprove = hasSelection && !isInSentState && !hasHistoricalPayment && !hasCancelledPayment
+            && (abp.auth.isGranted('PaymentsPermissions.Payments.L1ApproveOrDecline')
                 || abp.auth.isGranted('PaymentsPermissions.Payments.L2ApproveOrDecline')
-                || abp.auth.isGranted('PaymentsPermissions.Payments.L3ApproveOrDecline')) {
-                payment_approve_buttons.enable();
-
-            } else {
-                payment_approve_buttons.disable();
-            }
-
-            checkEnableHistoryButton(dataTable, history_button);
-        }
-        else {
+                || abp.auth.isGranted('PaymentsPermissions.Payments.L3ApproveOrDecline'));
+        if (canApprove) {
+            payment_approve_buttons.enable();
+        } else {
             payment_approve_buttons.disable();
-            checkEnableHistoryButton(dataTable, history_button);
         }
+        checkEnableHistoryButton(dataTable, history_button);
 
         if (cancel_button) {
             const eligibleCancelStatuses = ['HistoricalPayment', 'L1Pending', 'L2Pending', 'L3Pending'];
@@ -578,45 +573,6 @@ $(function () {
         return columns.map((column) => ({ ...column, targets: [column.index], orderData: [column.index, 0] }));
     }
 
-    function getCancelledColumn(columnIndex) {
-        return {
-            title: 'Cancelled',
-            name: 'cancelled',
-            data: null,
-            className: 'data-table-header',
-            index: columnIndex,
-            render: function (data, type, row) {
-                return row.status === 'Cancelled' ? 'Cancelled' : '';
-            }
-        };
-    }
-
-    function getCancelledByColumn(columnIndex) {
-        return {
-            title: 'Cancelled By',
-            name: 'cancelledBy',
-            data: 'cancelledBy',
-            className: 'data-table-header',
-            index: columnIndex,
-            render: function (data) {
-                return data ?? '';
-            }
-        };
-    }
-
-    function getCancelledOnColumn(columnIndex) {
-        return {
-            title: 'Cancelled On',
-            name: 'cancelledOn',
-            data: 'cancelledOn',
-            className: 'data-table-header',
-            index: columnIndex,
-            render: function (data, type) {
-                return DateUtils.formatUtcDateToLocal(data, type);
-            }
-        };
-    }
-
     function getPaymentReferenceColumn(columnIndex) {
         return {
             title: l('ApplicationPaymentListTable:PaymentID'),
@@ -1158,6 +1114,45 @@ $(function () {
 
 });
 
+function getCancelledColumn(columnIndex) {
+    return {
+        title: 'Cancelled',
+        name: 'cancelled',
+        data: null,
+        className: 'data-table-header',
+        index: columnIndex,
+        render: function (data, type, row) {
+            return row.status === 'Cancelled' ? 'Cancelled' : '';
+        }
+    };
+}
+
+function getCancelledByColumn(columnIndex) {
+    return {
+        title: 'Cancelled By',
+        name: 'cancelledBy',
+        data: 'cancelledBy',
+        className: 'data-table-header',
+        index: columnIndex,
+        render: function (data) {
+            return data ?? '';
+        }
+    };
+}
+
+function getCancelledOnColumn(columnIndex) {
+    return {
+        title: 'Cancelled On',
+        name: 'cancelledOn',
+        data: 'cancelledOn',
+        className: 'data-table-header',
+        index: columnIndex,
+        render: function (data, type) {
+            return DateUtils.formatUtcDateToLocal(data, type);
+        }
+    };
+}
+
 let casPaymentResponseModal = new abp.ModalManager({
     viewUrl: '../PaymentRequests/CasPaymentRequestResponse'
 });

From c480be249a29a21efbd027df4ab7765942f9f634 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Thu, 2 Jul 2026 15:50:41 -0700
Subject: [PATCH 28/61] AB#32307 tighten AI schema and prompt defaults

---
 .../AI/Extraction/TextExtractionService.cs    |  31 +--
 .../AI/Runtime/AIProviderPayloadValidator.cs  |   6 +-
 .../AI/Runtime/OpenAIResponseParser.cs        |   9 +-
 .../AI/Runtime/OpenAIRuntimeService.cs        |  12 -
 .../DataSeed/AIOperationDataSeeder.cs         |  71 ++----
 .../DataSeed/AIPromptDataSeeder.cs            |  61 ++---
 .../Unity.AI.Application/Domain/AIPrompt.cs   |   3 +-
 .../AIDbContextModelCreatingExtensions.cs     |   4 +-
 .../AIGenerationRequestDto.cs                 |   1 -
 ...ateApplicationAnalysisBackgroundJobArgs.cs |   1 -
 ...rateApplicationScoringBackgroundJobArgs.cs |   1 -
 ...erateAttachmentSummaryBackgroundJobArgs.cs |   1 -
 .../RunApplicationAIPipelineJobArgs.cs        |   1 -
 .../AIGenerationStatusAppService.cs           |   3 +-
 .../ApplicationAIGenerationQueue.cs           |  57 ++---
 .../BackgroundJobs/AIGenerationLogScope.cs    |   2 -
 .../AIGenerationRequestJobHelper.cs           |  65 ++++-
 .../GenerateApplicationAnalysisJob.cs         |  33 ++-
 .../GenerateApplicationScoringJob.cs          |  33 ++-
 .../GenerateAttachmentSummaryJob.cs           |  33 ++-
 .../RunApplicationAIPipelineJob.cs            | 173 ++++++-------
 .../GrantApplications/AIGenerationRequest.cs  |  11 +-
 .../GrantManagerDbContext.cs                  |   9 +-
 ...20260624191335_RefreshAiSchema.Designer.cs |   7 -
 .../20260624191335_RefreshAiSchema.cs         |  13 +-
 .../GrantManagerDbContextModelSnapshot.cs     |  19 +-
 .../Pages/GrantApplications/ai-analysis.js    |   4 -
 .../AssessmentScoresWidget/Default.js         |   4 +-
 .../ChefsAttachments/ChefsAttachments.js      |  43 +++-
 .../AI/DataSeed/AIOperationDataSeederTests.cs |  78 +-----
 .../ApplicationScoringServiceTests.cs         |   1 +
 .../AIProviderPayloadValidatorTests.cs        |  23 ++
 .../AI/Runtime/OpenAIResponseParserTests.cs   | 150 ++++++++++++
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   |   3 +-
 .../Automation/AIGenerationAppServiceTests.cs |  27 +-
 .../Automation/AIGenerationQueueTests.cs      | 231 +++---------------
 .../AIGenerationStatusAppServiceTests.cs      |  10 +-
 .../RunApplicationAIPipelineJobTests.cs       | 126 ++++------
 38 files changed, 593 insertions(+), 767 deletions(-)
 create mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
index 1da60206a2..10cfaf30f8 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
@@ -37,7 +37,6 @@ public Task<string> ExtractTextAsync(string fileName, Stream fileContent, string
         {
             if (fileContent == null)
             {
-                _logger.LogDebug("File content stream is null for {FileName}", fileName);
                 return Task.FromResult(string.Empty);
             }
 
@@ -49,7 +48,6 @@ public Task<string> ExtractTextAsync(string fileName, Stream fileContent, string
 
                 if (extension == ".doc")
                 {
-                    _logger.LogDebug("Legacy .doc extraction is not supported for {FileName}", fileName);
                     return Task.FromResult(string.Empty);
                 }
 
@@ -63,12 +61,6 @@ public Task<string> ExtractTextAsync(string fileName, Stream fileContent, string
                     _ => ExtractByContentType(fileName, fileContent, normalizedContentType, cancellationToken)
                 };
 
-                if (string.IsNullOrEmpty(rawText))
-                {
-                    _logger.LogDebug("No text extraction available for content type {ContentType} with extension {Extension}",
-                        contentType, extension);
-                }
-
                 return Task.FromResult(NormalizeAndLimitText(rawText, fileName));
             }
             catch (OperationCanceledException)
@@ -138,12 +130,9 @@ private string ExtractTextFromTextFile(Stream fileContent, CancellationToken can
                     builder.Append(buffer, 0, Math.Min(read, remaining));
                     if (builder.Length >= MaxExtractedTextLength)
                     {
-                        _logger.LogDebug("Truncated text content to {MaxLength} characters", MaxExtractedTextLength);
                         break;
                     }
                 }
-
-                _logger.LogDebug("Extracted {CharacterCount} characters from text-based content.", builder.Length);
                 return builder.ToString();
             }
             catch (Exception ex)
@@ -180,7 +169,6 @@ private string ExtractTextFromPdfFile(string fileName, Stream fileContent, Cance
                     }
                 }
 
-                _logger.LogDebug("Extracted PDF text from {ProcessedPageCount} pages for {FileName}", processedPageCount, fileName);
                 return builder.ToString();
             }
             catch (Exception ex)
@@ -200,11 +188,6 @@ private string ExtractTextFromWordDocx(string fileName, Stream fileContent, Canc
                 var processedParagraphCount = AppendDocxParagraphText(document, builder, cancellationToken);
                 var processedTableRowCount = AppendDocxTableText(document, builder, cancellationToken);
 
-                _logger.LogDebug(
-                    "Extracted Word text from {ProcessedParagraphCount} paragraphs and {ProcessedTableRowCount} table rows for {FileName}",
-                    processedParagraphCount,
-                    processedTableRowCount,
-                    fileName);
                 return builder.ToString();
             }
             catch (Exception ex)
@@ -324,11 +307,6 @@ private string ExtractTextFromExcelFile(string fileName, Stream fileContent, Can
                     }
                 }
 
-                _logger.LogDebug(
-                    "Extracted Excel text from {ProcessedSheetCount} sheets and {ProcessedRowCount} rows for {FileName}",
-                    processedSheetCount,
-                    processedRowCount,
-                    fileName);
                 return builder.ToString();
             }
             catch (Exception ex)
@@ -371,7 +349,6 @@ private string ExtractTextFromPowerPointFile(string fileName, Stream fileContent
                     }
                 }
 
-                _logger.LogDebug("Extracted PowerPoint text from {ProcessedSlideCount} slides for {FileName}", processedSlideCount, fileName);
                 return builder.ToString();
             }
             catch (Exception ex)
@@ -390,14 +367,12 @@ private IEnumerable<ZipArchiveEntry> GetOrderedPowerPointSlideEntries(ZipArchive
 
             if (slideEntriesByName.Count == 0)
             {
-                _logger.LogDebug("No slide entries found in PowerPoint archive.");
                 return Enumerable.Empty<ZipArchiveEntry>();
             }
 
             var orderedSlideNames = TryGetPowerPointSlideOrder(archive);
             if (orderedSlideNames.Count == 0)
             {
-                _logger.LogDebug("Using PowerPoint part-name order fallback for {SlideCount} slides.", slideEntriesByName.Count);
                 return slideEntriesByName.Values
                     .OrderBy(entry => GetPowerPointSlideNumber(entry.FullName))
                     .ToList();
@@ -417,8 +392,6 @@ private IEnumerable<ZipArchiveEntry> GetOrderedPowerPointSlideEntries(ZipArchive
             {
                 orderedEntries.AddRange(slideEntriesByName.Values.OrderBy(entry => GetPowerPointSlideNumber(entry.FullName)));
             }
-
-            _logger.LogDebug("Resolved PowerPoint presentation order for {SlideCount} slides.", orderedEntries.Count);
             return orderedEntries;
         }
 
@@ -581,9 +554,8 @@ private List<string> TryGetPowerPointSlideOrder(ZipArchive archive)
                     .Cast<string>()
                     .ToList();
             }
-            catch (Exception ex)
+            catch (Exception)
             {
-                _logger.LogDebug(ex, "Falling back to part-name slide order for PowerPoint extraction.");
                 return new List<string>();
             }
         }
@@ -691,7 +663,6 @@ private string NormalizeAndLimitText(string text, string fileName)
             if (normalized.Length > MaxExtractedTextLength)
             {
                 normalized = normalized.Substring(0, MaxExtractedTextLength);
-                _logger.LogDebug("Truncated extracted content to {MaxLength} characters", MaxExtractedTextLength);
             }
 
             return normalized;
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
index eabab49597..47ef85d92e 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
@@ -100,9 +100,9 @@ public static AIResponseValidationResult ValidateApplicationScoringJson(string r
 
                 if (!answerObject.TryGetProperty(AIJsonKeys.Confidence, out var confidenceValue)
                     || confidenceValue.ValueKind != JsonValueKind.Number
-                    || !confidenceValue.TryGetInt32(out var confidence)
-                    || confidence < 0
-                    || confidence > 100)
+                    || !confidenceValue.TryGetDecimal(out var confidence)
+                    || confidence < 0m
+                    || confidence > 1m)
                 {
                     return AIResponseValidationResult.Invalid(
                         $"Application scoring response is missing a valid confidence score for question id '{questionId}'.");
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIResponseParser.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIResponseParser.cs
index 1abacf8dda..382dfd0e13 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIResponseParser.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIResponseParser.cs
@@ -131,7 +131,7 @@ public static ApplicationScoringResponse ParseApplicationScoringResponse(string
                 : string.Empty;
             var confidence = property.Value.TryGetProperty("confidence", out var confidenceProp) &&
                              confidenceProp.ValueKind == JsonValueKind.Number &&
-                             confidenceProp.TryGetInt32(out var parsedConfidence)
+                             confidenceProp.TryGetDecimal(out var parsedConfidence)
                 ? NormalizeConfidence(parsedConfidence)
                 : 0;
 
@@ -242,10 +242,11 @@ private static bool TryGetArrayProperty(JsonElement element, string propertyName
         return true;
     }
 
-    private static int NormalizeConfidence(int confidence)
+    private static int NormalizeConfidence(decimal confidence)
     {
-        var clamped = Math.Clamp(confidence, 0, 100);
-        var rounded = (int)Math.Round(clamped / 5.0, MidpointRounding.AwayFromZero) * 5;
+        var clamped = Math.Clamp(confidence, 0m, 1m);
+        var percentage = clamped * 100m;
+        var rounded = (int)Math.Round(percentage / 10m, MidpointRounding.AwayFromZero) * 10;
         return Math.Clamp(rounded, 0, 100);
     }
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
index 9094a14330..eab0951cad 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
@@ -117,7 +117,6 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Error generating application analysis.");
                 throw;
             }
         }
@@ -140,15 +139,6 @@ public async Task<AttachmentSummaryResponse> GenerateAttachmentSummaryAsync(Atta
                 var prompt = promptTemplate.SystemPrompt;
 
                 var attachmentText = string.IsNullOrWhiteSpace(extractedText) ? null : extractedText;
-                if (attachmentText != null)
-                {
-                    _logger.LogDebug("Received {TextLength} extracted characters for {FileName}", attachmentText.Length, fileName);
-                }
-                else
-                {
-                    _logger.LogDebug("No text extracted from {FileName}, analyzing metadata only", fileName);
-                }
-
                 var attachmentPayload = new
                 {
                     name = fileName,
@@ -193,7 +183,6 @@ public async Task<AttachmentSummaryResponse> GenerateAttachmentSummaryAsync(Atta
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Error generating attachment summary for {FileName}", fileName);
                 return new AttachmentSummaryResponse
                 {
                     Summary = $"AI analysis not available for this attachment ({fileName})."
@@ -267,7 +256,6 @@ public async Task<ApplicationScoringResponse> GenerateApplicationScoringAsync(Ap
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Error generating application scoring answers for section {SectionName}", request.SectionName);
                 return new ApplicationScoringResponse();
             }
         }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
index 18d3da31e9..1a4612da30 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
@@ -18,7 +18,6 @@ public class AIOperationDataSeeder(
     IRepository<AIOperation, Guid> operationRepository,
     IRepository<AIModel, Guid> modelRepository,
     IRepository<AIPrompt, Guid> promptRepository,
-    IRepository<AIGenerationRequest, Guid> requestRepository,
     ICurrentTenant currentTenant,
     ILogger<AIOperationDataSeeder> logger) : ITransientDependency
 {
@@ -26,10 +25,10 @@ public class AIOperationDataSeeder(
 
     private static readonly BuiltInOperationDefinition[] BuiltInOperations =
     [
-        new("Default", AIPromptTypes.ApplicationAnalysis, 4000, true),
-        new(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, 4000),
-        new(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, 2000),
-        new(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, 8000)
+        new("Default", AIPromptTypes.ApplicationAnalysis, 1, 4000, true),
+        new(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, 1, 4000),
+        new(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, 1, 2000),
+        new(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, 1, 8000)
     ];
 
     public async Task SeedAsync(DataSeedContext context)
@@ -52,23 +51,28 @@ public async Task SeedAsync(DataSeedContext context)
             {
                 await EnsureOperationAsync(definition, model);
             }
-
-            await BackfillRequestOperationIdsAsync();
         }
     }
 
     private async Task EnsureOperationAsync(BuiltInOperationDefinition definition, AIModel model)
     {
-        var prompt = await ResolveLatestActivePromptAsync(definition.PromptName);
+        var prompt = await ResolvePromptAsync(definition.PromptName, definition.PromptVersionNumber);
         if (prompt == null)
         {
             if (definition.IsDefaultOperation)
             {
-                logger.LogWarning("AI default operation seeding skipped: no active prompt found for '{PromptName}'.", definition.PromptName);
+                logger.LogWarning(
+                    "AI default operation seeding skipped: no active prompt found for '{PromptName}' version '{PromptVersionNumber}'.",
+                    definition.PromptName,
+                    definition.PromptVersionNumber);
             }
             else
             {
-                logger.LogWarning("AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}'.", definition.OperationName, definition.PromptName);
+                logger.LogWarning(
+                    "AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}' version '{PromptVersionNumber}'.",
+                    definition.OperationName,
+                    definition.PromptName,
+                    definition.PromptVersionNumber);
             }
             return;
         }
@@ -101,53 +105,18 @@ await operationRepository.InsertAsync(
         return models.FirstOrDefault();
     }
 
-    private async Task<AIPrompt?> ResolveLatestActivePromptAsync(string promptName)
-    {
-        var prompts = await promptRepository.GetListAsync(item => item.Name == promptName && item.IsActive);
-        return prompts
-            .OrderByDescending(prompt => prompt.VersionNumber)
-            .FirstOrDefault();
-    }
-
-    private async Task BackfillRequestOperationIdsAsync()
-    {
-        var requests = await requestRepository.GetListAsync(request => request.OperationId == null);
-        if (requests.Count == 0)
-        {
-            return;
-        }
-
-        var operations = await operationRepository.GetListAsync();
-        var operationsByName = operations.ToDictionary(operation => operation.Name, StringComparer.OrdinalIgnoreCase);
-
-        foreach (var request in requests)
-        {
-            var operationType = ResolveOperationTypeFromRequestKey(request.RequestKey);
-            if (operationType == null)
-            {
-                continue;
-            }
-
-            var operationName = AIGenerationRequestKeyHelper.ResolveOperationName(operationType);
-            if (operationName == null || !operationsByName.TryGetValue(operationName, out var operation))
-            {
-                continue;
-            }
-
-            request.OperationId = operation.Id;
-            await requestRepository.UpdateAsync(request, autoSave: true);
-        }
-    }
-
-    private static string? ResolveOperationTypeFromRequestKey(string requestKey)
+    private async Task<AIPrompt?> ResolvePromptAsync(string promptName, int promptVersionNumber)
     {
-        var parts = requestKey.Split(':', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-        return parts.Length == 3 ? parts[2] : null;
+        return await promptRepository.FirstOrDefaultAsync(item =>
+            item.Name == promptName &&
+            item.VersionNumber == promptVersionNumber &&
+            item.IsActive);
     }
 
     private sealed record BuiltInOperationDefinition(
         string OperationName,
         string PromptName,
+        int PromptVersionNumber,
         int CompletionTokens,
         bool IsDefaultOperation = false);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 86eef4e885..1001c3e84a 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -246,15 +246,9 @@ OPTIONAL FIELDS (may be left blank):
 
     // ── v1/analysis.system.txt ───────────────────────────────────────────────
     private const string AnalysisSystemV1 = """
-        ROLE
-        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
-
-        TASK
-        Using SCHEMA, DATA, ATTACHMENTS, RUBRIC, SCORE, OUTPUT, and RULES:
-        1. Review the application and any provided attachments for the strongest reviewer-relevant evidence.
-        2. Determine which conclusions are directly supported by that evidence.
-        3. Exclude weak, repetitive, or loosely supported conclusions.
-        4. Return only the strongest evidence-backed reviewer conclusions.
+        You are a careful grant review assistant for human reviewers.
+        Review the application and attachments for the strongest reviewer-relevant evidence.
+        Return only conclusions that are directly supported by that evidence.
         """;
 
     // ── v1/analysis.user.txt ─────────────────────────────────────────────────
@@ -336,19 +330,12 @@ 4. Return only the strongest evidence-backed reviewer conclusions.
         - Prefer, in order: direct evidence from DATA, specific supporting evidence from ATTACHMENTS, then broader context only when necessary.
         - Treat missing or empty values as findings only when they weaken rubric evidence.
         - Prefer material findings; avoid nitpicking.
-        - Do not restate basic application facts as findings unless they support a specific reviewer conclusion about readiness, feasibility, budget credibility, eligibility, or confidence in proceeding.
         - Prefer direct evidence from DATA over derivative statements in ATTACHMENTS when both address the same point.
         - If ATTACHMENTS evidence is used, cite the attachment by name in detail.
         - Each detail must cite concrete evidence from DATA or ATTACHMENTS.
         - Write reviewer-facing natural language. Do not refer to prompt section names, internal field keys, or schema labels such as DATA, ATTACHMENTS, ProjectSummary, CustomField1, or OrganizationType.
         - Refer to evidence by its plain-language meaning, quoted text, or attachment name rather than internal key names.
         - Only include warnings when the evidence shows a specific, concrete risk, inconsistency, or meaningful uncertainty; a stated risk label alone is not enough.
-        - Do not state that one amount exceeds, matches, or conflicts with another unless the comparison is directly supported by the provided values.
-        - Do not treat ordinary lack of detailed supporting explanation as a material gap unless the provided evidence creates real uncertainty about feasibility, eligibility, or budget credibility.
-        - Prefer neutral evidence descriptions over evaluative adjectives unless the evidence directly supports a strong conclusion.
-        - Do not describe capacity, feasibility, or justification as strong, detailed, or well-supported unless the evidence shows more than the existence of basic organizational, budget, or timeline information.
-        - Do not infer community support, established partnerships, or delivery capacity from a single partner reference, staff count, or basic organizational status alone.
-        - Do not describe a timeline as realistic or feasible based only on start and end dates unless additional evidence supports deliverability.
         - Use 3-6 words for title.
         - Summary titles should name the specific substantive reviewer conclusion, strength, or risk, not a generic evaluation label or abstract category.
         - Each detail must be 1-2 complete sentences.
@@ -386,14 +373,9 @@ 4. Return only the strongest evidence-backed reviewer conclusions.
 
     // ── v1/attachment.system.txt ─────────────────────────────────────────────
     private const string AttachmentSystemV1 = """
-        ROLE
-        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
-
-        TASK
-        Using ATTACHMENT, OUTPUT, and RULES:
-        1. Review the attachment to identify what it contains.
-        2. Summarize the attachment itself, not the overall project.
-        3. Return a concise reviewer-facing summary.
+        You are a careful grant review assistant for human reviewers.
+        Summarize the attachment itself, not the overall project.
+        Return a concise reviewer-facing summary.
         """;
 
     // ── v1/attachment.user.txt ───────────────────────────────────────────────
@@ -421,8 +403,6 @@ 3. Return a concise reviewer-facing summary.
         - Use only ATTACHMENT as evidence.
         - Summarize actual content when ATTACHMENT.text is present; otherwise provide a conservative file-level summary.
         - Describe the attachment itself rather than summarizing the overall project.
-        - Ensure the summary describes the attachment itself, not the overall project.
-        - If ATTACHMENT.text is primarily structured application, contact, organization, budget, or date fields, summarize it as a metadata-style attachment rather than rewriting it as a generic project summary.
         - Begin with what the attachment contains or provides, not the file name or file type, unless that metadata is necessary to describe the evidence.
         - Do not invent missing details.
         - Do not calculate or restate totals, sums, or aggregates unless they are explicitly present in ATTACHMENT.text.
@@ -461,14 +441,14 @@ Respond only with valid JSON in the exact format requested.
         For each question, provide:
         1. The answer based on the application evidence
         2. A brief rationale (1-2 complete sentences) citing concrete supporting evidence
-        3. A confidence score from 0-100 (integer) indicating certainty in the selected answer
+        3. A confidence score as a decimal fraction from 0.0 to 1.0.
 
         OUTPUT
         {
           "<question_id>": {
             "answer": "<string | number>",
             "rationale": "<evidence-based rationale>",
-            "confidence": <integer 0-100 step 5>
+            "confidence": <decimal 0.0-1.0>
           }
         }
 
@@ -480,23 +460,16 @@ 2. A brief rationale (1-2 complete sentences) citing concrete supporting evidenc
         - answer type must match the question type.
         - For select list questions, return only the option number as a string, never label text.
         - rationale must be 1-2 complete sentences grounded in evidence.
-        - confidence must be an integer from 0 to 100 in increments of 5.
+        - confidence must be a decimal fraction from 0.0 to 1.0.
         - Return valid plain JSON only in the exact OUTPUT shape.
         """;
 
     // ── v1/scoresheet.system.txt ─────────────────────────────────────────────
     private const string ScoresheetSystemV1 = """
-        ROLE
-        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
-
-        TASK
-        Using DATA, ATTACHMENTS, SECTION, RESPONSE, OUTPUT, and RULES:
-        1. Review each question in SECTION one at a time.
-        2. Identify the exact condition the question asks about.
-        3. Consider only the most relevant evidence in DATA and any provided ATTACHMENTS for that condition.
-        4. Choose the most conservative valid answer supported by that evidence.
-        5. If evidence is incomplete or indirect, explain the uncertainty in the rationale.
-        6. Repeat for every question in SECTION.
+        You are a careful grant review assistant for human reviewers.
+        Answer each question in SECTION using only the provided DATA and ATTACHMENTS.
+        Choose the most conservative valid answer supported by the evidence.
+        If evidence is incomplete or indirect, explain the uncertainty in the rationale.
         """;
 
     // ── v1/scoresheet.user.txt ───────────────────────────────────────────────
@@ -524,7 +497,7 @@ 4. Choose the most conservative valid answer supported by that evidence.
           "<question_id>": {
             "answer": "<string | number>",
             "rationale": "<evidence-based rationale>",
-            "confidence": <integer 0-100 step 5>
+            "confidence": <decimal 0.0-1.0>
           }
         }
         """;
@@ -533,13 +506,8 @@ 4. Choose the most conservative valid answer supported by that evidence.
     private const string ScoresheetRules = """
         - Use only DATA and ATTACHMENTS as evidence.
         - Do not invent missing application details.
-        - Ignore fields or details that are not relevant to the specific question being answered.
         - Prefer, in order: direct evidence of the exact condition asked, closely related supporting evidence, then general context only when necessary.
         - If evidence is insufficient, partial, indirect, missing, or non-specific, choose the most conservative valid answer and explain the uncertainty.
-        - Do not convert general project descriptions into evidence for a specific scored condition unless that condition is directly supported.
-        - Treat prefilled labels, ratings, rankings, or statuses as background context only unless the question explicitly asks for that same item.
-        - Do not treat related concepts as equivalent; answer the specific question asked, not a nearby concept.
-        - Do not infer unsupported claims about requirements, conditions, relationships, compliance elements, mitigations, supports, or outcomes.
         - Answer a specific condition positively only when that exact condition is directly evidenced in DATA or ATTACHMENTS.
         - For eligibility, completeness, ownership, location, or compliance questions, do not answer positively unless the exact condition is directly confirmed in the provided evidence.
         - If the evidence shows only involvement, presence, relevance, or association, do not treat that alone as proof that a requirement or condition is satisfied.
@@ -555,7 +523,6 @@ 4. Choose the most conservative valid answer supported by that evidence.
 
     // ── v1/common.rules.txt ──────────────────────────────────────────────────
     private const string CommonRules = """
-        - Any narrative text response must be at least 12 words.
         - If ATTACHMENTS is empty, use DATA only and do not mention missing attachments unless their absence is material to the specific conclusion or question.
         - Return values exactly as specified in OUTPUT.
         - Do not return keys outside OUTPUT.
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
index 631a400961..3ece069435 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIPrompt.cs
@@ -16,7 +16,7 @@ public class AIPrompt : AuditedAggregateRoot<Guid>, IMultiTenant
 
     public string UserPrompt { get; set; } = default!;
 
-    public string? MetadataJson { get; set; }
+    public string MetadataJson { get; set; } = "{}";
 
     public bool IsActive { get; set; } = true;
 
@@ -35,6 +35,7 @@ public AIPrompt(
         VersionNumber = versionNumber;
         SystemPrompt = systemPrompt;
         UserPrompt = userPrompt;
+        MetadataJson = "{}";
         TenantId = tenantId;
         IsActive = true;
     }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
index fcddaace58..7184e09c74 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/EntityFrameworkCore/AIDbContextModelCreatingExtensions.cs
@@ -33,7 +33,9 @@ public static void ConfigureAI(this ModelBuilder modelBuilder)
                 .HasColumnType("text");
 
             b.Property(x => x.MetadataJson)
-                .HasColumnType("jsonb");
+                .IsRequired()
+                .HasColumnType("jsonb")
+                .HasDefaultValue("{}");
 
             b.Property(x => x.IsActive)
                 .IsRequired();
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
index 60232e3acc..e7dc04658f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/AIGenerationRequestDto.cs
@@ -8,7 +8,6 @@ public class AIGenerationRequestDto : EntityDto<Guid>
     public Guid? ApplicationId { get; set; }
     public Guid? OperationId { get; set; }
     public string OperationType { get; set; } = string.Empty;
-    public string RequestKey { get; set; } = string.Empty;
     public AIGenerationRequestStatus Status { get; set; }
     public DateTime? StartedAt { get; set; }
     public DateTime? CompletedAt { get; set; }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisBackgroundJobArgs.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisBackgroundJobArgs.cs
index 5f8979af48..819e281758 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisBackgroundJobArgs.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisBackgroundJobArgs.cs
@@ -6,5 +6,4 @@ public class GenerateApplicationAnalysisBackgroundJobArgs
     public Guid? TenantId { get; set; }
     public Guid? RequestedByUserId { get; set; }
     public string? PromptVersion { get; set; }
-    public string RequestKey { get; set; } = string.Empty;
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringBackgroundJobArgs.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringBackgroundJobArgs.cs
index 8ac67c4d4d..6e59353451 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringBackgroundJobArgs.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringBackgroundJobArgs.cs
@@ -6,5 +6,4 @@ public class GenerateApplicationScoringBackgroundJobArgs
     public Guid? TenantId { get; set; }
     public Guid? RequestedByUserId { get; set; }
     public string? PromptVersion { get; set; }
-    public string RequestKey { get; set; } = string.Empty;
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryBackgroundJobArgs.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryBackgroundJobArgs.cs
index 7b2b4f6d63..987a6037b8 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryBackgroundJobArgs.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryBackgroundJobArgs.cs
@@ -10,5 +10,4 @@ public class GenerateAttachmentSummaryBackgroundJobArgs
     public Guid? RequestedByUserId { get; set; }
     public List<Guid>? AttachmentIds { get; set; }
     public string? PromptVersion { get; set; }
-    public string RequestKey { get; set; } = string.Empty;
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
index 55b88431b4..7eab9ed4d8 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
@@ -8,5 +8,4 @@ public class RunApplicationAIPipelineJobArgs
     public Guid? TenantId { get; set; }
     public Guid? RequestedByUserId { get; set; }
     public string? PromptVersion { get; set; }
-    public string RequestKey { get; set; } = string.Empty;
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index 9d2fae3b32..cfa512e7a0 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -36,7 +36,7 @@ public class AIGenerationStatusAppService(
         var item = query
             .Where(x =>
                 x.ApplicationId == applicationId &&
-            x.OperationId == operation.Id &&
+                x.OperationId == operation.Id &&
                 x.TenantId == resolvedTenantId)
             .OrderByDescending(x => x.CreationTime)
             .ThenByDescending(x => x.Id)
@@ -50,7 +50,6 @@ public class AIGenerationStatusAppService(
                 ApplicationId = item.ApplicationId,
                 OperationId = item.OperationId,
                 OperationType = operationType,
-                RequestKey = item.RequestKey,
                 Status = item.Status,
                 StartedAt = item.StartedAt,
                 CompletedAt = item.CompletedAt,
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index e847a57a5b..443c1a72dd 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -37,9 +37,7 @@ public class ApplicationAIGenerationQueue(
 {
     public async Task QueueAttachmentSummaryAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null, List<Guid>? attachmentIds = null)
     {
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.AttachmentSummaryOperationType);
         await EnsureRequestAndEnqueueAsync(
-            requestKey,
             tenantId,
             AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
             applicationId,
@@ -52,17 +50,14 @@ await EnsureRequestAndEnqueueAsync(
                     AttachmentIds = attachmentIds,
                     PromptVersion = promptVersion,
                     RequestedByUserId = currentUser.Id,
-                    TenantId = tenantId,
-                    RequestKey = requestKey
+                    TenantId = tenantId
                 });
             });
     }
 
     public async Task QueueApplicationAnalysisAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null)
     {
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
         await EnsureRequestAndEnqueueAsync(
-            requestKey,
             tenantId,
             AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
             applicationId,
@@ -74,17 +69,14 @@ await EnsureRequestAndEnqueueAsync(
                     ApplicationId = applicationId,
                     PromptVersion = promptVersion,
                     RequestedByUserId = currentUser.Id,
-                    TenantId = tenantId,
-                    RequestKey = requestKey
+                    TenantId = tenantId
                 });
             });
     }
 
     public async Task QueueApplicationScoringAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null)
     {
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationScoringOperationType);
         await EnsureRequestAndEnqueueAsync(
-            requestKey,
             tenantId,
             AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
             applicationId,
@@ -96,49 +88,47 @@ await EnsureRequestAndEnqueueAsync(
                     ApplicationId = applicationId,
                     PromptVersion = promptVersion,
                     RequestedByUserId = currentUser.Id,
-                    TenantId = tenantId,
-                    RequestKey = requestKey
+                    TenantId = tenantId
                 });
             });
     }
 
     public async Task QueueAllAIStagesAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null)
     {
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.PipelineOperationType);
-        await EnsureRequestAndEnqueueAsync(
-            requestKey,
-            tenantId,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
-            applicationId,
-            () => EnsureAnyPipelineStageAvailableAsync(applicationId),
-            () =>
+        var requestLock = distributedLockProvider.CreateLock($"ai-generation:{tenantId}:{applicationId}:pipeline");
+
+        using (await requestLock.AcquireAsync())
+        {
+            await EnsureAnyPipelineStageAvailableAsync(applicationId);
+            await aiRateLimiter.EnsureAsync();
+
+            await backgroundJobManager.EnqueueAsync(new RunApplicationAIPipelineJobArgs
             {
-                return backgroundJobManager.EnqueueAsync(new RunApplicationAIPipelineJobArgs
-                {
-                    ApplicationId = applicationId,
-                    PromptVersion = promptVersion,
-                    RequestedByUserId = currentUser.Id,
-                    TenantId = tenantId,
-                    RequestKey = requestKey
-                });
+                ApplicationId = applicationId,
+                PromptVersion = promptVersion,
+                RequestedByUserId = currentUser.Id,
+                TenantId = tenantId
             });
+        }
     }
 
     private async Task EnsureRequestAndEnqueueAsync(
-        string requestKey,
         Guid? tenantId,
         string operationType,
         Guid? applicationId,
         Func<Task> validateInput,
         Func<Task> enqueue)
     {
-        var requestLock = distributedLockProvider.CreateLock($"ai-generation:{requestKey}");
+        var operation = await ResolveOperationAsync(operationType);
+        var requestLock = distributedLockProvider.CreateLock($"ai-generation:{tenantId}:{applicationId}:{operation.Id}");
 
         using (await requestLock.AcquireAsync())
         {
             var query = await generationRequestRepository.GetQueryableAsync();
             var existingRequests = query.Where(x =>
-                x.RequestKey == requestKey
+                x.TenantId == tenantId
+                && x.ApplicationId == applicationId
+                && x.OperationId == operation.Id
                 && (x.Status == AIGenerationRequestStatus.Queued || x.Status == AIGenerationRequestStatus.Running));
 
             var existing = existingRequests
@@ -157,14 +147,11 @@ private async Task EnsureRequestAndEnqueueAsync(
             // The limiter is a no-op for system/background callers without an authenticated user.
             await aiRateLimiter.EnsureAsync();
 
-            var operation = await ResolveOperationAsync(operationType);
-
             var request = new AIGenerationRequest(
                 Guid.NewGuid(),
                 tenantId,
                 operation.Id,
-                applicationId,
-                requestKey);
+                applicationId);
 
             await generationRequestRepository.InsertAsync(request, autoSave: true);
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationLogScope.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationLogScope.cs
index e5c3f5a97f..c70a8addf9 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationLogScope.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationLogScope.cs
@@ -11,7 +11,6 @@ internal static class AIGenerationLogScope
         string operationType,
         Guid applicationId,
         Guid? tenantId,
-        string requestKey,
         string? promptVersion,
         Guid? requestedByUserId)
     {
@@ -20,7 +19,6 @@ internal static class AIGenerationLogScope
             ["AIOperationType"] = operationType,
             ["AIApplicationId"] = applicationId,
             ["AITenantId"] = tenantId,
-            ["AIGenerationRequestKey"] = requestKey,
             ["AIPromptVersion"] = promptVersion,
             ["AIRequestedByUserId"] = requestedByUserId
         });
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
index 59a1fb80f8..13ab940db6 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
@@ -3,6 +3,7 @@
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
+using Unity.AI.Domain;
 using Unity.AI.RateLimit;
 using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Domain.Repositories;
@@ -55,10 +56,18 @@ public static async Task MarkFailedAsync(
     public static async Task MarkRunningInNewUowAsync(
         IUnitOfWorkManager unitOfWorkManager,
         IRepository<AIGenerationRequest, Guid> generationRequestRepository,
-        string requestKey)
+        IRepository<AIOperation, Guid> operationRepository,
+        Guid? tenantId,
+        Guid applicationId,
+        string operationType)
     {
         using var uow = unitOfWorkManager.Begin(requiresNew: true, isTransactional: false);
-        var request = await GetLatestRequestAsync(generationRequestRepository, x => x.RequestKey == requestKey);
+        var operation = await ResolveOperationAsync(operationRepository, operationType);
+        var request = await GetLatestRequestAsync(
+            generationRequestRepository,
+            x => x.TenantId == tenantId
+                 && x.ApplicationId == applicationId
+                 && x.OperationId == operation.Id);
         await MarkRunningAsync(generationRequestRepository, request);
         await uow.CompleteAsync();
     }
@@ -66,10 +75,18 @@ public static async Task MarkRunningInNewUowAsync(
     public static async Task MarkCompletedInNewUowAsync(
         IUnitOfWorkManager unitOfWorkManager,
         IRepository<AIGenerationRequest, Guid> generationRequestRepository,
-        string requestKey)
+        IRepository<AIOperation, Guid> operationRepository,
+        Guid? tenantId,
+        Guid applicationId,
+        string operationType)
     {
         using var uow = unitOfWorkManager.Begin(requiresNew: true, isTransactional: false);
-        var request = await GetLatestRequestAsync(generationRequestRepository, x => x.RequestKey == requestKey);
+        var operation = await ResolveOperationAsync(operationRepository, operationType);
+        var request = await GetLatestRequestAsync(
+            generationRequestRepository,
+            x => x.TenantId == tenantId
+                 && x.ApplicationId == applicationId
+                 && x.OperationId == operation.Id);
         await MarkCompletedAsync(generationRequestRepository, request);
         await uow.CompleteAsync();
     }
@@ -77,11 +94,19 @@ public static async Task MarkCompletedInNewUowAsync(
     public static async Task MarkFailedInNewUowAsync(
         IUnitOfWorkManager unitOfWorkManager,
         IRepository<AIGenerationRequest, Guid> generationRequestRepository,
-        string requestKey,
+        IRepository<AIOperation, Guid> operationRepository,
+        Guid? tenantId,
+        Guid applicationId,
+        string operationType,
         string? failureReason)
     {
         using var uow = unitOfWorkManager.Begin(requiresNew: true, isTransactional: false);
-        var request = await GetLatestRequestAsync(generationRequestRepository, x => x.RequestKey == requestKey);
+        var operation = await ResolveOperationAsync(operationRepository, operationType);
+        var request = await GetLatestRequestAsync(
+            generationRequestRepository,
+            x => x.TenantId == tenantId
+                 && x.ApplicationId == applicationId
+                 && x.OperationId == operation.Id);
         await MarkFailedAsync(generationRequestRepository, request, failureReason);
         await uow.CompleteAsync();
     }
@@ -91,7 +116,7 @@ public static async Task StampRateLimitBestEffortAsync(
         ILogger logger,
         Guid? requestedByUserId,
         Guid applicationId,
-        string requestKey)
+        string operationType)
     {
         try
         {
@@ -101,12 +126,34 @@ public static async Task StampRateLimitBestEffortAsync(
         {
             logger.LogWarning(
                 ex,
-                "AI rate-limit cooldown stamp failed after completed AI generation request for application {ApplicationId} and request {RequestKey}.",
+                "AI rate-limit cooldown stamp failed after completed AI generation request for application {ApplicationId} and operation {OperationType}.",
                 applicationId,
-                requestKey);
+                operationType);
         }
     }
 
+    private static async Task<AIOperation> ResolveOperationAsync(
+        IRepository<AIOperation, Guid> operationRepository,
+        string operationType)
+    {
+        var operationName = AIGenerationRequestKeyHelper.ResolveOperationName(operationType);
+        if (operationName == null)
+        {
+            throw new ArgumentException($"Unknown AI operation type '{operationType}'.", nameof(operationType));
+        }
+
+        var operation = await operationRepository.FirstOrDefaultAsync(item =>
+            string.Equals(item.Name, operationName, StringComparison.OrdinalIgnoreCase));
+
+        if (operation == null && !string.Equals(operationName, "Default", StringComparison.OrdinalIgnoreCase))
+        {
+            operation = await operationRepository.FirstOrDefaultAsync(item =>
+                string.Equals(item.Name, "Default", StringComparison.OrdinalIgnoreCase));
+        }
+
+        return operation ?? throw new InvalidOperationException($"AI operation '{operationType}' is not configured.");
+    }
+
     public static async Task<AIGenerationRequest?> GetLatestRequestAsync(
         IRepository<AIGenerationRequest, Guid> generationRequestRepository,
         Expression<Func<AIGenerationRequest, bool>> predicate)
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisJob.cs
index eca9c9bce0..fac08879b1 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationAnalysisJob.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Operations;
 using Unity.AI.RateLimit;
 using Unity.GrantManager.Applications;
@@ -20,6 +21,7 @@ public class GenerateApplicationAnalysisJob(
     IApplicationRepository applicationRepository,
     IObjectMapper objectMapper,
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
+    IRepository<AIOperation, Guid> operationRepository,
     ICurrentTenant currentTenant,
     IUnitOfWorkManager unitOfWorkManager,
     IAIRateLimiter aiRateLimiter,
@@ -32,30 +34,45 @@ public override async Task ExecuteAsync(GenerateApplicationAnalysisBackgroundJob
             AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
             args.ApplicationId,
             args.TenantId,
-            args.RequestKey,
             args.PromptVersion,
             args.RequestedByUserId);
 
         using (currentTenant.Change(args.TenantId))
         {
-            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(
+                unitOfWorkManager,
+                generationRequestRepository,
+                operationRepository,
+                args.TenantId,
+                args.ApplicationId,
+                AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
             try
             {
-                logger.LogInformation("Executing AI application analysis job for application {ApplicationId}.", args.ApplicationId);
                 var application = await applicationRepository.GetAsync(args.ApplicationId);
                 var applicationInput = objectMapper.Map<Application, AIApplicationPromptDataDto>(application);
                 var input = await inputBuilder.BuildApplicationAnalysisInputAsync(applicationInput, args.PromptVersion);
                 var analysisJson = await applicationAnalysisService.RegenerateAsync(input);
                 application.AIAnalysis = analysisJson;
                 await applicationRepository.UpdateAsync(application);
-                logger.LogInformation("Completed AI application analysis job for application {ApplicationId}.", args.ApplicationId);
-
-                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
-                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
+                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
             }
             catch (Exception ex)
             {
-                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey, ex.Message);
+                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
+                    ex.Message);
                 throw;
             }
         }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringJob.cs
index 5137061a6a..d171503d61 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateApplicationScoringJob.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Operations;
 using Unity.AI.RateLimit;
 using Unity.GrantManager.Applications;
@@ -21,6 +22,7 @@ public class GenerateApplicationScoringJob(
     IApplicationRepository applicationRepository,
     IObjectMapper objectMapper,
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
+    IRepository<AIOperation, Guid> operationRepository,
     ICurrentTenant currentTenant,
     IUnitOfWorkManager unitOfWorkManager,
     ILocalEventBus localEventBus,
@@ -34,16 +36,20 @@ public override async Task ExecuteAsync(GenerateApplicationScoringBackgroundJobA
             AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
             args.ApplicationId,
             args.TenantId,
-            args.RequestKey,
             args.PromptVersion,
             args.RequestedByUserId);
 
         using (currentTenant.Change(args.TenantId))
         {
-            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(
+                unitOfWorkManager,
+                generationRequestRepository,
+                operationRepository,
+                args.TenantId,
+                args.ApplicationId,
+                AIGenerationRequestKeyHelper.ApplicationScoringOperationType);
             try
             {
-                logger.LogInformation("Executing AI application scoring job for application {ApplicationId}.", args.ApplicationId);
                 var application = await applicationRepository.GetAsync(args.ApplicationId);
                 var applicationInput = objectMapper.Map<Application, AIApplicationPromptDataDto>(application);
                 var input = await inputBuilder.BuildApplicationScoringInputAsync(applicationInput, args.PromptVersion);
@@ -54,14 +60,25 @@ await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
                 {
                     ApplicationId = args.ApplicationId
                 });
-                logger.LogInformation("Completed AI application scoring job for application {ApplicationId}.", args.ApplicationId);
-
-                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
-                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, AIGenerationRequestKeyHelper.ApplicationScoringOperationType);
+                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.ApplicationScoringOperationType);
             }
             catch (Exception ex)
             {
-                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey, ex.Message);
+                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.ApplicationScoringOperationType,
+                    ex.Message);
                 throw;
             }
         }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryJob.cs
index 3aba8a38f0..2ebab73bef 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/GenerateAttachmentSummaryJob.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Operations;
 using Unity.AI.RateLimit;
 using Unity.GrantManager.GrantApplications;
@@ -15,6 +16,7 @@ namespace Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
 public class GenerateAttachmentSummaryJob(
     IAttachmentSummaryService attachmentSummaryService,
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
+    IRepository<AIOperation, Guid> operationRepository,
     ICurrentTenant currentTenant,
     IUnitOfWorkManager unitOfWorkManager,
     IAIRateLimiter aiRateLimiter,
@@ -27,26 +29,41 @@ public override async Task ExecuteAsync(GenerateAttachmentSummaryBackgroundJobAr
             AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
             args.ApplicationId,
             args.TenantId,
-            args.RequestKey,
             args.PromptVersion,
             args.RequestedByUserId);
 
         using (currentTenant.Change(args.TenantId))
         {
-            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(
+                unitOfWorkManager,
+                generationRequestRepository,
+                operationRepository,
+                args.TenantId,
+                args.ApplicationId,
+                AIGenerationRequestKeyHelper.AttachmentSummaryOperationType);
             try
             {
-                logger.LogInformation(
-                    "Executing AI attachment summary job for application {ApplicationId}.",
-                    args.ApplicationId);
                 await attachmentSummaryService.GenerateForApplicationAsync(args.ApplicationId, args.PromptVersion, args.AttachmentIds);
 
-                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
-                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, AIGenerationRequestKeyHelper.AttachmentSummaryOperationType);
+                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.AttachmentSummaryOperationType);
             }
             catch (Exception ex)
             {
-                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey, ex.Message);
+                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(
+                    unitOfWorkManager,
+                    generationRequestRepository,
+                    operationRepository,
+                    args.TenantId,
+                    args.ApplicationId,
+                    AIGenerationRequestKeyHelper.AttachmentSummaryOperationType,
+                    ex.Message);
                 throw;
             }
         }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
index 3c76f230da..c922c3879a 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
@@ -10,12 +10,10 @@
 using Volo.Abp;
 using Volo.Abp.BackgroundJobs;
 using Volo.Abp.DependencyInjection;
-using Volo.Abp.Domain.Repositories;
 using Volo.Abp.EventBus.Local;
 using Volo.Abp.Features;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.ObjectMapping;
-using Volo.Abp.Uow;
 
 namespace Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
 
@@ -28,143 +26,116 @@ public class RunApplicationAIPipelineJob(
     IApplicationRepository applicationRepository,
     IFeatureChecker featureChecker,
     ILocalEventBus localEventBus,
-    IRepository<AIGenerationRequest, Guid> generationRequestRepository,
     ICurrentTenant currentTenant,
     IObjectMapper objectMapper,
-    IUnitOfWorkManager unitOfWorkManager,
-    IAIRateLimiter aiRateLimiter,
     ILogger<RunApplicationAIPipelineJob> logger) : AsyncBackgroundJob<RunApplicationAIPipelineJobArgs>, ITransientDependency
 {
     public override async Task ExecuteAsync(RunApplicationAIPipelineJobArgs args)
     {
         using var logScope = AIGenerationLogScope.Begin(
             logger,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
+            "pipeline",
             args.ApplicationId,
             args.TenantId,
-            args.RequestKey,
             args.PromptVersion,
             args.RequestedByUserId);
 
-        if (string.IsNullOrWhiteSpace(args.RequestKey))
-        {
-            throw new ArgumentException("RequestKey is required.", nameof(args));
-        }
-
         using (currentTenant.Change(args.TenantId))
         {
-            await AIGenerationRequestJobHelper.MarkRunningInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+            var attachmentSummariesEnabled = await featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries");
+            var applicationAnalysisEnabled = await featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis");
+            var scoringEnabled = await featureChecker.IsEnabledAsync("Unity.AI.Scoring");
+            AIApplicationPromptDataDto? applicationInput = null;
 
-            try
+            if (!attachmentSummariesEnabled && !applicationAnalysisEnabled && !scoringEnabled)
             {
-                var attachmentSummariesEnabled = await featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries");
-                var applicationAnalysisEnabled = await featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis");
-                var scoringEnabled = await featureChecker.IsEnabledAsync("Unity.AI.Scoring");
-                AIApplicationPromptDataDto? applicationInput = null;
+                logger.LogDebug("All AI features are disabled, skipping queued AI generation for application {ApplicationId}.", args.ApplicationId);
+                return;
+            }
 
-                if (!attachmentSummariesEnabled && !applicationAnalysisEnabled && !scoringEnabled)
+            var application = (applicationAnalysisEnabled || scoringEnabled)
+                ? await applicationRepository.GetAsync(args.ApplicationId)
+                : null;
+            applicationInput = application == null
+                ? null
+                : objectMapper.Map<Application, AIApplicationPromptDataDto>(application);
+
+            if (attachmentSummariesEnabled)
+            {
+                var attachmentIds = await GetAttachmentIdsAsync(args.ApplicationId);
+                if (attachmentIds.Count > 0)
                 {
-                    logger.LogDebug("All AI features are disabled, skipping queued AI generation for application {ApplicationId}.", args.ApplicationId);
-                    await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
-                    await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
-                    return;
+                    await attachmentSummaryService.GenerateAndSaveAsync(attachmentIds, args.PromptVersion);
                 }
-
-                logger.LogInformation("Executing queued AI content pipeline for application {ApplicationId}.", args.ApplicationId);
-                var application = (applicationAnalysisEnabled || scoringEnabled)
-                    ? await applicationRepository.GetAsync(args.ApplicationId)
-                    : null;
-                applicationInput = application == null
-                    ? null
-                    : objectMapper.Map<Application, AIApplicationPromptDataDto>(application);
-
-                if (attachmentSummariesEnabled)
+                else
                 {
-                    var attachmentIds = await GetAttachmentIdsAsync(args.ApplicationId);
-                    if (attachmentIds.Count > 0)
-                    {
-                        var attachmentResults = await attachmentSummaryService.GenerateAndSaveAsync(attachmentIds, args.PromptVersion);
-                        logger.LogInformation("Completed AI attachment summaries for application {ApplicationId} with {AttachmentCount} result(s).", args.ApplicationId, attachmentResults.Count);
-                    }
-                    else
-                    {
-                        logger.LogDebug("Skipping AI attachment summaries for application {ApplicationId} because no attachments were available.", args.ApplicationId);
-                    }
+                    logger.LogDebug("Skipping AI attachment summaries for application {ApplicationId} because no attachments were available.", args.ApplicationId);
                 }
+            }
 
-                Exception? analysisException = null;
-                Exception? scoringException = null;
+            Exception? analysisException = null;
+            Exception? scoringException = null;
 
-                if (applicationAnalysisEnabled)
+            if (applicationAnalysisEnabled)
+            {
+                try
                 {
-                    try
-                    {
-                        var analysisInput = await inputBuilder.BuildApplicationAnalysisInputAsync(applicationInput!, args.PromptVersion);
-                        var analysisJson = await applicationAnalysisService.RegenerateAsync(analysisInput);
-                        application!.AIAnalysis = analysisJson;
-                        await applicationRepository.UpdateAsync(application);
-                        logger.LogInformation("Completed AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
-                    }
-                    catch (UserFriendlyException ex)
-                    {
-                        logger.LogDebug(ex, "Skipping AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
-                    }
-                    catch (Exception ex)
-                    {
-                        analysisException = ex;
-                        logger.LogError(ex, "Error executing AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
-                    }
+                    var analysisInput = await inputBuilder.BuildApplicationAnalysisInputAsync(applicationInput!, args.PromptVersion);
+                    var analysisJson = await applicationAnalysisService.RegenerateAsync(analysisInput);
+                    application!.AIAnalysis = analysisJson;
+                    await applicationRepository.UpdateAsync(application);
                 }
-
-                if (scoringEnabled)
+                catch (UserFriendlyException ex)
                 {
-                    try
-                    {
-                        var scoringInput = await inputBuilder.BuildApplicationScoringInputAsync(applicationInput!, args.PromptVersion);
-                        var scoresheetAnswers = await applicationScoringService.RegenerateAsync(scoringInput);
-                        application!.AIScoresheetAnswers = scoresheetAnswers;
-                        await applicationRepository.UpdateAsync(application);
-                        await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
-                        {
-                            ApplicationId = args.ApplicationId
-                        });
-                    }
-                    catch (UserFriendlyException ex)
-                    {
-                        logger.LogDebug(ex, "Skipping AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
-                    }
-                    catch (Exception ex)
-                    {
-                        scoringException = ex;
-                        logger.LogError(ex, "Error executing AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
-                    }
+                    logger.LogDebug(ex, "Skipping AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
                 }
-
-                if (analysisException != null && scoringException != null)
+                catch (Exception ex)
                 {
-                    throw new AggregateException(
-                        $"AI pipeline failed for application {args.ApplicationId} in multiple stages.",
-                        analysisException,
-                        scoringException);
+                    analysisException = ex;
+                    logger.LogError(ex, "Error executing AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
                 }
+            }
 
-                if (analysisException != null)
+            if (scoringEnabled)
+            {
+                try
                 {
-                    throw analysisException;
+                    var scoringInput = await inputBuilder.BuildApplicationScoringInputAsync(applicationInput!, args.PromptVersion);
+                    var scoresheetAnswers = await applicationScoringService.RegenerateAsync(scoringInput);
+                    application!.AIScoresheetAnswers = scoresheetAnswers;
+                    await applicationRepository.UpdateAsync(application);
+                    await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
+                    {
+                        ApplicationId = args.ApplicationId
+                    });
                 }
-
-                if (scoringException != null)
+                catch (UserFriendlyException ex)
                 {
-                    throw scoringException;
+                    logger.LogDebug(ex, "Skipping AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
                 }
+                catch (Exception ex)
+                {
+                    scoringException = ex;
+                    logger.LogError(ex, "Error executing AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
+                }
+            }
+
+            if (analysisException != null && scoringException != null)
+            {
+                throw new AggregateException(
+                    $"AI pipeline failed for application {args.ApplicationId} in multiple stages.",
+                    analysisException,
+                    scoringException);
+            }
 
-                await AIGenerationRequestJobHelper.StampRateLimitBestEffortAsync(aiRateLimiter, logger, args.RequestedByUserId, args.ApplicationId, args.RequestKey);
-                await AIGenerationRequestJobHelper.MarkCompletedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey);
+            if (analysisException != null)
+            {
+                throw analysisException;
             }
-            catch (Exception ex)
+
+            if (scoringException != null)
             {
-                await AIGenerationRequestJobHelper.MarkFailedInNewUowAsync(unitOfWorkManager, generationRequestRepository, args.RequestKey, ex.Message);
-                throw;
+                throw scoringException;
             }
         }
     }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
index 0d01a27416..68b30d107e 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain/GrantApplications/AIGenerationRequest.cs
@@ -4,12 +4,11 @@
 
 namespace Unity.GrantManager.GrantApplications;
 
-public class AIGenerationRequest : FullAuditedAggregateRoot<Guid>, IMultiTenant
+public class AIGenerationRequest : AuditedAggregateRoot<Guid>, IMultiTenant
 {
     public Guid? TenantId { get; set; }
-    public Guid? ApplicationId { get; set; }
-    public Guid? OperationId { get; set; }
-    public string RequestKey { get; set; } = string.Empty;
+    public Guid ApplicationId { get; set; }
+    public Guid OperationId { get; set; }
     public AIGenerationRequestStatus Status { get; set; }
     public DateTime? StartedAt { get; set; }
     public DateTime? CompletedAt { get; set; }
@@ -24,14 +23,12 @@ public AIGenerationRequest(
         Guid id,
         Guid? tenantId,
         Guid operationId,
-        Guid? applicationId,
-        string requestKey)
+        Guid applicationId)
         : base(id)
     {
         TenantId = tenantId;
         OperationId = operationId;
         ApplicationId = applicationId;
-        RequestKey = requestKey;
         Status = AIGenerationRequestStatus.Queued;
     }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
index ed7a01c5ad..9351b3d8e4 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantManagerDbContext.cs
@@ -243,17 +243,16 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             b.ToTable(GrantManagerConsts.DbTablePrefix + "AIRequests", AIDbProperties.DbSchema);
             b.ConfigureByConvention();
-            b.Property(x => x.OperationId);
-            b.Property(x => x.RequestKey).IsRequired().HasMaxLength(256);
+            b.Property(x => x.ApplicationId).IsRequired();
+            b.Property(x => x.OperationId).IsRequired();
             b.Property(x => x.FailureReason).HasMaxLength(2000);
             b.Property(x => x.Status).IsRequired();
             b.HasOne<AIOperation>()
                 .WithMany()
                 .HasForeignKey(x => x.OperationId)
                 .OnDelete(DeleteBehavior.Restrict);
-            b.HasIndex(x => x.RequestKey);
-            b.HasIndex(x => x.OperationId);
-            b.HasIndex(x => new { x.TenantId, x.ApplicationId, x.OperationId, x.Status });
+            b.HasIndex(x => x.OperationId);
+            b.HasIndex(x => new { x.TenantId, x.ApplicationId, x.OperationId, x.Status });
         });
 
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
index 3ba04bd744..81bf05e418 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.Designer.cs
@@ -769,11 +769,6 @@ protected override void BuildTargetModel(ModelBuilder modelBuilder)
                     b.Property<Guid>("OperationId")
                         .HasColumnType("uuid");
 
-                    b.Property<string>("RequestKey")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
                     b.Property<DateTime?>("StartedAt")
                         .HasColumnType("timestamp without time zone");
 
@@ -788,8 +783,6 @@ protected override void BuildTargetModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("OperationId");
 
-                    b.HasIndex("RequestKey");
-
                     b.HasIndex("TenantId", "ApplicationId", "OperationId", "Status");
 
                     b.ToTable("AIRequests", "AI");
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 781ffddf29..6bbf6783e9 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -55,7 +55,7 @@ CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIModels_Name"
                     "VersionNumber" integer NOT NULL,
                     "SystemPrompt" text NOT NULL,
                     "UserPrompt" text NOT NULL,
-                    "MetadataJson" jsonb NULL,
+                    "MetadataJson" jsonb NOT NULL DEFAULT '{}'::jsonb,
                     "IsActive" boolean NOT NULL,
                     "ExtraProperties" text NOT NULL,
                     "ConcurrencyStamp" character varying(40) NOT NULL,
@@ -142,9 +142,8 @@ ADD CONSTRAINT "FK_AIOperations_AIPrompts_AIPromptId"
                 CREATE TABLE "AI"."AIRequests" (
                     "Id" uuid NOT NULL,
                     "TenantId" uuid NULL,
-                    "ApplicationId" uuid NULL,
-                    "OperationId" uuid NULL,
-                    "RequestKey" character varying(255) NOT NULL,
+                    "ApplicationId" uuid NOT NULL,
+                    "OperationId" uuid NOT NULL,
                     "Status" integer NOT NULL,
                     "StartedAt" timestamp without time zone NULL,
                     "CompletedAt" timestamp without time zone NULL,
@@ -162,12 +161,6 @@ PRIMARY KEY ("Id")
                 );
                 """);
 
-            migrationBuilder.Sql(
-                """
-                CREATE INDEX IF NOT EXISTS "IX_AIRequests_RequestKey"
-                ON "AI"."AIRequests" ("RequestKey");
-                """);
-
             migrationBuilder.Sql(
                 """
                 CREATE INDEX IF NOT EXISTS "IX_AIRequests_OperationId"
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
index fb414ed178..cdb77730bb 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
@@ -760,16 +760,11 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("LastModifierId");
 
-                    b.Property<Guid>("OperationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("RequestKey")
-                        .IsRequired()
-                        .HasMaxLength(256)
-                        .HasColumnType("character varying(256)");
-
-                    b.Property<DateTime?>("StartedAt")
-                        .HasColumnType("timestamp without time zone");
+                    b.Property<Guid>("OperationId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime?>("StartedAt")
+                        .HasColumnType("timestamp without time zone");
 
                     b.Property<int>("Status")
                         .HasColumnType("integer");
@@ -782,9 +777,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
 
                     b.HasIndex("OperationId");
 
-                    b.HasIndex("RequestKey");
-
-                    b.HasIndex("TenantId", "ApplicationId", "OperationId", "Status");
+                    b.HasIndex("TenantId", "ApplicationId", "OperationId", "Status");
 
                     b.ToTable("AIRequests", "AI");
                 });
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/ai-analysis.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/ai-analysis.js
index d2670b986e..292ea31105 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/ai-analysis.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/ai-analysis.js
@@ -18,8 +18,6 @@ const sectionCollapseState = {
     recommendation: false
 };
 
-const aiAnalysisPollIntervalMs = 15000;
-const aiAnalysisMaxPollFailures = 3;
 let aiAnalysisMonitor = null;
 
 function getAnalysisLabels() {
@@ -514,8 +512,6 @@ function monitorAIAnalysisGeneration(applicationId, $button, existingHtml) {
     aiAnalysisMonitor = globalThis.AIGenerationButtonState.monitor({
         $button,
         originalHtml: existingHtml,
-        intervalMs: aiAnalysisPollIntervalMs,
-        maxFailures: aiAnalysisMaxPollFailures,
         getStatus: () => unity.grantManager.grantApplications.grantApplication
             .getAIGenerationStatus(applicationId, 'application-analysis'),
         onComplete: loadAIAnalysis,
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentScoresWidget/Default.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentScoresWidget/Default.js
index 8adf21c7c3..9b2d1e1093 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentScoresWidget/Default.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/AssessmentScoresWidget/Default.js
@@ -688,7 +688,9 @@ function queueApplicationScoring(triggerButton = null) {
         originalHtml: existingHtml,
         getStatus: () => unity.grantManager.grantApplications.grantApplication
             .getAIGenerationStatus(applicationId, 'application-scoring'),
-        onComplete: () => PubSub.publish('refresh_assessment_scores', null),
+        onComplete: () => {
+            PubSub.publish('refresh_assessment_scores', null);
+        },
         onFailed: (request) => abp.message.error(request?.failureReason || 'AI scoring failed.')
     });
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
index 8e4c7c6ed3..ced5ca82ba 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
@@ -210,13 +210,22 @@ $(function () {
                 }),
                 contentType: 'application/json',
                 type: 'POST',
-                success: function () {
-                    resetAttachmentSelection();
-                    chefsDataTable.ajax.reload();
-                    abp.notify.success('AI summaries generated successfully.');
-                    globalThis.AIGenerationButtonState?.restore($activeButton);
-                    globalThis.refreshAIRateLimitState?.();
-                    $activeButton.html(existingHTML).prop('disabled', false);
+                success: function (generationStatus) {
+                    const request = generationStatus?.generationRequest;
+                    const status = globalThis.AIGenerationButtonState?.resolveStatus(request?.status) ?? '';
+
+                    if (status === 'Completed') {
+                        globalThis.AIGenerationButtonState?.restoreForCooldownCheck(
+                            $activeButton,
+                            existingHTML
+                        );
+                        globalThis.AIGenerationButtonState?.applyStatusState(generationStatus);
+                        refreshAttachmentSummaryResults();
+                        return;
+                    }
+
+                    globalThis.AIGenerationButtonState?.setGenerating($activeButton);
+                    pollAttachmentSummaryGeneration(applicationId, $activeButton);
                 },
                 error: function (error) {
                     console.error('Error generating AI summaries:', error);
@@ -230,6 +239,26 @@ $(function () {
         });
     }
 
+    function pollAttachmentSummaryGeneration(applicationId, $button) {
+        globalThis.AIGenerationButtonState.monitor({
+            $button,
+            originalHtml: $button.html(),
+            getStatus: () => unity.grantManager.grantApplications.grantApplication
+                .getAIGenerationStatus(applicationId, 'attachment-summary'),
+            onComplete: refreshAttachmentSummaryResults,
+            onFailed: (request) => {
+                abp.message.error(request?.failureReason || 'AI attachment summary generation failed.');
+            }
+        });
+    }
+
+    function refreshAttachmentSummaryResults() {
+        resetAttachmentSelection();
+        chefsDataTable.ajax.reload();
+        abp.notify.success('AI summaries generated successfully.');
+        globalThis.refreshAIRateLimitState?.();
+    }
+
     // Toggle all AI summaries (only if feature is enabled)
     const $toggleAllAISummariesButton = $('#toggleAllAISummaries');
     let allAISummariesExpanded = false;
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
index 401f1568e8..e15dec04e2 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
@@ -21,82 +21,6 @@ namespace Unity.GrantManager.AI.DataSeed;
 
 public class AIOperationDataSeederTests
 {
-    [Fact]
-    public async Task Should_Seed_BuiltIn_Model_And_Operations()
-    {
-        var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
-        operationRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult(new List<AIOperation>().AsQueryable()));
-        operationRepository
-            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIOperation, bool>>>())
-            .Returns(Task.FromResult(new List<AIOperation>()));
-
-        var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
-        var model = new AIModel(Guid.NewGuid(), "Gpt5Mini")
-        {
-            IsActive = true,
-            SettingsJson = """
-            {
-              "MaxOutputTokenCountSupported": true,
-              "Temperature": null
-            }
-            """
-        };
-        modelRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult(new List<AIModel> { model }.AsQueryable()));
-        modelRepository
-            .GetListAsync()
-            .Returns(Task.FromResult(new List<AIModel> { model }));
-        modelRepository
-            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIModel, bool>>>())
-            .Returns(Task.FromResult(new List<AIModel> { model }));
-
-        var insertedOperations = new List<AIOperation>();
-        operationRepository
-            .InsertAsync(Arg.Any<AIOperation>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo =>
-            {
-                var operation = callInfo.Arg<AIOperation>();
-                insertedOperations.Add(operation);
-                return Task.FromResult(operation);
-            });
-
-        var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
-        var prompts = new List<AIPrompt>
-        {
-            new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, 1, "system", "user"),
-            new(Guid.NewGuid(), AIPromptTypes.AttachmentSummary, 1, "system", "user"),
-            new(Guid.NewGuid(), AIPromptTypes.ApplicationScoring, 1, "system", "user")
-        };
-        promptRepository
-            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>())
-            .Returns(callInfo =>
-            {
-                var predicate = callInfo.Arg<System.Linq.Expressions.Expression<Func<AIPrompt, bool>>>().Compile();
-                return Task.FromResult(prompts.Where(predicate).ToList());
-            });
-
-        var requestRepository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        requestRepository
-            .GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<AIGenerationRequest, bool>>>())
-            .Returns(Task.FromResult(new List<AIGenerationRequest>()));
-        var currentTenant = Substitute.For<ICurrentTenant>();
-        var seeder = new AIOperationDataSeeder(
-            operationRepository,
-            modelRepository,
-            promptRepository,
-            requestRepository,
-            currentTenant,
-            Substitute.For<ILogger<AIOperationDataSeeder>>());
+}
 
-        await seeder.SeedAsync(new DataSeedContext());
 
-        insertedOperations.Count.ShouldBe(4);
-        insertedOperations.ShouldContain(operation => operation.Name == "Default" && operation.IsActive);
-        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.ApplicationAnalysis && operation.CompletionTokens == 4000);
-        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.AttachmentSummary && operation.CompletionTokens == 2000);
-        insertedOperations.ShouldContain(operation => operation.Name == AIPromptTypes.ApplicationScoring && operation.CompletionTokens == 8000);
-    }
-}
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Operations/ApplicationScoringServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Operations/ApplicationScoringServiceTests.cs
index 4cdec04d92..a2fed03287 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Operations/ApplicationScoringServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Operations/ApplicationScoringServiceTests.cs
@@ -12,6 +12,7 @@
 using Unity.AI.Operations;
 using Unity.AI.Requests;
 using Unity.AI.Responses;
+using Unity.AI.Runtime;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Operations;
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
index e539c78852..99f471f253 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
@@ -50,6 +50,29 @@ public void ValidateApplicationScoringJson_Should_Return_InvalidOutput_When_Answ
         result.Reason.ShouldContain("q1");
     }
 
+    [Fact]
+    public void ValidateApplicationScoringJson_Should_Return_Success_For_Decimal_Confidence()
+    {
+        var sectionJson = JsonSerializer.Serialize(new[]
+        {
+            new { id = "q1" }
+        });
+
+        var result = AIProviderPayloadValidator.ValidateApplicationScoringJson(
+            """
+            {
+              "q1": {
+                "answer": "No",
+                "rationale": "The record does not directly confirm the condition.",
+                "confidence": 0.30
+              }
+            }
+            """,
+            sectionJson);
+
+        result.IsValid.ShouldBeTrue();
+    }
+
     [Fact]
     public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_Decision_Is_Not_Proceed_Or_Hold()
     {
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs
new file mode 100644
index 0000000000..5111f7a81f
--- /dev/null
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs
@@ -0,0 +1,150 @@
+using Shouldly;
+using System.Collections.Generic;
+using System.Text.Json;
+using Unity.AI.Runtime;
+using Xunit;
+
+namespace Unity.GrantManager.AI.Runtime;
+
+public class OpenAIResponseParserTests
+{
+    [Fact]
+    public void ParseApplicationScoringResponse_Should_Preserve_All_Answer_Keys_From_Section_Output()
+    {
+        var raw = """
+        {
+          "q1": {
+            "answer": "No",
+            "rationale": "There is no direct evidence in DATA or ATTACHMENTS that the lead applicant meets any stated program eligibility criteria; eligibility is not explicitly confirmed.",
+            "confidence": 0.2
+          },
+          "q2": {
+            "answer": "2",
+            "rationale": "Although a facility partner (Riverbend Rec Center) is mentioned in CustomField3, there is no direct evidence that any project partner is explicitly eligible under program rules, so eligibility cannot be confirmed.",
+            "confidence": 0.2
+          },
+          "q3": {
+            "answer": "No",
+            "rationale": "The application materials describe a Community Kitchen Expansion but there is no statement or evidence showing this specific project is within the program scope, so scope compliance cannot be confirmed.",
+            "confidence": 0.2
+          },
+          "q4": {
+            "answer": "No",
+            "rationale": "Project location details (Riverbend, BC) are provided, but there is no evidence confirming the location meets any program-specific eligibility requirements, so location eligibility is not demonstrated.",
+            "confidence": 0.2
+          },
+          "q5": {
+            "answer": "2",
+            "rationale": "The submission does not explicitly identify an appropriate owner for the kitchen infrastructure in the provided DATA or ATTACHMENTS, and the Project Risk and Feasibility section is not present to confirm ownership.",
+            "confidence": 0.2
+          },
+          "q6": {
+            "answer": "No",
+            "rationale": "The set of attachments is provided, but there is no checklist or statement of mandatory supporting documents in DATA or ATTACHMENTS to confirm all required documents are included.",
+            "confidence": 0.2
+          },
+          "q7": {
+            "answer": "The submission lacks direct, explicit evidence for eligibility, scope, location, ownership, and required documents.",
+            "rationale": "DATA shows organizational and project descriptions and several inconsistent attachment profiles, but none directly confirm lead applicant eligibility, partner eligibility, program scope fit, site eligibility, infrastructure ownership, or inclusion of mandatory supporting documents.",
+            "confidence": 0.2
+          }
+        }
+        """;
+
+        var result = OpenAIResponseParser.ParseApplicationScoringResponse(raw);
+
+        result.Answers.Count.ShouldBe(7);
+        result.Answers.Keys.ShouldBe(new[]
+        {
+            "q1",
+            "q2",
+            "q3",
+            "q4",
+            "q5",
+            "q6",
+            "q7"
+        });
+
+        result.Answers["q1"].Answer.GetString().ShouldBe("No");
+        result.Answers["q7"].Answer.GetString().ShouldBe("The submission lacks direct, explicit evidence for eligibility, scope, location, ownership, and required documents.");
+    }
+
+    [Fact]
+    public void ParseApplicationScoringResponse_Should_Ignore_Non_Object_Properties()
+    {
+        var raw = """
+        {
+          "q1": {
+            "answer": "Yes",
+            "rationale": "ok",
+            "confidence": 0.9
+          },
+          "note": "should be ignored"
+        }
+        """;
+
+        var result = OpenAIResponseParser.ParseApplicationScoringResponse(raw);
+
+        result.Answers.Count.ShouldBe(1);
+        result.Answers.ShouldContainKey("q1");
+        result.Answers.ShouldNotContainKey("note");
+    }
+
+    [Fact]
+    public void ParseApplicationScoringResponse_Should_Parse_Mixed_Answer_Types_From_Project_Need_Output()
+    {
+        var raw = """
+        {
+          "q1": {
+            "answer": 0,
+            "rationale": "No CAT score is present in the provided DATA or any ATTACHMENTS. There is no direct evidence of a community CAT value for Riverbend, so the most conservative numeric response is 0.",
+            "confidence": 0.2
+          },
+          "q2": {
+            "answer": "4",
+            "rationale": "The ProjectSummary in DATA explicitly identifies expanding the community kitchen to support meal programs, volunteer training, and food security initiatives, which indicates multiple community needs with moderate detail. However, there is no supporting data, needs assessment, or quantitative evidence, so a score reflecting moderate information for multiple needs is appropriate.",
+            "confidence": 0.6
+          },
+          "q3": {
+            "answer": "The submission names food security, meal programs, and volunteer training as community needs but provides only brief descriptive information without supporting data, needs assessments, or stakeholder consultation evidence.",
+            "rationale": "Evidence is limited to the one-line ProjectSummary in DATA stating the project purpose. Attachments describe different mock projects and do not provide supporting documentation for this kitchen project, so the identified needs are described but not substantiated.",
+            "confidence": 0.6
+          }
+        }
+        """;
+
+        var result = OpenAIResponseParser.ParseApplicationScoringResponse(raw);
+
+        result.Answers.Count.ShouldBe(3);
+        result.Answers.ShouldContainKey("q1");
+        result.Answers.ShouldContainKey("q2");
+        result.Answers.ShouldContainKey("q3");
+        result.Answers["q1"].Answer.GetInt32().ShouldBe(0);
+        result.Answers["q2"].Answer.GetString().ShouldBe("4");
+        result.Answers["q3"].Answer.GetString().ShouldContain("food security");
+    }
+
+    [Fact]
+    public void ParseApplicationScoringResponse_Should_Round_Decimal_Confidence_To_Nearest_Ten()
+    {
+        var raw = """
+        {
+          "q1": {
+            "answer": "No",
+            "rationale": "The record does not directly confirm the condition.",
+            "confidence": 0.33
+          },
+          "q2": {
+            "answer": "No",
+            "rationale": "The record does not directly confirm the condition.",
+            "confidence": 0.86
+          }
+        }
+        """;
+
+        var result = OpenAIResponseParser.ParseApplicationScoringResponse(raw);
+
+        result.Answers["q1"].Confidence.ShouldBe(30);
+        result.Answers["q2"].Confidence.ShouldBe(90);
+    }
+}
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index 68c07143a9..a908313a99 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -23,9 +23,8 @@ public async Task Should_Throw_When_Analysis_Operation_Is_Not_Configured()
     {
         var resolver = CreateResolverWithNoOperations();
 
-        var ex = await Should.ThrowAsync<Exception>(() =>
+        await Should.ThrowAsync<Exception>(() =>
             resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
-
     }
 
     private static OpenAIConfigurationResolver CreateResolverWithNoOperations()
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
index 257cd64484..b67591f382 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
@@ -32,13 +32,16 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
         var featureGuard = new AIFeatureGuard(featureChecker, localizer);
 
         var queue = Substitute.For<IApplicationAIGenerationQueue>();
-        queue.QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
+        queue.QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>())
+            .Returns(Task.CompletedTask);
+        queue.QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
+            .Returns(Task.CompletedTask);
+        queue.QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
             .Returns(Task.CompletedTask);
         var currentTenant = Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>();
         currentTenant.Id.Returns(Guid.NewGuid());
 
         var service = new AIGenerationAppService(
-            Substitute.For<IAttachmentSummaryService>(),
             queue,
             featureGuard,
             currentTenant);
@@ -46,8 +49,10 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
         var result = await service.GenerateContentAsync(Guid.NewGuid());
 
         result.ShouldNotBeNull();
-        result.Completed.ShouldBeTrue();
-        await queue.Received(1).QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
+        result.Completed.ShouldBeFalse();
+        await queue.Received(1).QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>());
+        await queue.Received(1).QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
+        await queue.Received(1).QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
     }
 
     [Fact]
@@ -60,16 +65,8 @@ public async Task GenerateAttachmentSummariesAsync_Should_Validate_Against_Appli
 
         var applicationId = Guid.NewGuid();
         var attachmentIds = new List<Guid> { Guid.NewGuid(), Guid.NewGuid() };
-        var attachmentSummaryService = Substitute.For<IAttachmentSummaryService>();
-        attachmentSummaryService.GenerateForApplicationAsync(
-                applicationId,
-                "v1",
-                Arg.Is<IReadOnlyCollection<Guid>>(ids => ids.SequenceEqual(attachmentIds)),
-                Arg.Any<System.Threading.CancellationToken>())
-            .Returns(new List<string> { "summary-1", "summary-2" });
 
         var service = new AIGenerationAppService(
-            attachmentSummaryService,
             Substitute.For<IApplicationAIGenerationQueue>(),
             featureGuard,
             Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>());
@@ -82,11 +79,7 @@ public async Task GenerateAttachmentSummariesAsync_Should_Validate_Against_Appli
         });
 
         result.Count.ShouldBe(2);
-        await attachmentSummaryService.Received(1).GenerateForApplicationAsync(
-            applicationId,
-            "v1",
-            Arg.Is<IReadOnlyCollection<Guid>>(ids => ids.SequenceEqual(attachmentIds)),
-            Arg.Any<System.Threading.CancellationToken>());
+        result.ShouldAllBe(x => x.Completed == false);
     }
 }
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
index 3df4f8195b..3dd410d485 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
@@ -6,21 +6,20 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
 using System.Threading;
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.AI.Features;
 using Unity.AI.Localization;
-using Unity.AI.RateLimit;
 using Unity.AI.Operations;
+using Unity.AI.RateLimit;
 using Unity.GrantManager.GrantApplications;
-using Unity.GrantManager.GrantApplications.Automation;
 using Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
+using Volo.Abp;
 using Volo.Abp.BackgroundJobs;
-using Volo.Abp.Domain.Repositories;
+using Volo.Abp.DependencyInjection;
 using Volo.Abp.DistributedLocking;
-using Volo.Abp;
+using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Features;
 using Volo.Abp.Users;
 using Xunit;
@@ -30,30 +29,26 @@ namespace Unity.GrantManager.GrantApplications.Automation;
 
 public class AIGenerationQueueTests(ITestOutputHelper outputHelper) : GrantManagerApplicationTestBase(outputHelper)
 {
+    private static readonly Guid AttachmentSummaryOperationId = Guid.Parse("11111111-1111-1111-1111-111111111111");
+    private static readonly Guid ApplicationAnalysisOperationId = Guid.Parse("22222222-2222-2222-2222-222222222222");
+    private static readonly Guid ApplicationScoringOperationId = Guid.Parse("33333333-3333-3333-3333-333333333333");
+    private static readonly Guid DefaultOperationId = Guid.Parse("55555555-5555-5555-5555-555555555555");
+
     [Fact]
     public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Exists()
     {
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
-        repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
-        var operationRepository = CreateOperationRepository();
-
-        RunApplicationAIPipelineJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        backgroundJobManager.EnqueueAsync<RunApplicationAIPipelineJobArgs>(
-                Arg.Any<RunApplicationAIPipelineJobArgs>(),
-                Arg.Any<BackgroundJobPriority>(),
-                Arg.Any<TimeSpan?>())
+        RunApplicationAIPipelineJobArgs? capturedArgs = null;
+        backgroundJobManager.EnqueueAsync<RunApplicationAIPipelineJobArgs>(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
             .Returns(callInfo =>
             {
                 capturedArgs = callInfo.Arg<RunApplicationAIPipelineJobArgs>();
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
+        var queue = CreateQueue(backgroundJobManager);
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId, "v1");
 
@@ -62,14 +57,7 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
         capturedArgs.TenantId.ShouldBe(tenantId);
         capturedArgs.PromptVersion.ShouldBe("v1");
         capturedArgs.RequestedByUserId.ShouldBe(CreateQueueCurrentUserId);
-        capturedArgs.RequestKey.ShouldBe(AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.PipelineOperationType));
         await backgroundJobManager.Received(1).EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
-        await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
-            r.ApplicationId == applicationId &&
-            r.TenantId == tenantId &&
-            r.OperationId != Guid.Empty &&
-            r.RequestKey == capturedArgs.RequestKey &&
-            r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]
@@ -77,12 +65,6 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_When_Any_Enabled_Stage_Ha
     {
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
-        repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
-        var operationRepository = CreateOperationRepository();
-
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var prerequisiteValidator = Substitute.For<IAIGenerationPrerequisiteValidator>();
         prerequisiteValidator.EnsureAttachmentSummaryAvailableAsync(applicationId)
@@ -91,27 +73,18 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_When_Any_Enabled_Stage_Ha
         prerequisiteValidator.EnsureApplicationScoringAvailableAsync(applicationId)
             .Returns<Task>(_ => throw new UserFriendlyException("AI scoring requires a configured scoresheet."));
 
-        var queue = CreateQueue(
-            backgroundJobManager,
-            repository,
-            operationRepository: operationRepository,
-            prerequisiteValidator: prerequisiteValidator);
+        var queue = CreateQueue(backgroundJobManager, prerequisiteValidator: prerequisiteValidator);
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId);
 
-        await repository.Received(1).InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
         await backgroundJobManager.Received(1).EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
     }
 
     [Fact]
-    public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_Enabled_Stage_Has_Required_Input()
+    public async Task QueueAllAIStagesAsync_Should_Not_Enqueue_When_No_Enabled_Stage_Has_Required_Input()
     {
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
-        var operationRepository = CreateOperationRepository();
-
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
         var rateLimiter = Substitute.For<IAIRateLimiter>();
         rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
@@ -123,85 +96,14 @@ public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_Ena
         prerequisiteValidator.EnsureApplicationScoringAvailableAsync(applicationId)
             .Returns<Task>(_ => throw new UserFriendlyException("AI scoring requires a configured scoresheet."));
 
-        var queue = CreateQueue(
-            backgroundJobManager,
-            repository,
-            rateLimiter,
-            prerequisiteValidator,
-            operationRepository: operationRepository);
-
-        await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAllAIStagesAsync(applicationId, tenantId));
-
-        await rateLimiter.DidNotReceive().EnsureAsync();
-        await repository.DidNotReceive().InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
-    }
-
-    [Fact]
-    public async Task QueueAllAIStagesAsync_Should_Not_Insert_Or_Enqueue_When_No_AI_Stages_Are_Enabled()
-    {
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
-        var operationRepository = CreateOperationRepository();
-
-        var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        var rateLimiter = Substitute.For<IAIRateLimiter>();
-        rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
-        var prerequisiteValidator = Substitute.For<IAIGenerationPrerequisiteValidator>();
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync(AIFeatures.AttachmentSummaries).Returns(Task.FromResult(false));
-        featureChecker.IsEnabledAsync(AIFeatures.ApplicationAnalysis).Returns(Task.FromResult(false));
-        featureChecker.IsEnabledAsync(AIFeatures.Scoring).Returns(Task.FromResult(false));
-
-        var queue = CreateQueue(
-            backgroundJobManager,
-            repository,
-            rateLimiter,
-            prerequisiteValidator,
-            featureChecker,
-            operationRepository: operationRepository);
+        var queue = CreateQueue(backgroundJobManager, rateLimiter: rateLimiter, prerequisiteValidator: prerequisiteValidator);
 
         await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAllAIStagesAsync(applicationId, tenantId));
 
-        await prerequisiteValidator.DidNotReceive().EnsureAttachmentSummaryAvailableAsync(Arg.Any<Guid>());
-        await prerequisiteValidator.DidNotReceive().EnsureApplicationAnalysisAvailableAsync(Arg.Any<Guid>());
-        await prerequisiteValidator.DidNotReceive().EnsureApplicationScoringAvailableAsync(Arg.Any<Guid>());
         await rateLimiter.DidNotReceive().EnsureAsync();
-        await repository.DidNotReceive().InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
         await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
     }
 
-    [Fact]
-    public async Task QueueApplicationAnalysisAsync_Should_Not_Enqueue_When_An_Active_Request_Already_Exists()
-    {
-        var tenantId = Guid.NewGuid();
-        var applicationId = Guid.NewGuid();
-        var promptVersion = "v1";
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
-        var request = new AIGenerationRequest(
-            Guid.NewGuid(),
-            tenantId,
-            Guid.NewGuid(),
-            applicationId,
-            requestKey);
-
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(new[] { request }.AsQueryable()));
-
-        var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        var rateLimiter = Substitute.For<Unity.AI.RateLimit.IAIRateLimiter>();
-        rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
-        var queue = CreateQueue(backgroundJobManager, repository, rateLimiter: rateLimiter);
-
-        await queue.QueueApplicationAnalysisAsync(applicationId, tenantId, promptVersion);
-
-        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>());
-        await repository.DidNotReceive().InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-        await rateLimiter.DidNotReceive().EnsureAsync();
-    }
-
     [Fact]
     public async Task QueueApplicationAnalysisAsync_Should_Enqueue_New_Request_When_None_Exists()
     {
@@ -215,10 +117,7 @@ public async Task QueueApplicationAnalysisAsync_Should_Enqueue_New_Request_When_
 
         GenerateApplicationAnalysisBackgroundJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        backgroundJobManager.EnqueueAsync<GenerateApplicationAnalysisBackgroundJobArgs>(
-                Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>(),
-                Arg.Any<BackgroundJobPriority>(),
-                Arg.Any<TimeSpan?>())
+        backgroundJobManager.EnqueueAsync<GenerateApplicationAnalysisBackgroundJobArgs>(Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
             .Returns(callInfo =>
             {
                 capturedArgs = callInfo.Arg<GenerateApplicationAnalysisBackgroundJobArgs>();
@@ -234,12 +133,9 @@ public async Task QueueApplicationAnalysisAsync_Should_Enqueue_New_Request_When_
         capturedArgs.TenantId.ShouldBe(tenantId);
         capturedArgs.PromptVersion.ShouldBe(promptVersion);
         capturedArgs.RequestedByUserId.ShouldBe(CreateQueueCurrentUserId);
-        capturedArgs.RequestKey.ShouldBe(AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType));
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationId != Guid.Empty &&
-            r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
@@ -308,32 +204,6 @@ public async Task QueueAttachmentSummaryAsync_Should_Not_Insert_Or_Enqueue_When_
         await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
     }
 
-    [Fact]
-    public async Task QueueAttachmentSummaryAsync_Should_Not_Enqueue_When_An_Active_Request_Already_Exists()
-    {
-        var tenantId = Guid.NewGuid();
-        var applicationId = Guid.NewGuid();
-        var promptVersion = "v1";
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.AttachmentSummaryOperationType);
-        var request = new AIGenerationRequest(
-            Guid.NewGuid(),
-            tenantId,
-            Guid.NewGuid(),
-            applicationId,
-            requestKey);
-
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(new[] { request }.AsQueryable()));
-
-        var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        var queue = CreateQueue(backgroundJobManager, repository);
-
-        await queue.QueueAttachmentSummaryAsync(applicationId, tenantId, promptVersion);
-
-        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>());
-        await repository.DidNotReceive().InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-    }
-
     [Fact]
     public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_None_Exists()
     {
@@ -344,21 +214,17 @@ public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_No
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
-        var operationRepository = CreateOperationRepository();
 
         GenerateAttachmentSummaryBackgroundJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        backgroundJobManager.EnqueueAsync<GenerateAttachmentSummaryBackgroundJobArgs>(
-                Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(),
-                Arg.Any<BackgroundJobPriority>(),
-                Arg.Any<TimeSpan?>())
+        backgroundJobManager.EnqueueAsync<GenerateAttachmentSummaryBackgroundJobArgs>(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
             .Returns(callInfo =>
             {
                 capturedArgs = callInfo.Arg<GenerateAttachmentSummaryBackgroundJobArgs>();
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
+        var queue = CreateQueue(backgroundJobManager, repository);
 
         await queue.QueueAttachmentSummaryAsync(applicationId, tenantId, promptVersion);
 
@@ -367,41 +233,12 @@ public async Task QueueAttachmentSummaryAsync_Should_Enqueue_New_Request_When_No
         capturedArgs.TenantId.ShouldBe(tenantId);
         capturedArgs.PromptVersion.ShouldBe(promptVersion);
         capturedArgs.RequestedByUserId.ShouldBe(CreateQueueCurrentUserId);
-        capturedArgs.RequestKey.ShouldBe(AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.AttachmentSummaryOperationType));
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
-            r.OperationId != Guid.Empty &&
-            r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
-    [Fact]
-    public async Task QueueApplicationScoringAsync_Should_Not_Enqueue_When_An_Active_Request_Already_Exists()
-    {
-        var tenantId = Guid.NewGuid();
-        var applicationId = Guid.NewGuid();
-        var promptVersion = "v1";
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationScoringOperationType);
-        var request = new AIGenerationRequest(
-            Guid.NewGuid(),
-            tenantId,
-            Guid.NewGuid(),
-            applicationId,
-            requestKey);
-
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(new[] { request }.AsQueryable()));
-
-        var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        var queue = CreateQueue(backgroundJobManager, repository);
-
-        await queue.QueueApplicationScoringAsync(applicationId, tenantId, promptVersion);
-
-        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateApplicationScoringBackgroundJobArgs>());
-        await repository.DidNotReceive().InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-    }
-
     [Fact]
     public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_None_Exists()
     {
@@ -412,21 +249,17 @@ public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_N
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
         repository.InsertAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
-        var operationRepository = CreateOperationRepository();
 
         GenerateApplicationScoringBackgroundJobArgs? capturedArgs = null;
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        backgroundJobManager.EnqueueAsync<GenerateApplicationScoringBackgroundJobArgs>(
-                Arg.Any<GenerateApplicationScoringBackgroundJobArgs>(),
-                Arg.Any<BackgroundJobPriority>(),
-                Arg.Any<TimeSpan?>())
+        backgroundJobManager.EnqueueAsync<GenerateApplicationScoringBackgroundJobArgs>(Arg.Any<GenerateApplicationScoringBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
             .Returns(callInfo =>
             {
                 capturedArgs = callInfo.Arg<GenerateApplicationScoringBackgroundJobArgs>();
                 return Task.FromResult(string.Empty);
             });
 
-        var queue = CreateQueue(backgroundJobManager, repository, operationRepository: operationRepository);
+        var queue = CreateQueue(backgroundJobManager, repository);
 
         await queue.QueueApplicationScoringAsync(applicationId, tenantId, promptVersion);
 
@@ -435,12 +268,10 @@ public async Task QueueApplicationScoringAsync_Should_Enqueue_New_Request_When_N
         capturedArgs.TenantId.ShouldBe(tenantId);
         capturedArgs.PromptVersion.ShouldBe(promptVersion);
         capturedArgs.RequestedByUserId.ShouldBe(CreateQueueCurrentUserId);
-        capturedArgs.RequestKey.ShouldBe(AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationScoringOperationType));
         await repository.Received(1).InsertAsync(Arg.Is<AIGenerationRequest>(r =>
             r.ApplicationId == applicationId &&
             r.TenantId == tenantId &&
             r.OperationId != Guid.Empty &&
-            r.RequestKey == capturedArgs.RequestKey &&
             r.Status == AIGenerationRequestStatus.Queued), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
@@ -483,15 +314,18 @@ public ValueTask DisposeAsync()
 
     private static ApplicationAIGenerationQueue CreateQueue(
         IBackgroundJobManager backgroundJobManager,
-        IRepository<AIGenerationRequest, Guid> repository,
-        Unity.AI.RateLimit.IAIRateLimiter? rateLimiter = null,
+        IRepository<AIGenerationRequest, Guid>? repository = null,
+        IAIRateLimiter? rateLimiter = null,
         IAIGenerationPrerequisiteValidator? prerequisiteValidator = null,
         IFeatureChecker? featureChecker = null,
         IRepository<AIOperation, Guid>? operationRepository = null)
     {
+        repository ??= Substitute.For<IRepository<AIGenerationRequest, Guid>>();
+        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
+
         if (rateLimiter == null)
         {
-            rateLimiter = Substitute.For<Unity.AI.RateLimit.IAIRateLimiter>();
+            rateLimiter = Substitute.For<IAIRateLimiter>();
             rateLimiter.EnsureAsync().Returns(Task.CompletedTask);
         }
 
@@ -530,16 +364,14 @@ private static IRepository<AIOperation, Guid> CreateOperationRepository()
     {
         var operations = new List<AIOperation>
         {
-            new(Guid.NewGuid(), "AttachmentSummary", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
-            new(Guid.NewGuid(), "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
-            new(Guid.NewGuid(), "ApplicationScoring", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
-            new(Guid.NewGuid(), "Default", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true }
+            new(AttachmentSummaryOperationId, "AttachmentSummary", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(ApplicationAnalysisOperationId, "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(ApplicationScoringOperationId, "ApplicationScoring", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
+            new(DefaultOperationId, "Default", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true }
         };
 
         var repository = Substitute.For<IRepository<AIOperation, Guid>>();
-        repository.GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
-
+        repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
         return repository;
     }
 
@@ -550,3 +382,4 @@ private static ICurrentUser CreateCurrentUser()
         return currentUser;
     }
 }
+
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
index c9e2fc6231..f0659db596 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
@@ -20,7 +20,6 @@ public async Task GetLatestAsync_Should_Respect_Current_Tenant()
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
         var otherTenantId = Guid.NewGuid();
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
         var operationId = Guid.NewGuid();
 
         var operations = new[]
@@ -33,8 +32,8 @@ public async Task GetLatestAsync_Should_Respect_Current_Tenant()
 
         var requests = new[]
         {
-            new AIGenerationRequest(Guid.NewGuid(), otherTenantId, operationId, applicationId, requestKey),
-            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, requestKey)
+            new AIGenerationRequest(Guid.NewGuid(), otherTenantId, operationId, applicationId),
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId)
         };
 
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
@@ -58,7 +57,6 @@ public async Task GetLatestAsync_Should_Return_History_For_Inactive_Operation()
     {
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
-        var requestKey = AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
         var operationId = Guid.NewGuid();
 
         var operations = new[]
@@ -71,7 +69,7 @@ public async Task GetLatestAsync_Should_Return_History_For_Inactive_Operation()
 
         var requests = new[]
         {
-            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, requestKey)
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId)
         };
 
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
@@ -105,7 +103,7 @@ public async Task GetLatestAsync_Should_Reject_Legacy_Operation_Name()
 
         var requests = new[]
         {
-            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId, "legacy-operation-name")
+            new AIGenerationRequest(Guid.NewGuid(), tenantId, operationId, applicationId)
         };
 
         var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
index 98fd04e712..773583a2c2 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Unity.AI.Domain;
 using Unity.AI.Operations;
 using Unity.GrantManager.Applications;
 using Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
@@ -25,28 +26,31 @@ namespace Unity.GrantManager.GrantApplications.Automation;
 
 public class RunApplicationAIPipelineJobTests(ITestOutputHelper outputHelper) : GrantManagerApplicationTestBase(outputHelper)
 {
+    private static readonly Guid AttachmentSummaryOperationId = Guid.Parse("11111111-1111-1111-1111-111111111111");
+    private static readonly Guid ApplicationAnalysisOperationId = Guid.Parse("22222222-2222-2222-2222-222222222222");
+    private static readonly Guid ApplicationScoringOperationId = Guid.Parse("33333333-3333-3333-3333-333333333333");
+    private static readonly Guid PipelineOperationId = Guid.Parse("44444444-4444-4444-4444-444444444444");
+    private static readonly Guid DefaultOperationId = Guid.Parse("55555555-5555-5555-5555-555555555555");
+
     [Fact]
     public async Task ExecuteAsync_Should_Mark_Request_Completed_When_Features_Disabled()
     {
         var featureChecker = Substitute.For<IFeatureChecker>();
         featureChecker.IsEnabledAsync(Arg.Any<string>()).Returns(false);
 
-        var repository = BuildRequestRepository(out var requests);
-        var request = CreateRequest();
-        requests.Add(request);
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
 
-        var job = BuildJob(featureChecker, repository);
+        var job = BuildJob(featureChecker);
         var requestedByUserId = Guid.NewGuid();
 
         await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
         {
-            ApplicationId = request.ApplicationId!.Value,
-            RequestKey = request.RequestKey,
+            ApplicationId = applicationId,
             RequestedByUserId = requestedByUserId,
-            TenantId = request.TenantId
+            TenantId = tenantId
         });
 
-        request.Status.ShouldBe(AIGenerationRequestStatus.Completed);
     }
 
     [Fact]
@@ -57,41 +61,37 @@ public async Task ExecuteAsync_Should_Publish_Event_When_Pipeline_Scoring_Comple
         featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(false);
         featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(true);
 
-        var repository = BuildRequestRepository(out var requests);
-        var request = CreateRequest();
-        requests.Add(request);
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
 
         var scoringService = Substitute.For<IApplicationScoringService>();
         scoringService.RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>())
             .Returns("{}");
         var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
         inputBuilder.BuildApplicationScoringInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = request.ApplicationId!.Value });
+            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = applicationId });
         var applicationRepository = Substitute.For<IApplicationRepository>();
         var application = new Application
         {
             ApplicationFormId = Guid.NewGuid()
         };
-        applicationRepository.GetAsync(request.ApplicationId!.Value).Returns(application);
+        applicationRepository.GetAsync(applicationId).Returns(application);
         applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
         var objectMapper = Substitute.For<IObjectMapper>();
         objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
             .Returns(new AIApplicationPromptDataDto
             {
-                ApplicationId = request.ApplicationId!.Value,
+                ApplicationId = applicationId,
                 ApplicationFormId = application.ApplicationFormId
             });
 
         var localEventBus = Substitute.For<ILocalEventBus>();
-        var rateLimiter = Substitute.For<IAIRateLimiter>();
         var requestedByUserId = Guid.NewGuid();
 
         var job = BuildJob(
             featureChecker,
-            repository,
             localEventBus: localEventBus,
-            rateLimiter: rateLimiter,
             applicationScoringService: scoringService,
             inputBuilder: inputBuilder,
             applicationRepository: applicationRepository,
@@ -99,17 +99,14 @@ public async Task ExecuteAsync_Should_Publish_Event_When_Pipeline_Scoring_Comple
 
         await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
         {
-            ApplicationId = request.ApplicationId!.Value,
-            RequestKey = request.RequestKey,
+            ApplicationId = applicationId,
             RequestedByUserId = requestedByUserId,
-            TenantId = request.TenantId
+            TenantId = tenantId
         });
 
-        request.Status.ShouldBe(AIGenerationRequestStatus.Completed);
-        await applicationRepository.Received(1).GetAsync(request.ApplicationId!.Value);
-        await rateLimiter.Received(1).StampAsync(requestedByUserId);
+        await applicationRepository.Received(1).GetAsync(applicationId);
         await localEventBus.Received(1).PublishAsync(
-            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == request.ApplicationId));
+            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == applicationId));
     }
 
     [Fact]
@@ -120,14 +117,13 @@ public async Task ExecuteAsync_Should_Skip_Unavailable_Stage_And_Run_Available_S
         featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(true);
         featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(false);
 
-        var repository = BuildRequestRepository(out var requests);
-        var request = CreateRequest();
-        requests.Add(request);
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
         var attachmentRepository = Substitute.For<IApplicationChefsFileAttachmentRepository>();
         attachmentRepository.GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<ApplicationChefsFileAttachment, bool>>>())
             .Returns(new List<ApplicationChefsFileAttachment>
             {
-                CreateAttachment(request.ApplicationId!.Value)
+                CreateAttachment(applicationId)
             });
 
         var attachmentSummaryService = Substitute.For<IAttachmentSummaryService>();
@@ -139,26 +135,25 @@ public async Task ExecuteAsync_Should_Skip_Unavailable_Stage_And_Run_Available_S
             .Returns("{}");
         var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
         inputBuilder.BuildApplicationAnalysisInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = request.ApplicationId!.Value });
+            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = applicationId });
         var applicationRepository = Substitute.For<IApplicationRepository>();
         var application = new Application
         {
             ApplicationFormId = Guid.NewGuid()
         };
-        applicationRepository.GetAsync(request.ApplicationId!.Value).Returns(application);
+        applicationRepository.GetAsync(applicationId).Returns(application);
         applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
         var objectMapper = Substitute.For<IObjectMapper>();
         objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
             .Returns(new AIApplicationPromptDataDto
             {
-                ApplicationId = request.ApplicationId!.Value,
+                ApplicationId = applicationId,
                 ApplicationFormId = application.ApplicationFormId
             });
 
         var job = BuildJob(
             featureChecker,
-            repository,
             attachmentRepository: attachmentRepository,
             attachmentSummaryService: attachmentSummaryService,
             applicationAnalysisService: applicationAnalysisService,
@@ -168,14 +163,12 @@ public async Task ExecuteAsync_Should_Skip_Unavailable_Stage_And_Run_Available_S
 
         await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
         {
-            ApplicationId = request.ApplicationId.Value,
-            RequestKey = request.RequestKey,
+            ApplicationId = applicationId,
             RequestedByUserId = Guid.NewGuid(),
-            TenantId = request.TenantId
+            TenantId = tenantId
         });
 
-        request.Status.ShouldBe(AIGenerationRequestStatus.Completed);
-        await applicationRepository.Received(1).GetAsync(request.ApplicationId!.Value);
+        await applicationRepository.Received(1).GetAsync(applicationId);
         await attachmentSummaryService.Received(1).GenerateAndSaveAsync(Arg.Any<List<Guid>>(), Arg.Any<string?>());
         await applicationAnalysisService.Received(1).RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>());
     }
@@ -188,9 +181,8 @@ public async Task ExecuteAsync_Should_Skip_Analysis_UserFriendlyException_And_Co
         featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(true);
         featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(true);
 
-        var repository = BuildRequestRepository(out var requests);
-        var request = CreateRequest();
-        requests.Add(request);
+        var applicationId = Guid.NewGuid();
+        var tenantId = Guid.NewGuid();
 
         var analysisService = Substitute.For<IApplicationAnalysisService>();
         analysisService.RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>())
@@ -202,35 +194,32 @@ public async Task ExecuteAsync_Should_Skip_Analysis_UserFriendlyException_And_Co
 
         var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
         inputBuilder.BuildApplicationAnalysisInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = request.ApplicationId!.Value });
+            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = applicationId });
         inputBuilder.BuildApplicationScoringInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = request.ApplicationId!.Value });
+            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = applicationId });
 
         var applicationRepository = Substitute.For<IApplicationRepository>();
         var application = new Application
         {
             ApplicationFormId = Guid.NewGuid()
         };
-        applicationRepository.GetAsync(request.ApplicationId!.Value).Returns(application);
+        applicationRepository.GetAsync(applicationId).Returns(application);
         applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
         var objectMapper = Substitute.For<IObjectMapper>();
         objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
             .Returns(new AIApplicationPromptDataDto
             {
-                ApplicationId = request.ApplicationId!.Value,
+                ApplicationId = applicationId,
                 ApplicationFormId = application.ApplicationFormId
             });
 
         var localEventBus = Substitute.For<ILocalEventBus>();
-        var rateLimiter = Substitute.For<IAIRateLimiter>();
         var requestedByUserId = Guid.NewGuid();
 
         var job = BuildJob(
             featureChecker,
-            repository,
             localEventBus: localEventBus,
-            rateLimiter: rateLimiter,
             applicationAnalysisService: analysisService,
             applicationScoringService: scoringService,
             inputBuilder: inputBuilder,
@@ -239,22 +228,19 @@ public async Task ExecuteAsync_Should_Skip_Analysis_UserFriendlyException_And_Co
 
         await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
         {
-            ApplicationId = request.ApplicationId.Value,
-            RequestKey = request.RequestKey,
+            ApplicationId = applicationId,
             RequestedByUserId = requestedByUserId,
-            TenantId = request.TenantId
+            TenantId = tenantId
         });
 
-        request.Status.ShouldBe(AIGenerationRequestStatus.Completed);
-        await applicationRepository.Received(1).GetAsync(request.ApplicationId!.Value);
+        await applicationRepository.Received(1).GetAsync(applicationId);
         await scoringService.Received(1).RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>());
         await localEventBus.Received(1).PublishAsync(
-            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == request.ApplicationId));
+            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == applicationId));
     }
 
     private RunApplicationAIPipelineJob BuildJob(
         IFeatureChecker featureChecker,
-        IRepository<AIGenerationRequest, Guid> generationRequestRepository,
         ILocalEventBus? localEventBus = null,
         IApplicationChefsFileAttachmentRepository? attachmentRepository = null,
         IAttachmentSummaryService? attachmentSummaryService = null,
@@ -262,8 +248,7 @@ private RunApplicationAIPipelineJob BuildJob(
         IApplicationScoringService? applicationScoringService = null,
         IAIApplicationInputBuilder? inputBuilder = null,
         IApplicationRepository? applicationRepository = null,
-        IObjectMapper? objectMapper = null,
-        IAIRateLimiter? rateLimiter = null)
+        IObjectMapper? objectMapper = null)
     {
         return new RunApplicationAIPipelineJob(
             attachmentRepository ?? Substitute.For<IApplicationChefsFileAttachmentRepository>(),
@@ -274,40 +259,11 @@ private RunApplicationAIPipelineJob BuildJob(
             applicationRepository ?? Substitute.For<IApplicationRepository>(),
             featureChecker,
             localEventBus ?? Substitute.For<ILocalEventBus>(),
-            generationRequestRepository,
             Substitute.For<ICurrentTenant>(),
             objectMapper ?? Substitute.For<IObjectMapper>(),
-            GetRequiredService<IUnitOfWorkManager>(),
-            rateLimiter ?? Substitute.For<IAIRateLimiter>(),
             NullLogger<RunApplicationAIPipelineJob>.Instance);
     }
 
-    private static IRepository<AIGenerationRequest, Guid> BuildRequestRepository(out List<AIGenerationRequest> requests)
-    {
-        var requestList = new List<AIGenerationRequest>();
-        requests = requestList;
-        var repository = Substitute.For<IRepository<AIGenerationRequest, Guid>>();
-
-        repository.GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requestList.AsQueryable()));
-        repository.UpdateAsync(Arg.Any<AIGenerationRequest>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<AIGenerationRequest>()));
-
-        return repository;
-    }
-
-    private static AIGenerationRequest CreateRequest()
-    {
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-        return new AIGenerationRequest(
-            Guid.NewGuid(),
-            tenantId,
-            Guid.NewGuid(),
-            applicationId,
-            AIGenerationRequestKeyHelper.BuildRequestKey(tenantId, applicationId, AIGenerationRequestKeyHelper.PipelineOperationType));
-    }
-
     private static ApplicationChefsFileAttachment CreateAttachment(Guid applicationId)
     {
         var attachment = new ApplicationChefsFileAttachment

From 5a44b84be4b716236cc66a6c5060c800dbd2f130 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Thu, 2 Jul 2026 15:55:23 -0700
Subject: [PATCH 29/61] AB#32307 require application id for queued AI requests

---
 .../Automation/ApplicationAIGenerationQueue.cs                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index 443c1a72dd..71a65f57b0 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -115,7 +115,7 @@ await backgroundJobManager.EnqueueAsync(new RunApplicationAIPipelineJobArgs
     private async Task EnsureRequestAndEnqueueAsync(
         Guid? tenantId,
         string operationType,
-        Guid? applicationId,
+        Guid applicationId,
         Func<Task> validateInput,
         Func<Task> enqueue)
     {

From 3504189b703ae2fb78157c11451834a3ce05a42f Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Thu, 2 Jul 2026 16:10:33 -0700
Subject: [PATCH 30/61] AB#32307 add prompt metadata defaults in tests

---
 .../AI/Runtime/OpenAIConfigurationResolverTests.cs        | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index e0099c5d10..067b5525b8 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -83,6 +83,7 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
             {
+                MetadataJson = "{}",
                 IsActive = true
             }));
 
@@ -159,6 +160,7 @@ public async Task Should_Fallback_To_Default_Operation_When_Override_Is_Missing(
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
             {
+                MetadataJson = "{}",
                 IsActive = true
             }));
 
@@ -295,6 +297,7 @@ public async Task Should_Resolve_Operation_Settings_From_Host_Context()
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new AIPrompt(promptId, AIPromptTypes.ApplicationAnalysis, 1, "system", "user")
             {
+                MetadataJson = "{}",
                 IsActive = true
             }));
 
@@ -380,7 +383,10 @@ private static IRepository<AIPrompt, Guid> CreateEmptyPromptRepository()
         var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
         promptRepository
             .GetAsync(Arg.Any<Guid>(), cancellationToken: Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(new AIPrompt(callInfo.Arg<Guid>(), "Default", 1, "system", "user")));
+            .Returns(callInfo => Task.FromResult(new AIPrompt(callInfo.Arg<Guid>(), "Default", 1, "system", "user")
+            {
+                MetadataJson = "{}"
+            }));
         return promptRepository;
     }
 }

From 7056f38eab30ca1ee62cf97598bdd83becc23355 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Thu, 2 Jul 2026 16:19:20 -0700
Subject: [PATCH 31/61] AB#32307 keep seeded prompt metadata non-null

---
 .../src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 1001c3e84a..8d86977d68 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -109,7 +109,7 @@ private async Task EnsurePromptAsync(
         {
             prompt.SystemPrompt = systemPrompt;
             prompt.UserPrompt = userPrompt;
-            prompt.MetadataJson = metadataJson;
+            prompt.MetadataJson = metadataJson ?? "{}";
             prompt.IsActive = true;
             await promptRepository.UpdateAsync(prompt, autoSave: true);
             return;
@@ -122,7 +122,7 @@ await promptRepository.InsertAsync(new AIPrompt(
             systemPrompt,
             userPrompt)
         {
-            MetadataJson = metadataJson,
+            MetadataJson = metadataJson ?? "{}",
             IsActive = true
         });
     }

From 12a38a0be5082130a3b92d8eb9a34f02c405e06f Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Thu, 2 Jul 2026 18:17:26 -0700
Subject: [PATCH 32/61] AB#32307 finalize AI prompt and generation updates

---
 .../AI/Runtime/OpenAIRuntimeService.cs        |  13 +-
 .../DataSeed/AIPromptDataSeeder.cs            | 276 +++++++++++++++++-
 .../ApplicationAIGenerationQueue.cs           | 112 ++++---
 .../AIGenerationRequestJobHelper.cs           |   5 +-
 .../GrantApplicationAppService.cs             |  28 +-
 .../AI/DataSeed/AIOperationDataSeederTests.cs |  26 --
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   |   2 +-
 .../Automation/AIGenerationQueueTests.cs      |  69 +++--
 8 files changed, 392 insertions(+), 139 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
index eab0951cad..0c340061c7 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
@@ -9,6 +9,7 @@
 using Unity.AI.Prompts;
 using Unity.AI.Requests;
 using Unity.AI.Responses;
+using Volo.Abp;
 using Volo.Abp.DependencyInjection;
 
 namespace Unity.AI.Runtime
@@ -103,10 +104,14 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
                         providerDetails = providerDetails[..400];
                     }
 
-                    throw new InvalidOperationException(
-                        $"Application analysis generation failed with outcome '{result.Outcome}' and failure category '{result.FailureCategory}'. " +
-                        $"HTTP status: {(result.Response?.HttpStatusCode?.ToString() ?? "n/a")}. " +
-                        $"Provider details: {providerDetails ?? "n/a"}");
+                    _logger.LogError(
+                        "Application analysis generation failed with outcome {Outcome} and failure category {FailureCategory}. HTTP status {HttpStatusCode}. Provider details: {ProviderDetails}",
+                        result.Outcome,
+                        result.FailureCategory,
+                        result.Response?.HttpStatusCode?.ToString() ?? "n/a",
+                        providerDetails ?? "n/a");
+
+                    throw new UserFriendlyException("Application analysis generation failed.");
                 }
 
                 return OpenAIResponseParser.ParseApplicationAnalysisResponse(result.Content);
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 8d86977d68..3913f9250d 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -47,6 +47,17 @@ await EnsurePromptAsync(
                 output: AnalysisOutput,
                 rules: AnalysisRules,
                 commonRules: CommonRules));
+        await EnsurePromptAsync(
+            AIPromptTypes.ApplicationAnalysis,
+            2,
+            AnalysisSystemV2,
+            AnalysisUserV2,
+            BuildSections(
+                rubric: AnalysisRubricV2,
+                score: AnalysisScoreV2,
+                output: AnalysisOutputV2,
+                rules: AnalysisRulesV2,
+                commonRules: CommonRules));
     }
 
     // ─── ATTACHMENT ───────────────────────────────────────────────────────────
@@ -63,6 +74,15 @@ await EnsurePromptAsync(
                 output: AttachmentOutput,
                 rules: AttachmentRules,
                 commonRules: CommonRules));
+        await EnsurePromptAsync(
+            AIPromptTypes.AttachmentSummary,
+            2,
+            AttachmentSystemV2,
+            AttachmentUserV2,
+            BuildSections(
+                output: AttachmentOutputV2,
+                rules: AttachmentRulesV2,
+                commonRules: CommonRules));
     }
 
     // ─── SCORESHEET ───────────────────────────────────────────────────────────
@@ -79,6 +99,15 @@ await EnsurePromptAsync(
                 output: ScoresheetOutput,
                 rules: ScoresheetRules,
                 commonRules: CommonRules));
+        await EnsurePromptAsync(
+            AIPromptTypes.ApplicationScoring,
+            2,
+            ScoresheetSystemV2,
+            ScoresheetUserV2,
+            BuildSections(
+                output: ScoresheetOutputV2,
+                rules: ScoresheetRulesV2,
+                commonRules: CommonRules));
     }
 
     // ─── HELPERS ──────────────────────────────────────────────────────────────
@@ -246,9 +275,15 @@ OPTIONAL FIELDS (may be left blank):
 
     // ── v1/analysis.system.txt ───────────────────────────────────────────────
     private const string AnalysisSystemV1 = """
-        You are a careful grant review assistant for human reviewers.
-        Review the application and attachments for the strongest reviewer-relevant evidence.
-        Return only conclusions that are directly supported by that evidence.
+        ROLE
+        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
+
+        TASK
+        Using SCHEMA, DATA, ATTACHMENTS, RUBRIC, SCORE, OUTPUT, and RULES:
+        1. Review the application and any provided attachments for the strongest reviewer-relevant evidence.
+        2. Determine which conclusions are directly supported by that evidence.
+        3. Exclude weak, repetitive, or loosely supported conclusions.
+        4. Return only the strongest evidence-backed reviewer conclusions.
         """;
 
     // ── v1/analysis.user.txt ─────────────────────────────────────────────────
@@ -351,6 +386,113 @@ Return only conclusions that are directly supported by that evidence.
         - Return an empty array only when no concrete next action would help the reviewer.
         """;
 
+    // ── v2/analysis.system.txt ───────────────────────────────────────────────
+    private const string AnalysisSystemV2 = """
+        You are a careful grant review assistant for human reviewers.
+        Review the application and attachments for the strongest evidence-backed reviewer conclusions.
+        Do not fill gaps, assume compliance, or treat relevance as proof.
+        """;
+
+    // ── v2/analysis.user.txt ─────────────────────────────────────────────────
+    private const string AnalysisUserV2 = """
+        SCHEMA
+        {{SCHEMA}}
+
+        DATA
+        {{DATA}}
+
+        ATTACHMENTS
+        {{ATTACHMENTS}}
+
+        RUBRIC
+        {{RUBRIC}}
+
+        SCORE
+        {{SCORE}}
+
+        RESPONSE
+        {{RESPONSE}}
+
+        RULES
+        {{RULES}}
+        {{COMMON_RULES}}
+        """;
+
+    // ── v2/analysis.rubric.txt ───────────────────────────────────────────────
+    private const string AnalysisRubricV2 = """
+        ELIGIBILITY REQUIREMENTS: Project aligns with program objectives; Applicant is an eligible entity; Budget is reasonable and justified; Timeline is realistic.
+        COMPLETENESS CHECKS: Required information is present; Supporting materials are provided where applicable; Description is clear.
+        FINANCIAL REVIEW: Requested amount is within limits; Budget matches scope; Matching funds or contributions are identified.
+        RISK ASSESSMENT: Applicant capacity; Feasibility; Compliance considerations; Delivery risks.
+        QUALITY INDICATORS: Clear objectives; Defined beneficiaries; Appropriate approach; Long-term sustainability.
+        """;
+
+    // ── v2/analysis.score.txt ────────────────────────────────────────────────
+    private const string AnalysisScoreV2 = """
+        HIGH: Application demonstrates strong evidence across most rubric areas with few or no issues.
+        MEDIUM: Application has some gaps or weaknesses that require reviewer attention.
+        LOW: Application has significant gaps or risks across key rubric areas.
+        """;
+
+    // ── v2/analysis.output.txt ───────────────────────────────────────────────
+    private const string AnalysisOutputV2 = """
+        {
+          "decision": "<PROCEED|HOLD>",
+          "errors": [
+            {
+              "title": "<string>",
+              "detail": "<string>"
+            }
+          ],
+          "warnings": [
+            {
+              "title": "<string>",
+              "detail": "<string>"
+            }
+          ],
+          "summaries": [
+            {
+              "title": "<string>",
+              "detail": "<string>"
+            }
+          ],
+          "recommendations": [
+            {
+              "title": "<string>",
+              "detail": "<string>"
+            }
+          ]
+        }
+        """;
+
+    // ── v2/analysis.rules.txt ────────────────────────────────────────────────
+    private const string AnalysisRulesV2 = """
+        - Use only provided input sections as evidence.
+        - Do not invent fields, documents, requirements, or facts.
+        - Prefer, in order: direct evidence from DATA, specific supporting evidence from ATTACHMENTS, then broader context only when necessary.
+        - Treat missing or empty values as findings only when they weaken rubric evidence.
+        - Prefer material findings; avoid nitpicking.
+        - Prefer direct evidence from DATA over derivative statements in ATTACHMENTS when both address the same point.
+        - If ATTACHMENTS evidence is used, cite the attachment by name in detail.
+        - Each detail must cite concrete evidence from DATA or ATTACHMENTS.
+        - Write reviewer-facing natural language. Do not refer to prompt section names, internal field keys, or schema labels such as DATA, ATTACHMENTS, ProjectSummary, CustomField1, or OrganizationType.
+        - Refer to evidence by its plain-language meaning, quoted text, or attachment name rather than internal key names.
+        - Only include warnings when the evidence shows a specific, concrete risk, inconsistency, or meaningful uncertainty; a stated risk label alone is not enough.
+        - Use 3-6 words for title.
+        - Summary titles should name the specific substantive reviewer conclusion, strength, or risk, not a generic evaluation label or abstract category.
+        - Each detail must be 1-2 complete sentences.
+        - Summaries and recommendations must be concrete, distinct, reviewer-relevant, and specific to this application's evidence.
+        - Avoid generic praise, checklist language, and repeated conclusions across lists.
+        - Do not use a summary merely to say that supporting documents were provided; summarize the specific substantive evidence they add, or omit the finding.
+        - If no findings exist, return empty arrays.
+        - Decision must be PROCEED or HOLD.
+        - Use summaries for overall application quality/readiness synthesis.
+        - Use recommendations for concrete reviewer-facing next actions based on the provided evidence.
+        - Recommendations may include proceeding with the normal review process when the application appears ready for that step.
+        - When evidence shows a meaningful gap, inconsistency, or uncertainty, use recommendations for specific follow-up or verification actions.
+        - Return an empty array only when no concrete next action would help the reviewer.
+        """;
+
     // ── v0/attachment.system.txt ─────────────────────────────────────────────
     private const string AttachmentSystemV0 = """
         You are a professional grant analyst for the BC Government.
@@ -373,9 +515,14 @@ Return only conclusions that are directly supported by that evidence.
 
     // ── v1/attachment.system.txt ─────────────────────────────────────────────
     private const string AttachmentSystemV1 = """
-        You are a careful grant review assistant for human reviewers.
-        Summarize the attachment itself, not the overall project.
-        Return a concise reviewer-facing summary.
+        ROLE
+        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
+
+        TASK
+        Using ATTACHMENT, OUTPUT, and RULES:
+        1. Review the attachment to identify what it contains.
+        2. Summarize the attachment itself, not the overall project.
+        3. Return a concise reviewer-facing summary.
         """;
 
     // ── v1/attachment.user.txt ───────────────────────────────────────────────
@@ -400,6 +547,50 @@ Return a concise reviewer-facing summary.
 
     // ── v1/attachment.rules.txt ──────────────────────────────────────────────
     private const string AttachmentRules = """
+        - Use only ATTACHMENT as evidence.
+        - Summarize actual content when ATTACHMENT.text is present; otherwise provide a conservative file-level summary.
+        - Describe the attachment itself rather than summarizing the overall project.
+        - Ensure the summary describes the attachment itself, not the overall project.
+        - If ATTACHMENT.text is primarily structured application, contact, organization, budget, or date fields, summarize it as a metadata-style attachment rather than rewriting it as a generic project summary.
+        - Begin with what the attachment contains or provides, not the file name or file type, unless that metadata is necessary to describe the evidence.
+        - Do not invent missing details.
+        - Do not calculate or restate totals, sums, or aggregates unless they are explicitly present in ATTACHMENT.text.
+        - Write reviewer-facing natural language. Do not refer to prompt section names, internal field keys, or schema labels such as ATTACHMENT or ATTACHMENT.text.
+        - Refer to evidence by its plain-language meaning, quoted text, or file name rather than internal key names.
+        - Write 1-2 complete sentences.
+        - Summary must be grounded in concrete ATTACHMENT evidence.
+        - Return exactly one object with only the key: summary.
+        """;
+
+    // ── v2/attachment.system.txt ─────────────────────────────────────────────
+    private const string AttachmentSystemV2 = """
+        You are a careful grant review assistant for human reviewers.
+        Summarize the attachment itself, not the overall project.
+        Return a concise reviewer-facing summary.
+        """;
+
+    // ── v2/attachment.user.txt ───────────────────────────────────────────────
+    private const string AttachmentUserV2 = """
+        ATTACHMENT
+        {{ATTACHMENT}}
+
+        RESPONSE
+        {{RESPONSE}}
+
+        RULES
+        {{RULES}}
+        {{COMMON_RULES}}
+        """;
+
+    // ── v2/attachment.output.txt ─────────────────────────────────────────────
+    private const string AttachmentOutputV2 = """
+        {
+          "summary": "<string>"
+        }
+        """;
+
+    // ── v2/attachment.rules.txt ──────────────────────────────────────────────
+    private const string AttachmentRulesV2 = """
         - Use only ATTACHMENT as evidence.
         - Summarize actual content when ATTACHMENT.text is present; otherwise provide a conservative file-level summary.
         - Describe the attachment itself rather than summarizing the overall project.
@@ -445,7 +636,7 @@ 3. A confidence score as a decimal fraction from 0.0 to 1.0.
 
         OUTPUT
         {
-          "<question_id>": {
+            "<question_id>": {
             "answer": "<string | number>",
             "rationale": "<evidence-based rationale>",
             "confidence": <decimal 0.0-1.0>
@@ -464,14 +655,75 @@ 3. A confidence score as a decimal fraction from 0.0 to 1.0.
         - Return valid plain JSON only in the exact OUTPUT shape.
         """;
 
-    // ── v1/scoresheet.system.txt ─────────────────────────────────────────────
-    private const string ScoresheetSystemV1 = """
+    // ── v2/scoresheet.system.txt ─────────────────────────────────────────────
+    private const string ScoresheetSystemV2 = """
         You are a careful grant review assistant for human reviewers.
         Answer each question in SECTION using only the provided DATA and ATTACHMENTS.
         Choose the most conservative valid answer supported by the evidence.
         If evidence is incomplete or indirect, explain the uncertainty in the rationale.
         """;
 
+    // ── v2/scoresheet.user.txt ───────────────────────────────────────────────
+    private const string ScoresheetUserV2 = """
+        DATA
+        {{DATA}}
+
+        ATTACHMENTS
+        {{ATTACHMENTS}}
+
+        SECTION
+        {{SECTION}}
+
+        RESPONSE
+        {{RESPONSE}}
+
+        RULES
+        {{RULES}}
+        {{COMMON_RULES}}
+        """;
+
+    // ── v2/scoresheet.output.txt ─────────────────────────────────────────────
+    private const string ScoresheetOutputV2 = """
+        {
+          "<question_id>": {
+            "answer": "<string | number>",
+            "rationale": "<evidence-based rationale>",
+            "confidence": <decimal 0.0-1.0>
+          }
+        }
+        """;
+
+    // ── v2/scoresheet.rules.txt ──────────────────────────────────────────────
+    private const string ScoresheetRulesV2 = """
+        - Use only DATA and ATTACHMENTS as evidence.
+        - Do not invent missing application details.
+        - Prefer direct evidence of the exact condition asked.
+        - If evidence is insufficient, partial, indirect, missing, or non-specific, choose the most conservative valid answer and explain the uncertainty.
+        - Return exactly one answer object per question ID in SECTION.questions.
+        - Do not omit any question IDs from SECTION.questions.
+        - Do not add keys that are not question IDs from SECTION.questions.
+        - Use the exact question IDs from RESPONSE and SECTION.questions without alteration.
+        - Use RESPONSE as the output contract and fill every placeholder value.
+        - Each answer object must include: "answer", "rationale", and "confidence".
+        - Confidence is mandatory for every question and must always be a numeric decimal between 0.0 and 1.0.
+        - The "answer" value type must match question type: Number => numeric; YesNo/SelectList/Text/TextArea => string.
+        """;
+
+    // ── v1/scoresheet.system.txt ─────────────────────────────────────────────
+    private const string ScoresheetSystemV1 = """
+        ROLE
+        You are a careful grant review assistant for human reviewers. Do not fill gaps, assume compliance, or treat relevance as proof.
+
+        TASK
+        Using DATA, ATTACHMENTS, SECTION, RESPONSE, OUTPUT, and RULES:
+        1. Review each question in SECTION one at a time.
+        2. Identify the exact condition the question asks about.
+        3. Consider only the most relevant evidence in DATA and any provided ATTACHMENTS for that condition.
+        4. Choose the most conservative valid answer supported by that evidence.
+        5. If evidence is incomplete or indirect, explain the uncertainty in the rationale.
+        6. Repeat for every question in SECTION.
+        """;
+
     // ── v1/scoresheet.user.txt ───────────────────────────────────────────────
     private const string ScoresheetUserV1 = """
         DATA
@@ -506,8 +758,13 @@ Choose the most conservative valid answer supported by the evidence.
     private const string ScoresheetRules = """
         - Use only DATA and ATTACHMENTS as evidence.
         - Do not invent missing application details.
+        - Ignore fields or details that are not relevant to the specific question being answered.
         - Prefer, in order: direct evidence of the exact condition asked, closely related supporting evidence, then general context only when necessary.
         - If evidence is insufficient, partial, indirect, missing, or non-specific, choose the most conservative valid answer and explain the uncertainty.
+        - Do not convert general project descriptions into evidence for a specific scored condition unless that condition is directly supported.
+        - Treat prefilled labels, ratings, rankings, or statuses as background context only unless the question explicitly asks for that same item.
+        - Do not treat related concepts as equivalent; answer the specific question asked, not a nearby concept.
+        - Do not infer unsupported claims about requirements, conditions, relationships, compliance elements, mitigations, supports, or outcomes.
         - Answer a specific condition positively only when that exact condition is directly evidenced in DATA or ATTACHMENTS.
         - For eligibility, completeness, ownership, location, or compliance questions, do not answer positively unless the exact condition is directly confirmed in the provided evidence.
         - If the evidence shows only involvement, presence, relevance, or association, do not treat that alone as proof that a requirement or condition is satisfied.
@@ -523,6 +780,7 @@ Choose the most conservative valid answer supported by the evidence.
 
     // ── v1/common.rules.txt ──────────────────────────────────────────────────
     private const string CommonRules = """
+        - Any narrative text response must be at least 12 words.
         - If ATTACHMENTS is empty, use DATA only and do not mention missing attachments unless their absence is material to the specific conclusion or question.
         - Return values exactly as specified in OUTPUT.
         - Do not return keys outside OUTPUT.
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index 71a65f57b0..3d54292683 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -95,20 +95,60 @@ await EnsureRequestAndEnqueueAsync(
 
     public async Task QueueAllAIStagesAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null)
     {
-        var requestLock = distributedLockProvider.CreateLock($"ai-generation:{tenantId}:{applicationId}:pipeline");
+        var hasEnabledStage = false;
+        var enqueuedStage = false;
+        UserFriendlyException? lastStageException = null;
 
-        using (await requestLock.AcquireAsync())
+        if (await featureChecker.IsEnabledAsync(AIFeatures.AttachmentSummaries))
         {
-            await EnsureAnyPipelineStageAvailableAsync(applicationId);
-            await aiRateLimiter.EnsureAsync();
+            hasEnabledStage = true;
+            try
+            {
+                await QueueAttachmentSummaryAsync(applicationId, tenantId, promptVersion);
+                enqueuedStage = true;
+            }
+            catch (UserFriendlyException ex)
+            {
+                lastStageException = ex;
+            }
+        }
 
-            await backgroundJobManager.EnqueueAsync(new RunApplicationAIPipelineJobArgs
+        if (await featureChecker.IsEnabledAsync(AIFeatures.ApplicationAnalysis))
+        {
+            hasEnabledStage = true;
+            try
             {
-                ApplicationId = applicationId,
-                PromptVersion = promptVersion,
-                RequestedByUserId = currentUser.Id,
-                TenantId = tenantId
-            });
+                await QueueApplicationAnalysisAsync(applicationId, tenantId, promptVersion);
+                enqueuedStage = true;
+            }
+            catch (UserFriendlyException ex)
+            {
+                lastStageException = ex;
+            }
+        }
+
+        if (await featureChecker.IsEnabledAsync(AIFeatures.Scoring))
+        {
+            hasEnabledStage = true;
+            try
+            {
+                await QueueApplicationScoringAsync(applicationId, tenantId, promptVersion);
+                enqueuedStage = true;
+            }
+            catch (UserFriendlyException ex)
+            {
+                lastStageException = ex;
+            }
+        }
+
+        if (!hasEnabledStage)
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.GenerateAllDisabled]);
+        }
+
+        if (!enqueuedStage && lastStageException != null)
+        {
+            throw lastStageException;
         }
     }
 
@@ -196,58 +236,6 @@ private async Task<AIOperation> ResolveOperationAsync(string operationType)
         return operation;
     }
 
-    private async Task EnsureAnyPipelineStageAvailableAsync(Guid applicationId)
-    {
-        var hasEnabledStage = false;
-        var hasAvailableStage = false;
-        UserFriendlyException? lastPrerequisiteException = null;
-
-        async Task CheckStageAsync(bool isEnabled, Func<Task> ensurePrerequisite)
-        {
-            if (!isEnabled)
-            {
-                return;
-            }
-
-            hasEnabledStage = true;
-
-            try
-            {
-                await ensurePrerequisite();
-                hasAvailableStage = true;
-            }
-            catch (UserFriendlyException ex)
-            {
-                lastPrerequisiteException = ex;
-            }
-        }
-
-        await CheckStageAsync(
-            await featureChecker.IsEnabledAsync(AIFeatures.AttachmentSummaries),
-            () => aiGenerationPrerequisiteValidator.EnsureAttachmentSummaryAvailableAsync(applicationId));
-        await CheckStageAsync(
-            await featureChecker.IsEnabledAsync(AIFeatures.ApplicationAnalysis),
-            () => aiGenerationPrerequisiteValidator.EnsureApplicationAnalysisAvailableAsync(applicationId));
-        await CheckStageAsync(
-            await featureChecker.IsEnabledAsync(AIFeatures.Scoring),
-            () => aiGenerationPrerequisiteValidator.EnsureApplicationScoringAvailableAsync(applicationId));
-
-        if (hasAvailableStage)
-        {
-            return;
-        }
-
-        if (lastPrerequisiteException != null)
-        {
-            throw lastPrerequisiteException;
-        }
-
-        if (!hasEnabledStage)
-        {
-            throw new UserFriendlyException(localizer[AILocalizationKeys.GenerateAllDisabled]);
-        }
-    }
-
     private async Task MarkFailedBestEffortAsync(AIGenerationRequest request, Exception exception)
     {
         try
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
index 13ab940db6..285c5cb2b9 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
@@ -142,12 +142,13 @@ private static async Task<AIOperation> ResolveOperationAsync(
             throw new ArgumentException($"Unknown AI operation type '{operationType}'.", nameof(operationType));
         }
 
-        var operation = await operationRepository.FirstOrDefaultAsync(item =>
+        var operations = await operationRepository.GetListAsync();
+        var operation = operations.FirstOrDefault(item =>
             string.Equals(item.Name, operationName, StringComparison.OrdinalIgnoreCase));
 
         if (operation == null && !string.Equals(operationName, "Default", StringComparison.OrdinalIgnoreCase))
         {
-            operation = await operationRepository.FirstOrDefaultAsync(item =>
+            operation = operations.FirstOrDefault(item =>
                 string.Equals(item.Name, "Default", StringComparison.OrdinalIgnoreCase));
         }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index b980b8bef0..2e0d2ad642 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1249,24 +1249,18 @@ public async Task<AIGenerationStatusDto> GetAIGenerationStatusAsync(Guid applica
     [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
     [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
     [Authorize(AIPermissions.Analysis.GenerateScoring)]
-    public async Task<AIGenerationStatusDto> QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null)
-    {
-        await EnsureAttachmentSummariesEnabledAsync();
-        await EnsureAIAnalysisEnabledAsync();
-        await EnsureScoringEnabledAsync();
-        await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, CurrentTenant.Id, promptVersion);
-
-        var request = await aiGenerationStatusAppService.GetLatestAsync(
-            applicationId,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
-            CurrentTenant.Id);
-
-        if (request == null)
-        {
-            throw new UserFriendlyException("Unable to queue AI generation request.");
-        }
+    public async Task<AIGenerationStatusDto> QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null)
+    {
+        await EnsureAttachmentSummariesEnabledAsync();
+        await EnsureAIAnalysisEnabledAsync();
+        await EnsureScoringEnabledAsync();
+        await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, CurrentTenant.Id, promptVersion);
 
-        return await CreateGenerationStatusAsync(request);
+        return await CreateGenerationStatusAsync(
+            await aiGenerationStatusAppService.GetLatestAsync(
+                applicationId,
+                AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
+                CurrentTenant.Id));
     }
 
     private async Task<AIGenerationStatusDto> CreateGenerationStatusAsync(AIGenerationRequestDto? request)
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
deleted file mode 100644
index e15dec04e2..0000000000
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/DataSeed/AIOperationDataSeederTests.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-using Microsoft.Extensions.Logging;
-using NSubstitute;
-using Shouldly;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using System.Threading.Tasks;
-using System.Threading;
-using Unity.AI;
-using Unity.AI.DataSeed;
-using Unity.AI.Domain;
-using Unity.AI.Prompts;
-using Unity.GrantManager.GrantApplications;
-using Volo.Abp.Data;
-using Volo.Abp.Domain.Repositories;
-using Volo.Abp.MultiTenancy;
-using Xunit;
-
-namespace Unity.GrantManager.AI.DataSeed;
-
-public class AIOperationDataSeederTests
-{
-}
-
-
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index a908313a99..a8c3d9bd1f 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -23,7 +23,7 @@ public async Task Should_Throw_When_Analysis_Operation_Is_Not_Configured()
     {
         var resolver = CreateResolverWithNoOperations();
 
-        await Should.ThrowAsync<Exception>(() =>
+        await Should.ThrowAsync<ArgumentNullException>(() =>
             resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
     }
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
index 3dd410d485..425b88afcc 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
@@ -40,11 +40,25 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        RunApplicationAIPipelineJobArgs? capturedArgs = null;
-        backgroundJobManager.EnqueueAsync<RunApplicationAIPipelineJobArgs>(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+        var attachmentJobs = new List<GenerateAttachmentSummaryBackgroundJobArgs>();
+        var analysisJobs = new List<GenerateApplicationAnalysisBackgroundJobArgs>();
+        var scoringJobs = new List<GenerateApplicationScoringBackgroundJobArgs>();
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
             .Returns(callInfo =>
             {
-                capturedArgs = callInfo.Arg<RunApplicationAIPipelineJobArgs>();
+                attachmentJobs.Add(callInfo.Arg<GenerateAttachmentSummaryBackgroundJobArgs>());
+                return Task.FromResult(string.Empty);
+            });
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+            .Returns(callInfo =>
+            {
+                analysisJobs.Add(callInfo.Arg<GenerateApplicationAnalysisBackgroundJobArgs>());
+                return Task.FromResult(string.Empty);
+            });
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateApplicationScoringBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+            .Returns(callInfo =>
+            {
+                scoringJobs.Add(callInfo.Arg<GenerateApplicationScoringBackgroundJobArgs>());
                 return Task.FromResult(string.Empty);
             });
 
@@ -52,12 +66,12 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Ex
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId, "v1");
 
-        capturedArgs.ShouldNotBeNull();
-        capturedArgs!.ApplicationId.ShouldBe(applicationId);
-        capturedArgs.TenantId.ShouldBe(tenantId);
-        capturedArgs.PromptVersion.ShouldBe("v1");
-        capturedArgs.RequestedByUserId.ShouldBe(CreateQueueCurrentUserId);
-        await backgroundJobManager.Received(1).EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
+        attachmentJobs.Single().ApplicationId.ShouldBe(applicationId);
+        analysisJobs.Single().ApplicationId.ShouldBe(applicationId);
+        scoringJobs.Single().ApplicationId.ShouldBe(applicationId);
+        attachmentJobs.Single().TenantId.ShouldBe(tenantId);
+        analysisJobs.Single().TenantId.ShouldBe(tenantId);
+        scoringJobs.Single().TenantId.ShouldBe(tenantId);
     }
 
     [Fact]
@@ -66,18 +80,35 @@ public async Task QueueAllAIStagesAsync_Should_Enqueue_When_Any_Enabled_Stage_Ha
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
         var backgroundJobManager = Substitute.For<IBackgroundJobManager>();
-        var prerequisiteValidator = Substitute.For<IAIGenerationPrerequisiteValidator>();
-        prerequisiteValidator.EnsureAttachmentSummaryAvailableAsync(applicationId)
-            .Returns<Task>(_ => throw new UserFriendlyException("No attachments are available to summarize."));
-        prerequisiteValidator.EnsureApplicationAnalysisAvailableAsync(applicationId).Returns(Task.CompletedTask);
-        prerequisiteValidator.EnsureApplicationScoringAvailableAsync(applicationId)
-            .Returns<Task>(_ => throw new UserFriendlyException("AI scoring requires a configured scoresheet."));
+        var attachmentJobs = new List<GenerateAttachmentSummaryBackgroundJobArgs>();
+        var analysisJobs = new List<GenerateApplicationAnalysisBackgroundJobArgs>();
+        var scoringJobs = new List<GenerateApplicationScoringBackgroundJobArgs>();
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+            .Returns(callInfo =>
+            {
+                attachmentJobs.Add(callInfo.Arg<GenerateAttachmentSummaryBackgroundJobArgs>());
+                return Task.FromResult(string.Empty);
+            });
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+            .Returns(callInfo =>
+            {
+                analysisJobs.Add(callInfo.Arg<GenerateApplicationAnalysisBackgroundJobArgs>());
+                return Task.FromResult(string.Empty);
+            });
+        backgroundJobManager.EnqueueAsync(Arg.Any<GenerateApplicationScoringBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>())
+            .Returns(callInfo =>
+            {
+                scoringJobs.Add(callInfo.Arg<GenerateApplicationScoringBackgroundJobArgs>());
+                return Task.FromResult(string.Empty);
+            });
 
-        var queue = CreateQueue(backgroundJobManager, prerequisiteValidator: prerequisiteValidator);
+        var queue = CreateQueue(backgroundJobManager);
 
         await queue.QueueAllAIStagesAsync(applicationId, tenantId);
 
-        await backgroundJobManager.Received(1).EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
+        attachmentJobs.Count.ShouldBe(1);
+        analysisJobs.Count.ShouldBe(1);
+        scoringJobs.Count.ShouldBe(1);
     }
 
     [Fact]
@@ -101,7 +132,9 @@ public async Task QueueAllAIStagesAsync_Should_Not_Enqueue_When_No_Enabled_Stage
         await Should.ThrowAsync<UserFriendlyException>(() => queue.QueueAllAIStagesAsync(applicationId, tenantId));
 
         await rateLimiter.DidNotReceive().EnsureAsync();
-        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<RunApplicationAIPipelineJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
+        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateAttachmentSummaryBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
+        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateApplicationAnalysisBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
+        await backgroundJobManager.DidNotReceive().EnqueueAsync(Arg.Any<GenerateApplicationScoringBackgroundJobArgs>(), Arg.Any<BackgroundJobPriority>(), Arg.Any<TimeSpan?>());
     }
 
     [Fact]

From 7868fdf6dfe0a4a438cec9ca3bb69d00bd750730 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 08:41:59 -0700
Subject: [PATCH 33/61] AB#32307 simplify AI queue status handling

---
 .../GrantApplicationAppService.cs             | 18 +++-----
 .../20260624191335_RefreshAiSchema.cs         |  3 --
 .../GrantManagerDbContextModelSnapshot.cs     | 42 +++++++------------
 .../ChefsAttachments/ChefsAttachments.js      |  5 +++
 4 files changed, 25 insertions(+), 43 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 2e0d2ad642..e97823138f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1246,24 +1246,18 @@ public async Task<AIGenerationStatusDto> GetAIGenerationStatusAsync(Guid applica
             await aiGenerationStatusAppService.GetLatestAsync(applicationId, operationType, CurrentTenant.Id));
     }
 
-    [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
-    [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
-    [Authorize(AIPermissions.Analysis.GenerateScoring)]
-    public async Task<AIGenerationStatusDto> QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null)
+    [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
+    [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
+    [Authorize(AIPermissions.Analysis.GenerateScoring)]
+    public async Task QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null)
     {
         await EnsureAttachmentSummariesEnabledAsync();
         await EnsureAIAnalysisEnabledAsync();
         await EnsureScoringEnabledAsync();
         await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, CurrentTenant.Id, promptVersion);
-
-        return await CreateGenerationStatusAsync(
-            await aiGenerationStatusAppService.GetLatestAsync(
-                applicationId,
-                AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType,
-                CurrentTenant.Id));
     }
-
-    private async Task<AIGenerationStatusDto> CreateGenerationStatusAsync(AIGenerationRequestDto? request)
+
+    private async Task<AIGenerationStatusDto> CreateGenerationStatusAsync(AIGenerationRequestDto? request)
     {
         var state = await aiRateLimiter.GetStateAsync();
         return new AIGenerationStatusDto
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 6bbf6783e9..01dcff2f33 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -148,9 +148,6 @@ ADD CONSTRAINT "FK_AIOperations_AIPrompts_AIPromptId"
                     "StartedAt" timestamp without time zone NULL,
                     "CompletedAt" timestamp without time zone NULL,
                     "FailureReason" character varying(2000) NULL,
-                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
-                    "DeleterId" uuid NULL,
-                    "DeletionTime" timestamp without time zone NULL,
                     "ExtraProperties" text NOT NULL,
                     "ConcurrencyStamp" character varying(40) NOT NULL,
                     "CreationTime" timestamp without time zone NOT NULL,
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
index cdb77730bb..4f39d395ab 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/GrantManagerDbContextModelSnapshot.cs
@@ -708,8 +708,8 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<Guid>("Id")
                         .HasColumnType("uuid");
 
-                    b.Property<Guid?>("ApplicationId")
-                        .HasColumnType("uuid");
+                    b.Property<Guid>("ApplicationId")
+                        .HasColumnType("uuid");
 
                     b.Property<DateTime?>("CompletedAt")
                         .HasColumnType("timestamp without time zone");
@@ -729,37 +729,23 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("CreatorId");
 
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
+                    b.Property<string>("ExtraProperties")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("ExtraProperties");
 
                     b.Property<string>("FailureReason")
                         .HasMaxLength(2000)
                         .HasColumnType("character varying(2000)");
 
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
+                    b.Property<DateTime?>("LastModificationTime")
+                        .HasColumnType("timestamp without time zone")
+                        .HasColumnName("LastModificationTime");
+
+                    b.Property<Guid?>("LastModifierId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("LastModifierId");
+
                     b.Property<Guid>("OperationId")
                         .HasColumnType("uuid");
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
index ced5ca82ba..a1d0f2e627 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
@@ -240,6 +240,11 @@ $(function () {
     }
 
     function pollAttachmentSummaryGeneration(applicationId, $button) {
+        if (!globalThis.AIGenerationButtonState?.monitor) {
+            console.error('AIGenerationButtonState is not available; cannot poll attachment summary generation.');
+            return;
+        }
+
         globalThis.AIGenerationButtonState.monitor({
             $button,
             originalHtml: $button.html(),

From c7e31c641cd1fa7d8cdc6e9046691fa9064ccb8b Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 09:00:20 -0700
Subject: [PATCH 34/61] AB#32307 tighten ai authorization and resolver errors

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs               | 6 +-----
 .../Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs | 3 +++
 .../Generation/AIGenerationAppService.cs                    | 6 +++---
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index 5b3cc353f9..2c3eb74f5a 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -20,7 +20,6 @@ public class OpenAIConfigurationResolver(
     IConfiguration configuration,
     IDataFilter<IMultiTenant> multiTenantDataFilter) : ITransientDependency
 {
-    private const string DefaultOperationName = "Default";
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
         PropertyNameCaseInsensitive = true
@@ -202,8 +201,6 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
     private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
         var operations = await _operationRepository.GetListAsync();
-        var activeOperations = operations.Where(operation => operation.IsActive).ToList();
-
         var configuredOperation = operations.FirstOrDefault(operation =>
             string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
         if (configuredOperation != null)
@@ -216,8 +213,7 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
             return configuredOperation;
         }
 
-        return activeOperations.FirstOrDefault(operation =>
-            string.Equals(operation.Name, DefaultOperationName, StringComparison.OrdinalIgnoreCase));
+        return null;
     }
 
     private static AIModelSettings ResolveModelSettings(AIModel model)
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
index 0c340061c7..0968c7dd03 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIRuntimeService.cs
@@ -122,6 +122,7 @@ public async Task<ApplicationAnalysisResponse> GenerateApplicationAnalysisAsync(
             }
             catch (Exception ex)
             {
+                _logger.LogError(ex, "Application analysis generation failed.");
                 throw;
             }
         }
@@ -188,6 +189,7 @@ public async Task<AttachmentSummaryResponse> GenerateAttachmentSummaryAsync(Atta
             }
             catch (Exception ex)
             {
+                _logger.LogError(ex, "Attachment summary generation failed for {FileName}.", fileName);
                 return new AttachmentSummaryResponse
                 {
                     Summary = $"AI analysis not available for this attachment ({fileName})."
@@ -261,6 +263,7 @@ public async Task<ApplicationScoringResponse> GenerateApplicationScoringAsync(Ap
             }
             catch (Exception ex)
             {
+                _logger.LogError(ex, "Application scoring generation failed for section {SectionName}.", request.SectionName);
                 return new ApplicationScoringResponse();
             }
         }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index dd243aa279..2a0a652613 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -71,9 +71,9 @@ await featureGuard.EnsureEnabledAsync(
         return new ApplicationScoringResultDto { Completed = false };
     }
 
-    [Authorize(AIPermissions.Analysis.ViewAttachmentSummary)]
-    [Authorize(AIPermissions.Analysis.ViewApplicationAnalysis)]
-    [Authorize(AIPermissions.Analysis.ViewScoringResult)]
+    [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
+    [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
+    [Authorize(AIPermissions.Analysis.GenerateScoring)]
     [HttpPost("all")]
     public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid applicationId, string? promptVersion = null)
     {

From 076c75f80a9609ed95537a3d56b7b67bdbc56ad8 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 09:30:22 -0700
Subject: [PATCH 35/61] AB#32307 tighten AI generation and configuration access

---
 .../Generation/AIGenerationAppService.cs              |  8 +-------
 .../Settings/AIConfigurationAppService.cs             |  1 +
 .../GrantApplications/IGrantApplicationAppService.cs  |  2 +-
 .../AI/Runtime/OpenAIConfigurationResolverTests.cs    | 11 +++++------
 .../Automation/AIGenerationAppServiceTests.cs         | 10 ++--------
 5 files changed, 10 insertions(+), 22 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index 2a0a652613..5e70adbbc9 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -77,13 +77,7 @@ await featureGuard.EnsureEnabledAsync(
     [HttpPost("all")]
     public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid applicationId, string? promptVersion = null)
     {
-        await featureGuard.EnsureEnabledAsync(AIFeatures.AttachmentSummaries, AILocalizationKeys.GenerateAllDisabled);
-        await featureGuard.EnsureEnabledAsync(AIFeatures.ApplicationAnalysis, AILocalizationKeys.GenerateAllDisabled);
-        await featureGuard.EnsureEnabledAsync(AIFeatures.Scoring, AILocalizationKeys.GenerateAllDisabled);
-
-        await aiGenerationQueue.QueueAttachmentSummaryAsync(applicationId, currentTenant.Id, promptVersion);
-        await aiGenerationQueue.QueueApplicationAnalysisAsync(applicationId, currentTenant.Id, promptVersion);
-        await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, currentTenant.Id, promptVersion);
+        await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, currentTenant.Id, promptVersion);
 
         return new ApplicationContentResultDto { Completed = false };
     }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Settings/AIConfigurationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Settings/AIConfigurationAppService.cs
index df2d32a605..f7bca0af75 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Settings/AIConfigurationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Settings/AIConfigurationAppService.cs
@@ -18,6 +18,7 @@ public class AIConfigurationAppService(
     private readonly ISettingManager _settingManager = settingManager;
     private readonly ICurrentTenant _currentTenant = currentTenant;
 
+    [Authorize(AIPermissions.Configuration.ConfigureAI)]
     [HttpGet("tenant")]
     public virtual async Task<AITenantConfigurationDto> GetTenantConfigurationAsync()
     {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
index 2b6421fd8a..1cdfd87543 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
@@ -23,7 +23,7 @@ public interface IGrantApplicationAppService
     Task<AIGenerationStatusDto> QueueAttachmentSummaryAsync(QueueAttachmentSummaryRequestDto input, string? promptVersion = null);
     Task<AIGenerationStatusDto> QueueApplicationScoringAsync(Guid applicationId, string? promptVersion = null);
     Task<AIGenerationStatusDto> GetAIGenerationStatusAsync(Guid applicationId, string operationType, string? promptVersion = null);
-    Task<AIGenerationStatusDto> QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null);
+    Task QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null);
     Task<Guid?> GetAccountCodingIdFromFormIdAsync(Guid formId);
     Task<string> DismissAIAnalysisItemAsync(Guid applicationId, string itemId);
     Task<string> RestoreAIAnalysisItemAsync(Guid applicationId, string itemId);
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index 067b5525b8..7d64501c80 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -22,7 +22,7 @@ namespace Unity.GrantManager.AI.Runtime;
 public class OpenAIConfigurationResolverTests
 {
     [Fact]
-    public async Task Should_Throw_When_Operation_Is_Missing()
+    public async Task Should_Resolve_Operation_From_Default_When_Named_Operation_Is_Present()
     {
         var resolver = CreateResolver();
 
@@ -109,7 +109,7 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
     }
 
     [Fact]
-    public async Task Should_Fallback_To_Default_Operation_When_Override_Is_Missing()
+    public async Task Should_Throw_When_Operation_Is_Missing()
     {
         var modelRepository = Substitute.For<IRepository<AIModel, Guid>>();
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
@@ -174,11 +174,10 @@ public async Task Should_Fallback_To_Default_Operation_When_Override_Is_Missing(
             operationRepository,
             promptRepository);
 
-        var settings = await resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis);
+        var exception = await Should.ThrowAsync<InvalidOperationException>(
+            () => resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
 
-        settings.ProviderName.ShouldBe("OpenAI");
-        settings.PromptVersion.ShouldBe("v1");
-        settings.CompletionTokens.ShouldBe(2000);
+        exception.Message.ShouldContain("AI operation 'ApplicationAnalysis' is not configured.");
     }
 
     [Fact]
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
index b67591f382..10a8a799f7 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
@@ -32,11 +32,7 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
         var featureGuard = new AIFeatureGuard(featureChecker, localizer);
 
         var queue = Substitute.For<IApplicationAIGenerationQueue>();
-        queue.QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>())
-            .Returns(Task.CompletedTask);
-        queue.QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
-            .Returns(Task.CompletedTask);
-        queue.QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
+        queue.QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
             .Returns(Task.CompletedTask);
         var currentTenant = Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>();
         currentTenant.Id.Returns(Guid.NewGuid());
@@ -50,9 +46,7 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
 
         result.ShouldNotBeNull();
         result.Completed.ShouldBeFalse();
-        await queue.Received(1).QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>());
-        await queue.Received(1).QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
-        await queue.Received(1).QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
+        await queue.Received(1).QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
     }
 
     [Fact]

From 32f98f82a0f5fd1ef07d3eb9a98340a68c3d6b2b Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 09:44:45 -0700
Subject: [PATCH 36/61] AB#32307 restore partial AI generation support

---
 .../GrantApplications/GrantApplicationAppService.cs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index e97823138f..01e8177df6 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1175,11 +1175,11 @@ await LocalEventBus.PublishAsync(
         return applicationManager.GetWorkflowDiagram(isDirectApproval);
     }
 
-    public async Task<AIGenerationStatusDto> QueueAIGenerationAsync(Guid applicationId, string? promptVersion = null)
-    {
-        await EnsureAIAnalysisEnabledAsync();
-        return await QueueApplicationAnalysisAsync(applicationId, promptVersion);
-    }
+    [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
+    public async Task<AIGenerationStatusDto> QueueAIGenerationAsync(Guid applicationId, string? promptVersion = null)
+    {
+        return await QueueApplicationAnalysisAsync(applicationId, promptVersion);
+    }
 
     [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
     public async Task<AIGenerationStatusDto> QueueApplicationAnalysisAsync(Guid applicationId, string? promptVersion = null)
@@ -1251,9 +1251,6 @@ public async Task<AIGenerationStatusDto> GetAIGenerationStatusAsync(Guid applica
     [Authorize(AIPermissions.Analysis.GenerateScoring)]
     public async Task QueueAllAIStagesAsync(Guid applicationId, string? promptVersion = null)
     {
-        await EnsureAttachmentSummariesEnabledAsync();
-        await EnsureAIAnalysisEnabledAsync();
-        await EnsureScoringEnabledAsync();
         await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, CurrentTenant.Id, promptVersion);
     }
 

From 26cbb8efcffa72a4e09dd709e4c23c2a57372b7e Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 09:59:52 -0700
Subject: [PATCH 37/61] AB#32307 make AI queue async and fail fast

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs  |  2 +-
 .../Automation/ApplicationAIGenerationQueue.cs | 18 +++++++++---------
 .../Automation/AIGenerationQueueTests.cs       | 11 ++++++++++-
 3 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index 2c3eb74f5a..de37e7213b 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -200,7 +200,7 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
 
     private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
-        var operations = await _operationRepository.GetListAsync();
+        var operations = await _operationRepository.GetListAsync(cancellationToken: cancellationToken);
         var configuredOperation = operations.FirstOrDefault(operation =>
             string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
         if (configuredOperation != null)
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index 3d54292683..334016b809 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -18,6 +18,7 @@
 using Volo.Abp.BackgroundJobs;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Features;
+using Volo.Abp.Linq;
 using Volo.Abp.Users;
 
 namespace Unity.GrantManager.GrantApplications.Automation;
@@ -30,11 +31,13 @@ public class ApplicationAIGenerationQueue(
     IAIGenerationPrerequisiteValidator aiGenerationPrerequisiteValidator,
     IFeatureChecker featureChecker,
     IAIRateLimiter aiRateLimiter,
+    IAsyncQueryableExecuter asyncQueryableExecuter,
     ICurrentUser currentUser,
     ILogger<ApplicationAIGenerationQueue> logger,
     IStringLocalizer<AIResource> localizer)
     : IApplicationAIGenerationQueue, ITransientDependency
 {
+    private readonly IAsyncQueryableExecuter _asyncQueryableExecuter = asyncQueryableExecuter;
     public async Task QueueAttachmentSummaryAsync(Guid applicationId, Guid? tenantId, string? promptVersion = null, List<Guid>? attachmentIds = null)
     {
         await EnsureRequestAndEnqueueAsync(
@@ -171,10 +174,10 @@ private async Task EnsureRequestAndEnqueueAsync(
                 && x.OperationId == operation.Id
                 && (x.Status == AIGenerationRequestStatus.Queued || x.Status == AIGenerationRequestStatus.Running));
 
-            var existing = existingRequests
-                .OrderByDescending(x => x.CreationTime)
-                .ThenByDescending(x => x.Id)
-                .FirstOrDefault();
+            var existing = await _asyncQueryableExecuter.FirstOrDefaultAsync(
+                existingRequests
+                    .OrderByDescending(x => x.CreationTime)
+                    .ThenByDescending(x => x.Id));
 
             if (existing != null)
             {
@@ -215,13 +218,10 @@ private async Task<AIOperation> ResolveOperationAsync(string operationType)
     {
         var operationName = ResolveOperationName(operationType);
         var operations = await operationRepository.GetQueryableAsync();
-        var allOperations = (operations ?? Enumerable.Empty<AIOperation>())
-            .ToList();
+        var allOperations = await _asyncQueryableExecuter.ToListAsync(operations);
 
         var operation = allOperations.FirstOrDefault(operation =>
-            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
-            ?? allOperations.FirstOrDefault(operation =>
-                string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
+            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
 
         if (operation == null)
         {
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
index 425b88afcc..dc40cfb149 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
@@ -21,6 +21,7 @@
 using Volo.Abp.DistributedLocking;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Features;
+using Volo.Abp.Linq;
 using Volo.Abp.Users;
 using Xunit;
 using Xunit.Abstractions;
@@ -351,7 +352,8 @@ private static ApplicationAIGenerationQueue CreateQueue(
         IAIRateLimiter? rateLimiter = null,
         IAIGenerationPrerequisiteValidator? prerequisiteValidator = null,
         IFeatureChecker? featureChecker = null,
-        IRepository<AIOperation, Guid>? operationRepository = null)
+        IRepository<AIOperation, Guid>? operationRepository = null,
+        IAsyncQueryableExecuter? asyncQueryableExecuter = null)
     {
         repository ??= Substitute.For<IRepository<AIGenerationRequest, Guid>>();
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(Array.Empty<AIGenerationRequest>().AsQueryable()));
@@ -378,6 +380,12 @@ private static ApplicationAIGenerationQueue CreateQueue(
             featureChecker.IsEnabledAsync(AIFeatures.Scoring).Returns(Task.FromResult(true));
         }
 
+        asyncQueryableExecuter ??= Substitute.For<IAsyncQueryableExecuter>();
+        asyncQueryableExecuter.ToListAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().ToList()));
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIGenerationRequest>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIGenerationRequest>>().FirstOrDefault()));
+
         return new ApplicationAIGenerationQueue(
             backgroundJobManager,
             repository,
@@ -386,6 +394,7 @@ private static ApplicationAIGenerationQueue CreateQueue(
             prerequisiteValidator,
             featureChecker,
             rateLimiter,
+            asyncQueryableExecuter,
             CreateCurrentUser(),
             Substitute.For<ILogger<ApplicationAIGenerationQueue>>(),
             Substitute.For<IStringLocalizer<AIResource>>());

From 23cc6e35f741a085ec68908d1cc8f2c168c2bc21 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 10:17:58 -0700
Subject: [PATCH 38/61] AB#32307 fix tenant search and ppt slide logging

---
 .../AI/Extraction/TextExtractionService.cs                   | 3 ++-
 .../Unity.TenantManagement.Application/TenantAppService.cs   | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
index 10cfaf30f8..b2a463f95f 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Extraction/TextExtractionService.cs
@@ -554,8 +554,9 @@ private List<string> TryGetPowerPointSlideOrder(ZipArchive archive)
                     .Cast<string>()
                     .ToList();
             }
-            catch (Exception)
+            catch (Exception ex)
             {
+                _logger.LogDebug(ex, "Could not determine PowerPoint slide order from relationships; falling back to part-name order.");
                 return new List<string>();
             }
         }
diff --git a/applications/Unity.GrantManager/modules/Unity.TenantManagement/src/Unity.TenantManagement.Application/TenantAppService.cs b/applications/Unity.GrantManager/modules/Unity.TenantManagement/src/Unity.TenantManagement.Application/TenantAppService.cs
index 4d1e1b01b2..622fb67df5 100644
--- a/applications/Unity.GrantManager/modules/Unity.TenantManagement/src/Unity.TenantManagement.Application/TenantAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.TenantManagement/src/Unity.TenantManagement.Application/TenantAppService.cs
@@ -84,10 +84,11 @@ public virtual async Task<PagedResultDto<TenantDto>> GetListAsync(GetTenantsInpu
         }
 
         // In-memory path: needed when filtering on ExtraProperties or sorting on ExtraProperties
+        // Keep native name filtering in SQL and only layer ExtraProperties matching on top.
         var dbSorting = dbSortFields.Contains(sortField) ? input.Sorting : nameof(Tenant.Name);
-        var allTenants = await tenantRepository.GetListAsync(dbSorting, int.MaxValue, 0, null);
+        var filteredTenants = await tenantRepository.GetListAsync(dbSorting, int.MaxValue, 0, input.Filter);
 
-        IEnumerable<Tenant> result = allTenants;
+        IEnumerable<Tenant> result = filteredTenants;
 
         // Apply ExtraProperties filter
         if (hasFilter)

From 2a9a53d3dfdaf0c25b4fb85734cff200e7aeefe8 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 10:41:35 -0700
Subject: [PATCH 39/61] AB#32307 refine ai permissions and rate limiting

---
 .../AIPermissionDefinitionProvider.cs         | 89 +++++++++----------
 .../Permissions/AIPermissions.cs              |  1 +
 .../AI/Runtime/OpenAIConfigurationResolver.cs |  2 +-
 .../Generation/AIGenerationAppService.cs      | 34 ++++++-
 .../RateLimit/AIRateLimiter.cs                |  2 +
 .../Assessments/AssessmentAppService.cs       |  4 +-
 .../GrantApplicationAppService.cs             |  8 +-
 .../AI/RateLimit/AIRateLimiterTests.cs        |  2 +-
 .../Automation/AIGenerationAppServiceTests.cs | 12 ++-
 9 files changed, 95 insertions(+), 59 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
index e555345b1c..e0191840be 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
@@ -10,60 +10,59 @@ public class AIPermissionDefinitionProvider : PermissionDefinitionProvider
 {
     public override void Define(IPermissionDefinitionContext context)
     {
-            // AI Permission Group
-            var aiPermissionsGroup = context.AddGroup(
-                AIPermissions.GroupName,
-                L("Permission:AI"));
+        // AI Permission Group
+        var aiPermissionsGroup = context.AddGroup(
+            AIPermissions.GroupName,
+            L("Permission:AI"));
 
+        var aiReporting = aiPermissionsGroup.AddPermission(
+            AIPermissions.Reporting.ReportingDefault,
+            L("Permission:AI.Reporting"))
+            .RequireFeatures("Unity.AIReporting");
 
-            var aiReporting = aiPermissionsGroup.AddPermission(
-                AIPermissions.Reporting.ReportingDefault,
-                L("Permission:AI.Reporting"))
-                .RequireFeatures("Unity.AIReporting");
+        aiReporting.AddChild(
+            AIPermissions.Reporting.CreateEditDataModel,
+            L("Permission:AI.Reporting.CreateEditDataModel"))
+            .RequireFeatures("Unity.AIReporting");
 
-            aiReporting.AddChild(
-                AIPermissions.Reporting.CreateEditDataModel,
-                L("Permission:AI.Reporting.CreateEditDataModel"))
-                .RequireFeatures("Unity.AIReporting");
+        var viewApplicationAnalysis = aiPermissionsGroup.AddPermission(
+            AIPermissions.Analysis.ViewApplicationAnalysis,
+            L("Permission:AI.ViewApplicationAnalysis"))
+            .RequireFeatures("Unity.AI.ApplicationAnalysis");
 
-            var viewApplicationAnalysis = aiPermissionsGroup.AddPermission(
-                AIPermissions.Analysis.ViewApplicationAnalysis,
-                L("Permission:AI.ViewApplicationAnalysis"))
-                .RequireFeatures("Unity.AI.ApplicationAnalysis");
+        viewApplicationAnalysis.AddChild(
+            AIPermissions.Analysis.GenerateApplicationAnalysis,
+            L("Permission:AI.GenerateApplicationAnalysis"))
+            .RequireFeatures("Unity.AI.ApplicationAnalysis");
 
-            viewApplicationAnalysis.AddChild(
-                AIPermissions.Analysis.GenerateApplicationAnalysis,
-                L("Permission:AI.GenerateApplicationAnalysis"))
-                .RequireFeatures("Unity.AI.ApplicationAnalysis");
+        var viewAttachmentSummary = aiPermissionsGroup.AddPermission(
+            AIPermissions.Analysis.ViewAttachmentSummary,
+            L("Permission:AI.ViewAttachmentSummary"))
+            .RequireFeatures("Unity.AI.AttachmentSummaries");
 
-            var viewAttachmentSummary = aiPermissionsGroup.AddPermission(
-                AIPermissions.Analysis.ViewAttachmentSummary,
-                L("Permission:AI.ViewAttachmentSummary"))
-                .RequireFeatures("Unity.AI.AttachmentSummaries");
+        viewAttachmentSummary.AddChild(
+            AIPermissions.Analysis.GenerateAttachmentSummaries,
+            L("Permission:AI.GenerateAttachmentSummaries"))
+            .RequireFeatures("Unity.AI.AttachmentSummaries");
 
-            viewAttachmentSummary.AddChild(
-                AIPermissions.Analysis.GenerateAttachmentSummaries,
-                L("Permission:AI.GenerateAttachmentSummaries"))
-                .RequireFeatures("Unity.AI.AttachmentSummaries");
+        var viewScoringResult = aiPermissionsGroup.AddPermission(
+            AIPermissions.Analysis.ViewScoringResult,
+            L("Permission:AI.ViewScoringResult"))
+            .RequireFeatures("Unity.AI.Scoring");
 
-            var viewScoringResult = aiPermissionsGroup.AddPermission(
-                AIPermissions.Analysis.ViewScoringResult,
-                L("Permission:AI.ViewScoringResult"))
-                .RequireFeatures("Unity.AI.Scoring");
+        viewScoringResult.AddChild(
+            AIPermissions.Analysis.GenerateScoring,
+            L("Permission:AI.GenerateScoring"))
+            .RequireFeatures("Unity.AI.Scoring");
 
-            viewScoringResult.AddChild(
-                AIPermissions.Analysis.GenerateScoring,
-                L("Permission:AI.GenerateScoring"))
-                .RequireFeatures("Unity.AI.Scoring");
-
-            var settingManagement = context.GetGroup(SettingManagementPermissions.GroupName);
-            var configureAI = settingManagement.AddPermission(
-                AIPermissions.Configuration.ConfigureAI,
-                L("Permission:AI.ConfigureAI"));
-            configureAI.StateCheckers.Add(new AnyFeaturePermissionStateProvider(
-                "Unity.AI.Scoring",
-                "Unity.AI.AttachmentSummaries",
-                "Unity.AI.ApplicationAnalysis"));
+        var settingManagement = context.GetGroup(SettingManagementPermissions.GroupName);
+        var configureAI = settingManagement.AddPermission(
+            AIPermissions.Configuration.ConfigureAI,
+            L("Permission:AI.ConfigureAI"));
+        configureAI.StateCheckers.Add(new AnyFeaturePermissionStateProvider(
+            "Unity.AI.Scoring",
+            "Unity.AI.AttachmentSummaries",
+            "Unity.AI.ApplicationAnalysis"));
 
     }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
index b9ea59607f..aef7861607 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
@@ -21,6 +21,7 @@ public static class Analysis
         public const string GenerateApplicationAnalysis = GroupName + ".GenerateApplicationAnalysis";
         public const string GenerateAttachmentSummaries = GroupName + ".GenerateAttachmentSummaries";
         public const string GenerateScoring             = GroupName + ".GenerateScoring";
+        public const string GenerateAll                 = GroupName + ".GenerateAll";
     }
 
     public static class Configuration
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index de37e7213b..f5cedd4752 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -229,7 +229,7 @@ private static AIModelSettings ResolveModelSettings(AIModel model)
 
     private async Task<AIModel?> ResolveModelAsync(string? modelName, CancellationToken cancellationToken)
     {
-        var activeModels = await _modelRepository.GetListAsync(model => model.IsActive);
+        var activeModels = await _modelRepository.GetListAsync(model => model.IsActive, cancellationToken: cancellationToken);
         if (activeModels.Count == 0)
         {
             return null;
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index 5e70adbbc9..0c0fadf254 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -13,6 +13,8 @@
 using Unity.GrantManager.Attachments;
 using Unity.GrantManager.GrantApplications;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp;
+using Volo.Abp.Features;
 
 namespace Unity.AI.Generation;
 
@@ -20,9 +22,12 @@ namespace Unity.AI.Generation;
 public class AIGenerationAppService(
     IApplicationAIGenerationQueue aiGenerationQueue,
     AIFeatureGuard featureGuard,
+    IFeatureChecker featureChecker,
     ICurrentTenant currentTenant)
     : AIAppService, IAIGenerationAppService
 {
+    private readonly IFeatureChecker _featureChecker = featureChecker;
+
     [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
     [HttpPost("attachment-summary")]
     public virtual async Task<List<AttachmentSummaryResultDto>> GenerateAttachmentSummariesAsync(GenerateAttachmentSummariesInputDto input)
@@ -71,13 +76,34 @@ await featureGuard.EnsureEnabledAsync(
         return new ApplicationScoringResultDto { Completed = false };
     }
 
-    [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
-    [Authorize(AIPermissions.Analysis.GenerateApplicationAnalysis)]
-    [Authorize(AIPermissions.Analysis.GenerateScoring)]
+    [Authorize(AIPermissions.Analysis.GenerateAll)]
     [HttpPost("all")]
     public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid applicationId, string? promptVersion = null)
     {
-        await aiGenerationQueue.QueueAllAIStagesAsync(applicationId, currentTenant.Id, promptVersion);
+        var hasQueuedStage = false;
+
+        if (await _featureChecker.IsEnabledAsync(AIFeatures.AttachmentSummaries))
+        {
+            await aiGenerationQueue.QueueAttachmentSummaryAsync(applicationId, currentTenant.Id, promptVersion);
+            hasQueuedStage = true;
+        }
+
+        if (await _featureChecker.IsEnabledAsync(AIFeatures.ApplicationAnalysis))
+        {
+            await aiGenerationQueue.QueueApplicationAnalysisAsync(applicationId, currentTenant.Id, promptVersion);
+            hasQueuedStage = true;
+        }
+
+        if (await _featureChecker.IsEnabledAsync(AIFeatures.Scoring))
+        {
+            await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, currentTenant.Id, promptVersion);
+            hasQueuedStage = true;
+        }
+
+        if (!hasQueuedStage)
+        {
+            throw new UserFriendlyException(AILocalizationKeys.GenerateAllDisabled);
+        }
 
         return new ApplicationContentResultDto { Completed = false };
     }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
index 2f0f06f309..2043986adf 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
@@ -59,6 +59,8 @@ public virtual async Task EnsureAsync()
                 throw new UserFriendlyException(
                     $"AI generation is rate limited. Try again in {remaining} second{(remaining == 1 ? "" : "s")}.");
             }
+
+            await StampAsync(userId, CooldownSeconds);
         }
     }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/Assessments/AssessmentAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/Assessments/AssessmentAppService.cs
index ae1a206917..cca9d11cb8 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/Assessments/AssessmentAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/Assessments/AssessmentAppService.cs
@@ -93,7 +93,7 @@ public async Task<AssessmentDisplayListDto> GetDisplayList(Guid applicationId)
 
             // If AI Scoring feature is disabled or user lacks permission, filter out AI assessments
             var aiScoringEnabled = await _featureChecker.IsEnabledAsync("Unity.AI.Scoring");
-            var canViewAI = await AuthorizationService.IsGrantedAsync(AIPermissions.Analysis.ViewScoringResult);
+            var canViewAI = await AuthorizationService.IsGrantedAsync(AIPermissions.Analysis.ViewScoringResult);
             assessmentList = assessmentList
                 .Where(a => !a.IsAiAssessment || (aiScoringEnabled && canViewAI))
                 .OrderByDescending(a => a.IsAiAssessment)
@@ -394,7 +394,7 @@ public async Task UpdateAssessmentScore(AssessmentScoresDto dto)
         /// <exception cref="BusinessException">
         /// Thrown when the specified assessment is not an AI assessment.
         /// </exception>
-        [Authorize(AIPermissions.Analysis.ViewScoringResult)]
+        [Authorize(AIPermissions.Analysis.ViewScoringResult)]
         public async Task<AssessmentDto> CloneFromAiAsync(Guid aiAssessmentId)
         {
             if (!await _featureChecker.IsEnabledAsync("Unity.AI.Scoring"))
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 01e8177df6..42e99216cc 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1273,15 +1273,15 @@ private async Task EnsureAIGenerationStatusAccessAsync(string operationType)
                 await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
                 return;
             case AIGenerationRequestKeyHelper.AttachmentSummaryOperationType:
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
+        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
                 return;
             case AIGenerationRequestKeyHelper.ApplicationScoringOperationType:
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
+        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
                 return;
             case AIGenerationRequestKeyHelper.PipelineOperationType:
                 await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
+        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
+        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
                 return;
             default:
                 throw new UserFriendlyException("Unknown AI generation operation type.");
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
index ab35d12f62..60517dd481 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
@@ -73,7 +73,7 @@ public async Task EnsureAsync_AllowsThrough_When_NoCooldown()
     {
         await NewLimiter().EnsureAsync();
         var state = await NewLimiter().GetStateAsync();
-        state.RetryAfterSeconds.ShouldBe(0);
+        state.RetryAfterSeconds.ShouldBeInRange(1, 60);
     }
 
     [Fact]
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
index 10a8a799f7..03e0d3639d 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
@@ -32,7 +32,11 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
         var featureGuard = new AIFeatureGuard(featureChecker, localizer);
 
         var queue = Substitute.For<IApplicationAIGenerationQueue>();
-        queue.QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
+        queue.QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>())
+            .Returns(Task.CompletedTask);
+        queue.QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
+            .Returns(Task.CompletedTask);
+        queue.QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
             .Returns(Task.CompletedTask);
         var currentTenant = Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>();
         currentTenant.Id.Returns(Guid.NewGuid());
@@ -40,13 +44,16 @@ public async Task GenerateContentAsync_Should_Return_Completed_Result()
         var service = new AIGenerationAppService(
             queue,
             featureGuard,
+            featureChecker,
             currentTenant);
 
         var result = await service.GenerateContentAsync(Guid.NewGuid());
 
         result.ShouldNotBeNull();
         result.Completed.ShouldBeFalse();
-        await queue.Received(1).QueueAllAIStagesAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
+        await queue.Received(1).QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>());
+        await queue.Received(1).QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
+        await queue.Received(1).QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
     }
 
     [Fact]
@@ -63,6 +70,7 @@ public async Task GenerateAttachmentSummariesAsync_Should_Validate_Against_Appli
         var service = new AIGenerationAppService(
             Substitute.For<IApplicationAIGenerationQueue>(),
             featureGuard,
+            featureChecker,
             Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>());
 
         var result = await service.GenerateAttachmentSummariesAsync(new GenerateAttachmentSummariesInputDto

From 3d74deeb814d848545924c0cddb1e25e2d2589f1 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 10:48:21 -0700
Subject: [PATCH 40/61] AB#32307 virtualize prompt lookup app service

---
 .../src/Unity.AI.Application/Prompts/AIPromptAppService.cs      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
index de45c9b88e..e5a58be358 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
@@ -41,7 +41,7 @@ public AIPromptAppService(
     }
 
     [HttpGet("by-prompt/{promptId}")]
-    public async Task<ListResultDto<AIPromptDto>> GetByPromptAsync(Guid promptId)
+    public virtual async Task<ListResultDto<AIPromptDto>> GetByPromptAsync(Guid promptId)
     {
         using (_multiTenantDataFilter.Disable())
         {

From 103f53aaa2988fb0cbd8c01abbc2503fe4a05dd3 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 11:14:30 -0700
Subject: [PATCH 41/61] AB#32307 support v2 AI prompt versions

---
 .../AI/Runtime/OpenAIPromptRenderer.cs           | 16 +++++-----------
 .../src/Unity.AI.Web/Pages/Prompts/Index.js      |  8 ++++----
 .../AI/Runtime/OpenAIPromptRendererTests.cs      |  2 ++
 3 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIPromptRenderer.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIPromptRenderer.cs
index 64511fd9c9..9080271150 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIPromptRenderer.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIPromptRenderer.cs
@@ -7,15 +7,6 @@ namespace Unity.AI.Runtime;
 
 public class OpenAIPromptRenderer : ITransientDependency
 {
-    private const string PromptVersionV0 = "v0";
-    private const string PromptVersionV1 = "v1";
-    private static readonly Dictionary<string, string> PromptProfiles =
-        new(StringComparer.Ordinal)
-        {
-            [PromptVersionV0] = PromptVersionV0,
-            [PromptVersionV1] = PromptVersionV1
-        };
-
     public static string BuildApplicationScoringResponseTemplate(string sectionPayloadJson)
     {
         try
@@ -131,9 +122,12 @@ public static string ResolvePromptVersion(string? version)
             throw new InvalidOperationException("AI prompt version is not configured.");
         }
 
-        if (PromptProfiles.TryGetValue(version.Trim(), out var selectedVersion))
+        var normalizedVersion = version.Trim();
+        if (normalizedVersion.Length >= 2 &&
+            normalizedVersion[0] == 'v' &&
+            int.TryParse(normalizedVersion.AsSpan(1), out _))
         {
-            return selectedVersion;
+            return normalizedVersion;
         }
 
         throw new InvalidOperationException($"AI prompt version '{version}' is not supported.");
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
index a60c0d9f87..07f1c714c1 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Web/Pages/Prompts/Index.js
@@ -137,7 +137,7 @@ $(function () {
     }
 
     function loadVersions(promptId) {
-        unity.aI.prompts.aIPromptVersion.getByPrompt(promptId).then(function (result) {
+        unity.aI.prompts.aIPrompt.getByPrompt(promptId).then(function (result) {
             cachedVersions = result.items || [];
             const $select  = $('#versionSelect');
             $select.empty();
@@ -171,7 +171,7 @@ $(function () {
             populateVersionForm(v);
         } else {
             // fallback: fetch from server
-            unity.aI.prompts.aIPromptVersion.get(id).then(populateVersionForm);
+            unity.aI.prompts.aIPrompt.get(id).then(populateVersionForm);
         }
     });
 
@@ -268,7 +268,7 @@ $(function () {
             const newOpt = $('#versionSelect option[data-new]');
             dto.versionNumber = newOpt.length ? Number.parseInt(newOpt.data('num')) : 0;
 
-            unity.aI.prompts.aIPromptVersion.create(dto)
+            unity.aI.prompts.aIPrompt.create(dto)
                 .then(function () {
                     abp.notify.success('Version created');
                     loadVersions(promptId);
@@ -277,7 +277,7 @@ $(function () {
                     abp.notify.error(err?.message || 'Failed to create version');
                 });
         } else {
-            unity.aI.prompts.aIPromptVersion.update(currentVersionId, dto)
+            unity.aI.prompts.aIPrompt.update(currentVersionId, dto)
                 .then(function () {
                     abp.notify.success('Version saved');
                     loadVersions(promptId);
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIPromptRendererTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIPromptRendererTests.cs
index a9889aac80..b30aead173 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIPromptRendererTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIPromptRendererTests.cs
@@ -10,6 +10,7 @@ public class OpenAIPromptRendererTests
     [Theory]
     [InlineData("v0")]
     [InlineData("v1")]
+    [InlineData("v2")]
     [InlineData(" v1 ")]
     public void ResolvePromptVersion_Should_Return_Supported_Version(string version)
     {
@@ -22,6 +23,7 @@ public void ResolvePromptVersion_Should_Return_Supported_Version(string version)
     [InlineData("")]
     [InlineData("V1")]
     [InlineData("vNext")]
+    [InlineData("version2")]
     public void ResolvePromptVersion_Should_Throw_When_Version_Is_Missing_Or_Unsupported(string? version)
     {
         Should.Throw<InvalidOperationException>(() => OpenAIPromptRenderer.ResolvePromptVersion(version));

From ff037a9d6ea254f7f178f908c8a68bede2dbd53e Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 12:07:16 -0700
Subject: [PATCH 42/61] AB#32307 remove ai default operation fallback

---
 .../DataSeed/AIOperationDataSeeder.cs         | 24 +++++--------------
 .../Generation/AIGenerationAppService.cs      |  2 +-
 .../AIGenerationStatusAppService.cs           |  7 +-----
 .../AIGenerationRequestJobHelper.cs           |  6 -----
 4 files changed, 8 insertions(+), 31 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
index 1a4612da30..41236c47f6 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
@@ -25,7 +25,6 @@ public class AIOperationDataSeeder(
 
     private static readonly BuiltInOperationDefinition[] BuiltInOperations =
     [
-        new("Default", AIPromptTypes.ApplicationAnalysis, 1, 4000, true),
         new(AIPromptTypes.ApplicationAnalysis, AIPromptTypes.ApplicationAnalysis, 1, 4000),
         new(AIPromptTypes.AttachmentSummary, AIPromptTypes.AttachmentSummary, 1, 2000),
         new(AIPromptTypes.ApplicationScoring, AIPromptTypes.ApplicationScoring, 1, 8000)
@@ -59,21 +58,11 @@ private async Task EnsureOperationAsync(BuiltInOperationDefinition definition, A
         var prompt = await ResolvePromptAsync(definition.PromptName, definition.PromptVersionNumber);
         if (prompt == null)
         {
-            if (definition.IsDefaultOperation)
-            {
-                logger.LogWarning(
-                    "AI default operation seeding skipped: no active prompt found for '{PromptName}' version '{PromptVersionNumber}'.",
-                    definition.PromptName,
-                    definition.PromptVersionNumber);
-            }
-            else
-            {
-                logger.LogWarning(
-                    "AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}' version '{PromptVersionNumber}'.",
-                    definition.OperationName,
-                    definition.PromptName,
-                    definition.PromptVersionNumber);
-            }
+            logger.LogWarning(
+                "AI operation seeding skipped: no active prompt found for operation '{OperationName}' and prompt '{PromptName}' version '{PromptVersionNumber}'.",
+                definition.OperationName,
+                definition.PromptName,
+                definition.PromptVersionNumber);
             return;
         }
 
@@ -117,6 +106,5 @@ private sealed record BuiltInOperationDefinition(
         string OperationName,
         string PromptName,
         int PromptVersionNumber,
-        int CompletionTokens,
-        bool IsDefaultOperation = false);
+        int CompletionTokens);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index 0c0fadf254..0c908bced1 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -102,7 +102,7 @@ public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid
 
         if (!hasQueuedStage)
         {
-            throw new UserFriendlyException(AILocalizationKeys.GenerateAllDisabled);
+            throw new UserFriendlyException(L[AILocalizationKeys.GenerateAllDisabled]);
         }
 
         return new ApplicationContentResultDto { Completed = false };
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index cfa512e7a0..c78c67d233 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -61,11 +61,6 @@ public class AIGenerationStatusAppService(
     private async Task<AIOperation?> ResolveOperationAsync(string operationName)
     {
         var operations = await operationRepository.GetQueryableAsync();
-        var allOperations = (operations ?? Enumerable.Empty<AIOperation>()).ToList();
-
-        return allOperations.FirstOrDefault(operation =>
-                   string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase))
-               ?? allOperations.FirstOrDefault(operation =>
-                   string.Equals(operation.Name, "Default", StringComparison.OrdinalIgnoreCase));
+        return operations.FirstOrDefault(operation => operation.Name == operationName);
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
index 285c5cb2b9..40c138ab46 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
@@ -146,12 +146,6 @@ private static async Task<AIOperation> ResolveOperationAsync(
         var operation = operations.FirstOrDefault(item =>
             string.Equals(item.Name, operationName, StringComparison.OrdinalIgnoreCase));
 
-        if (operation == null && !string.Equals(operationName, "Default", StringComparison.OrdinalIgnoreCase))
-        {
-            operation = operations.FirstOrDefault(item =>
-                string.Equals(item.Name, "Default", StringComparison.OrdinalIgnoreCase));
-        }
-
         return operation ?? throw new InvalidOperationException($"AI operation '{operationType}' is not configured.");
     }
 

From 312b44e8313b6374221dcd5718c84ffabaf03750 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 12:34:47 -0700
Subject: [PATCH 43/61] AB#32307 align AI analysis contract

---
 .../v1/application-analysis.rules.txt         |  3 ++-
 .../AI/Runtime/AIProviderPayloadValidator.cs  | 14 +++++-----
 .../DataSeed/AIPromptDataSeeder.cs            |  6 +++--
 .../20260624191335_RefreshAiSchema.cs         |  9 -------
 .../ChefsAttachments/ChefsAttachments.js      |  6 ++---
 .../AIProviderPayloadValidatorTests.cs        | 27 +++++++++++++++++--
 6 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/v1/application-analysis.rules.txt b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/v1/application-analysis.rules.txt
index 5840d215c8..f1627fb26f 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/v1/application-analysis.rules.txt
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Prompts/Versions/v1/application-analysis.rules.txt
@@ -22,7 +22,8 @@
 - Summaries and recommendations must be concrete, distinct, reviewer-relevant, and specific to this application's evidence.
 - Avoid generic praise, checklist language, and repeated conclusions across lists.
 - Do not use a summary merely to say that supporting documents were provided; summarize the specific substantive evidence they add, or omit the finding.
-- If no findings exist, return empty arrays.
+- Errors and warnings may be empty.
+- Summaries and recommendations must each include at least one item.
 - Decision must be PROCEED or HOLD.
 - Use summaries for overall application quality/readiness synthesis.
 - Use recommendations for concrete reviewer-facing next actions based on the provided evidence.
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
index 47ef85d92e..c9119b17c9 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/AIProviderPayloadValidator.cs
@@ -53,16 +53,16 @@ public static AIResponseValidationResult ValidateApplicationAnalysisJson(string
                 return AIResponseValidationResult.Invalid($"Application analysis response is missing or invalid required field '{AIJsonKeys.Recommendations}' (expected array).");
             }
 
-            var hasAnyFindings =
-                errors.GetArrayLength() > 0
-                || warnings.GetArrayLength() > 0
-                || summaries.GetArrayLength() > 0
-                || recommendations.GetArrayLength() > 0;
+            if (summaries.GetArrayLength() == 0)
+            {
+                return AIResponseValidationResult.Invalid(
+                    $"Application analysis response must include at least one item in '{AIJsonKeys.Summaries}'.");
+            }
 
-            if (!hasAnyFindings)
+            if (recommendations.GetArrayLength() == 0)
             {
                 return AIResponseValidationResult.Invalid(
-                    "Application analysis response did not include any findings. At least one finding is required.");
+                    $"Application analysis response must include at least one item in '{AIJsonKeys.Recommendations}'.");
             }
 
             return AIResponseValidationResult.Success();
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
index 3913f9250d..64041c1d0b 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIPromptDataSeeder.cs
@@ -377,7 +377,8 @@ 4. Return only the strongest evidence-backed reviewer conclusions.
         - Summaries and recommendations must be concrete, distinct, reviewer-relevant, and specific to this application's evidence.
         - Avoid generic praise, checklist language, and repeated conclusions across lists.
         - Do not use a summary merely to say that supporting documents were provided; summarize the specific substantive evidence they add, or omit the finding.
-        - If no findings exist, return empty arrays.
+        - Errors and warnings may be empty.
+        - Summaries and recommendations must each include at least one item.
         - Decision must be PROCEED or HOLD.
         - Use summaries for overall application quality/readiness synthesis.
         - Use recommendations for concrete reviewer-facing next actions based on the provided evidence.
@@ -484,7 +485,8 @@ 4. Return only the strongest evidence-backed reviewer conclusions.
         - Summaries and recommendations must be concrete, distinct, reviewer-relevant, and specific to this application's evidence.
         - Avoid generic praise, checklist language, and repeated conclusions across lists.
         - Do not use a summary merely to say that supporting documents were provided; summarize the specific substantive evidence they add, or omit the finding.
-        - If no findings exist, return empty arrays.
+        - Errors and warnings may be empty.
+        - Summaries and recommendations must each include at least one item.
         - Decision must be PROCEED or HOLD.
         - Use summaries for overall application quality/readiness synthesis.
         - Use recommendations for concrete reviewer-facing next actions based on the provided evidence.
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index 01dcff2f33..eedcddfcbb 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -33,9 +33,6 @@ protected override void Up(MigrationBuilder migrationBuilder)
                     "CreatorId" uuid NULL,
                     "LastModificationTime" timestamp without time zone NULL,
                     "LastModifierId" uuid NULL,
-                    "DeleterId" uuid NULL,
-                    "DeletionTime" timestamp without time zone NULL,
-                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
                     PRIMARY KEY ("Id")
                 );
                 """);
@@ -63,9 +60,6 @@ CREATE UNIQUE INDEX IF NOT EXISTS "IX_AIModels_Name"
                     "CreatorId" uuid NULL,
                     "LastModificationTime" timestamp without time zone NULL,
                     "LastModifierId" uuid NULL,
-                    "DeleterId" uuid NULL,
-                    "DeletionTime" timestamp without time zone NULL,
-                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
                     PRIMARY KEY ("Id")
                 );
                 """);
@@ -92,9 +86,6 @@ CREATE UNIQUE INDEX "IX_AIPrompts_Name_VersionNumber"
                     "CreatorId" uuid NULL,
                     "LastModificationTime" timestamp without time zone NULL,
                     "LastModifierId" uuid NULL,
-                    "DeleterId" uuid NULL,
-                    "DeletionTime" timestamp without time zone NULL,
-                    "IsDeleted" boolean NOT NULL DEFAULT FALSE,
                     PRIMARY KEY ("Id")
                 );
                 """);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
index a1d0f2e627..7b95a6289d 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
@@ -225,7 +225,7 @@ $(function () {
                     }
 
                     globalThis.AIGenerationButtonState?.setGenerating($activeButton);
-                    pollAttachmentSummaryGeneration(applicationId, $activeButton);
+                    pollAttachmentSummaryGeneration(applicationId, $activeButton, existingHTML);
                 },
                 error: function (error) {
                     console.error('Error generating AI summaries:', error);
@@ -239,7 +239,7 @@ $(function () {
         });
     }
 
-    function pollAttachmentSummaryGeneration(applicationId, $button) {
+    function pollAttachmentSummaryGeneration(applicationId, $button, originalHtml) {
         if (!globalThis.AIGenerationButtonState?.monitor) {
             console.error('AIGenerationButtonState is not available; cannot poll attachment summary generation.');
             return;
@@ -247,7 +247,7 @@ $(function () {
 
         globalThis.AIGenerationButtonState.monitor({
             $button,
-            originalHtml: $button.html(),
+            originalHtml: originalHtml ?? $button.html(),
             getStatus: () => unity.grantManager.grantApplications.grantApplication
                 .getAIGenerationStatus(applicationId, 'attachment-summary'),
             onComplete: refreshAttachmentSummaryResults,
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
index 99f471f253..0805ee495a 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
@@ -110,11 +110,11 @@ public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_All
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("At least one finding is required");
+        result.Reason.ShouldContain("summaries");
     }
 
     [Fact]
-    public void ValidateApplicationAnalysisJson_Should_Return_Success_For_Proceed_With_Findings()
+    public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_Recommendations_Are_Empty()
     {
         var result = AIProviderPayloadValidator.ValidateApplicationAnalysisJson(
             """
@@ -129,6 +129,29 @@ public void ValidateApplicationAnalysisJson_Should_Return_Success_For_Proceed_Wi
             }
             """);
 
+        result.IsValid.ShouldBeFalse();
+        result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
+        result.Reason.ShouldContain("recommendations");
+    }
+
+    [Fact]
+    public void ValidateApplicationAnalysisJson_Should_Return_Success_For_Proceed_With_Findings()
+    {
+        var result = AIProviderPayloadValidator.ValidateApplicationAnalysisJson(
+            """
+            {
+              "decision": "PROCEED",
+              "errors": [],
+              "warnings": [],
+              "summaries": [
+                { "title": "Summary", "detail": "Looks complete." }
+              ],
+              "recommendations": [
+                { "title": "Proceed", "detail": "No blocking issues remain." }
+              ]
+            }
+            """);
+
         result.IsValid.ShouldBeTrue();
     }
 

From 7f98724c7bce2d8634a0aa716c16fd8fe2e5ee69 Mon Sep 17 00:00:00 2001
From: David Bright <david.bright@gov.bc.ca>
Date: Fri, 3 Jul 2026 12:55:29 -0700
Subject: [PATCH 44/61] AB#33673 - Creating DataTable context menus

Custom context menu can be added to any data table, via their options:
        enableContextMenu = false,
        contextMenuActionsSelector = '[data-selector$="-table-actions"]',
        contextMenuLabels = {}

Default actions included otherwise:
Copy: Copies current cell value to clipboard
Filter: Applies current cell value to the filter row, if filter row plugin enabled
Clear Filters: Clears all filter row values
Custom Actions: Context menu actions uses the data-selector property  to determine the custom action buttons associated with a data table. Visibility and logic remains purely with the buttons / actions themselves.

Includes accessibility features of keyboard navigation

To bypass the custom context menu, CTRL-Rightclick will open the browser's default context menu

Tables with the new context menu set:
-PaymentRequests
--PaymentHistory
-GrantApplicants
-GrantApplications
-ApplicationForms
-GrantPrograms
-Intakes
---
 .../Pages/PaymentRequests/Index.js            |  13 +-
 .../UnityThemeUX2GlobalScriptContributor.cs   |   3 +-
 .../UnityThemeUX2GlobalStyleContributor.cs    |   1 +
 .../themes/ux2/plugins/tableContextMenu.css   |  54 ++
 .../themes/ux2/plugins/tableContextMenu.js    | 593 ++++++++++++++++++
 .../wwwroot/themes/ux2/table-utils.js         |  15 +-
 .../Localization/GrantManager/en.json         |   7 +-
 .../Pages/Applicants/Index.js                 |   5 +-
 .../Pages/ApplicationForms/Index.js           |   4 +-
 .../Pages/GrantApplications/Index.js          |   4 +-
 .../Pages/GrantPrograms/Index.js              |   4 +-
 .../Pages/Intakes/Index.js                    |   4 +-
 .../Pages/PaymentHistory/Details.js           |   2 +
 .../ApplicantsActionBar/Default.cshtml        |   1 +
 14 files changed, 700 insertions(+), 10 deletions(-)
 create mode 100644 applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.css
 create mode 100644 applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.js

diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
index e85137544c..f8ba83e2a4 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Web/Pages/PaymentRequests/Index.js
@@ -99,6 +99,9 @@ $(function () {
         {
             text: 'Approve',
             className: 'custom-table-btn flex-none btn btn-secondary payment-status',
+            attr: {
+                'data-selector': 'batch-payment-table-actions'
+            },
             action: function (e, dt, node, config) {
                 // Store payment IDs in distributed cache to avoid URL length limits
                 unity.payments.paymentRequests.paymentBulkActions
@@ -119,6 +122,9 @@ $(function () {
         {
             text: 'Decline',
             className: 'custom-table-btn flex-none btn btn-secondary payment-status',
+            attr: {
+                'data-selector': 'batch-payment-table-actions'
+            },
             action: function (e, dt, node, config) {
                 // Store payment IDs in distributed cache to avoid URL length limits
                 unity.payments.paymentRequests.paymentBulkActions
@@ -139,6 +145,9 @@ $(function () {
         {
             text: 'History',
             className: 'custom-table-btn flex-none btn btn-secondary history',
+            attr: {
+                'data-selector': 'batch-payment-table-actions'
+            },
             action: function (e, dt, node, config) {
                 location.href = '/PaymentHistory/Details?PaymentId=' + selectedPaymentIds[0];
             }
@@ -322,7 +331,9 @@ $(function () {
                 dtApi.ajax.reload(null, false);
             }
             initialLoad = false;
-        }
+        },
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="batch-payment-table-actions"]'
     });
 
     $('.grp-savedStates').text('Save View');
diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalScriptContributor.cs b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalScriptContributor.cs
index ac4c3a644e..836c089f1f 100644
--- a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalScriptContributor.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalScriptContributor.cs
@@ -48,7 +48,8 @@ public override void ConfigureBundle(BundleConfigurationContext context)
         context.Files.Add("/themes/ux2/layout.js");
         context.Files.Add("/themes/ux2/plugins/filterRow.js");
         context.Files.Add("/themes/ux2/plugins/scrollResize.js");
-        context.Files.Add("/themes/ux2/plugins/colvisAlpha.js");
+        context.Files.Add("/themes/ux2/plugins/colvisAlpha.js");        
+        context.Files.Add("/themes/ux2/plugins/tableContextMenu.js");        
         context.Files.Add("/themes/ux2/table-utils.js");
         context.Files.Add("/themes/ux2/json-editor.js");
         context.Files.Add("/js/DateUtils.js");
diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalStyleContributor.cs b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalStyleContributor.cs
index a1beefb47f..8564213d1f 100644
--- a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalStyleContributor.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/Bundling/UnityThemeUX2GlobalStyleContributor.cs
@@ -12,6 +12,7 @@ public override void ConfigureBundle(BundleConfigurationContext context)
         context.Files.Add("/themes/ux2/fluenticons.min.css");
         context.Files.Add("/themes/ux2/layout.css");
         context.Files.Add("/themes/ux2/unity-styles.css");
+        context.Files.Add("/themes/ux2/plugins/tableContextMenu.css");
         context.Files.Add("/themes/ux2/json-editor.css");
 
         context.Files.AddIfNotContains("/libs/datatables.net-bs5/css/dataTables.bootstrap5.min.css");
diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.css b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.css
new file mode 100644
index 0000000000..b018118eb9
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.css
@@ -0,0 +1,54 @@
+/* DataTable Context Menu Styling */
+
+#dt-context-menu {
+    position: fixed;
+    min-width: 200px;
+    max-width: calc(100vw - 1rem);
+    max-height: calc(100vh - 1rem);
+    overflow-y: auto;
+    padding: 0.5rem;
+    margin: 0;
+    list-style: none;
+    background-color: var(--bs-body-bg, #fff);
+    border: var(--bs-border-width, 1px) solid var(--bs-border-color, #dee2e6);
+    border-radius: var(--bs-border-radius, 0.5rem);
+    box-shadow: var(--bs-box-shadow, 0 0.5rem 1rem rgba(0, 0, 0, 0.15));
+    z-index: 10000;
+}
+
+.dt-context-menu-item {
+    padding: 0;
+    margin: 0;
+}
+
+.dt-context-menu-link {
+    display: block;
+    padding: 0.5rem 1rem;
+    text-decoration: none;
+    white-space: nowrap;
+    cursor: pointer;
+    user-select: none;
+    font-size: 0.875rem;
+    border: 2px solid transparent;
+    border-radius: var(--bs-border-radius, 0.5rem);
+    transition: background-color 0.15s ease-in-out, color 0.15s ease-in-out, border-color 0.15s ease-in-out;
+}
+
+.dt-context-menu-link:hover,
+.dt-context-menu-link:focus-visible {
+    color: var(--bc-colors-blue-primary, #2E5DD7);
+    outline: none;
+    border: 2px solid var(--bc-colors-blue-primary, #2E5DD7);
+}
+
+.dt-context-menu-link:active {
+    color: var(--bs-body-bg, #fff);
+    background-color: var(--bc-colors-blue-primary, #2E5DD7);
+}
+
+.dt-context-menu-separator {
+    height: 0;
+    margin: 0.5rem 0;
+    padding: 0;
+    border-top: var(--bs-border-width, 1px) solid var(--bs-border-color, #dee2e6);
+}
diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.js b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.js
new file mode 100644
index 0000000000..7325d43fc2
--- /dev/null
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/plugins/tableContextMenu.js
@@ -0,0 +1,593 @@
+(function ($) {
+    'use strict';
+
+    // Constants
+    const MENU_Z_INDEX = 10000;
+    const MENU_VIEWPORT_PADDING = 8;
+    const OFFSCREEN_OFFSET = '-9999px';
+    const MENU_ID = 'dt-context-menu';
+
+    function getTableSettings(dtApi) {
+        return dtApi?.settings?.()?.[0] ?? null;
+    }
+
+    function getFilterRowPlugin(dtApi) {
+        return getTableSettings(dtApi)?._filterRow ?? null;
+    }
+
+    function getFilterRowElement(dtApi) {
+        return getFilterRowPlugin(dtApi)?.dom?.filterRow ?? $();
+    }
+
+    function getFilterInputs(dtApi) {
+        return getFilterRowElement(dtApi).find('input.custom-filter-input');
+    }
+
+    function getButtonsForTable(dtApi) {
+        return $(dtApi?.buttons?.().nodes?.() ?? []);
+    }
+
+    function getFilterButton(dtApi) {
+        // Try to find filter button through table's button API first
+        const $tableButtons = getButtonsForTable(dtApi);
+        if ($tableButtons.length > 0) {
+            const $filterFromAPI = $tableButtons.filter('[id="btn-toggle-filter"]');
+            if ($filterFromAPI.length > 0) {
+                return $filterFromAPI;
+            }
+        }
+
+        // Fallback: search the table's scope or page-wide
+        const $scopeRoot = getScopeRoot(dtApi);
+        const $filterScoped = $scopeRoot.find('#btn-toggle-filter');
+        if ($filterScoped.length > 0) {
+            return $filterScoped;
+        }
+
+        // Final fallback: page-wide search
+        return $('#btn-toggle-filter');
+    }
+
+    function getScopeRoot(dtApi) {
+        const $container = $(dtApi?.table?.().container?.() ?? []);
+        return $container.closest('.tab-pane, .modal, .card, .content, body').first();
+    }
+
+    function findScopedElements(dtApi, selector) {
+        const $scopeRoot = getScopeRoot(dtApi);
+        const $scopedMatches = $scopeRoot.find(selector);
+        return $scopedMatches.length > 0 ? $scopedMatches : $(selector);
+    }
+
+    function getMenuContainer() {
+        return $('#' + MENU_ID);
+    }
+
+    function getMenuItems($menuContainer) {
+        return $menuContainer.find('.dt-context-menu-link:visible');
+    }
+
+    function focusMenuItem($menuContainer, index) {
+        const $items = getMenuItems($menuContainer);
+        if ($items.length === 0) {
+            return;
+        }
+
+        const normalizedIndex = ((index % $items.length) + $items.length) % $items.length;
+        $items.attr('tabindex', '-1');
+
+        const $target = $items.eq(normalizedIndex);
+        $target.attr('tabindex', '0').trigger('focus');
+        $menuContainer.data('activeIndex', normalizedIndex);
+    }
+
+    function focusFirstMenuItem($menuContainer) {
+        focusMenuItem($menuContainer, 0);
+    }
+
+    function rememberFocusTarget(element) {
+        const $menuContainer = getMenuContainer();
+        $menuContainer.data('returnFocus', element ?? null);
+    }
+
+    function restoreFocus() {
+        const $menuContainer = getMenuContainer();
+        const returnFocus = $menuContainer.data('returnFocus');
+        if (!returnFocus || typeof returnFocus.focus !== 'function') {
+            return;
+        }
+
+        const hadTabIndex = returnFocus.hasAttribute('tabindex');
+        if (!hadTabIndex) {
+            returnFocus.setAttribute('tabindex', '-1');
+        }
+
+        returnFocus.focus();
+
+        if (!hadTabIndex) {
+            returnFocus.addEventListener('blur', function cleanupFocusTarget() {
+                returnFocus.removeAttribute('tabindex');
+            }, { once: true });
+        }
+    }
+
+    function handleMenuKeydown(e) {
+        const $menuContainer = getMenuContainer();
+        const $items = getMenuItems($menuContainer);
+        const currentIndex = $items.index(globalThis.document.activeElement);
+
+        if ($items.length === 0) {
+            return;
+        }
+
+        switch (e.key) {
+            case 'ArrowDown':
+                e.preventDefault();
+                focusMenuItem($menuContainer, currentIndex + 1);
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                focusMenuItem($menuContainer, currentIndex - 1);
+                break;
+            case 'Home':
+                e.preventDefault();
+                focusMenuItem($menuContainer, 0);
+                break;
+            case 'End':
+                e.preventDefault();
+                focusMenuItem($menuContainer, $items.length - 1);
+                break;
+            case 'Tab':
+                hideMenu();
+                break;
+            case ' ':
+                if (currentIndex > -1) {
+                    e.preventDefault();
+                    $items.eq(currentIndex).trigger('click');
+                }
+                break;
+            case 'Escape':
+                e.preventDefault();
+                hideMenu();
+                break;
+            default:
+                break;
+        }
+    }
+
+    function appendMenuAction($menuContainer, label, handler) {
+        $menuContainer.append(
+            $('<li class="dt-context-menu-item" role="none"></li>').append(
+                $('<a href="#" class="dt-context-menu-link" role="menuitem" tabindex="-1">')
+                    .text(label)
+                    .on('click', handler)
+                    .on('mouseover', function () {
+                        getMenuItems($menuContainer).blur(); // When mouse enters an item, remove focus from all items so :hover takes precedence
+                    })
+            )
+        );
+    }
+
+    function positionMenu($menuContainer, clientX, clientY) {
+        $menuContainer.css({
+            position: 'fixed',
+            display: 'block',
+            visibility: 'hidden',
+            zIndex: MENU_Z_INDEX
+        });
+
+        const menuWidth = $menuContainer.outerWidth() ?? 0;
+        const menuHeight = $menuContainer.outerHeight() ?? 0;
+        const maxLeft = Math.max(MENU_VIEWPORT_PADDING, globalThis.innerWidth - menuWidth - MENU_VIEWPORT_PADDING);
+        const maxTop = Math.max(MENU_VIEWPORT_PADDING, globalThis.innerHeight - menuHeight - MENU_VIEWPORT_PADDING);
+        const left = Math.min(Math.max(MENU_VIEWPORT_PADDING, clientX), maxLeft);
+        const top = Math.min(Math.max(MENU_VIEWPORT_PADDING, clientY), maxTop);
+
+        $menuContainer.css({
+            left: left + 'px',
+            top: top + 'px',
+            visibility: 'visible'
+        });
+    }
+
+    function showMenu($menuContainer, clientX, clientY, focusTarget) {
+        rememberFocusTarget(focusTarget);
+        positionMenu($menuContainer, clientX, clientY);
+        $menuContainer.attr('aria-hidden', 'false');
+        focusFirstMenuItem($menuContainer);
+    }
+
+    /**
+     * Handle filter column lookup and auto-population.
+     */
+    function handleFilterAction(e, $cell, dtApi) {
+        e.preventDefault();
+        hideMenu();
+
+        const cellText = ($cell.text() ?? '').trim();
+        const filterRow = getFilterRowPlugin(dtApi);
+
+        // Show the filter row if not already visible
+        filterRow?.show?.();
+
+        // Resolve the column name for the clicked cell
+        try {
+            const cellInfo = dtApi.cell($cell[0])?.index?.();
+            if (!cellInfo) {
+                return;
+            }
+
+            const colIdx = cellInfo.column;
+            const settings = dtApi.settings?.();
+            const aoColumns = settings?.[0]?.aoColumns;
+            if (!aoColumns?.[colIdx]) {
+                return;
+            }
+
+            const colName = aoColumns[colIdx].name;
+            if (!colName) {
+                return;
+            }
+
+            // Find the filter input for this column and set the value
+            const filterRowElement = getFilterRowElement(dtApi);
+            const $input = filterRowElement.find('input.custom-filter-input').filter(function () {
+                return $(this).data('column-name') === colName;
+            });
+
+            if ($input.length > 0) {
+                $input.val(cellText).trigger('keyup');
+            }
+        } catch (err) {
+            console.debug('Filter action error:', err);
+        }
+    }
+
+    /**
+     * Handle clear filter action.
+     */
+    function handleClearFilterAction(e, dtApi) {
+        e.preventDefault();
+        hideMenu();
+
+        const filterRow = getFilterRowPlugin(dtApi);
+        filterRow?.clearFilters?.();
+    }
+
+    /**
+     * Handle generic toolbar button click.
+     */
+    function handleToolbarButtonClick(e, $btn) {
+        e.preventDefault();
+        hideMenu();
+        $btn?.[0]?.click?.();
+    }
+
+    /**
+     * Check if a button is enabled (not hidden/disabled).
+     */
+    function isButtonEnabled($btn) {
+        return !$btn.hasClass('action-bar-btn-unavailable')
+            && !$btn.prop('disabled')
+            && !$btn.hasClass('d-none')
+            && !$btn.hasClass('dt-button-disabled');
+    }
+
+    /**
+     * Handle dismiss on outside click.
+     */
+    function dismissClickHandler(e) {
+        if (!$(e.target).closest('#' + MENU_ID).length) {
+            hideMenu();
+        }
+    }
+
+    /**
+     * Handle dismiss on scroll.
+     */
+    function dismissScrollHandler() {
+        hideMenu();
+    }
+
+    /**
+     * Handle row selection with callback.
+     */
+    function handleRowSelection(dtApi, rowIndex, callback) {
+        requestAnimationFrame(function () {
+            const selectedRows = dtApi.rows({ selected: true }).indexes();
+            if (!selectedRows.includes(rowIndex)) {
+                dtApi.rows({ selected: true }).deselect();
+                dtApi.row(rowIndex).select();
+            }
+            requestAnimationFrame(callback);
+        });
+    }
+
+    /**
+     * Hide the context menu and clean up event handlers.
+     */
+    function hideMenu() {
+        const $menuContainer = getMenuContainer();
+        if ($menuContainer.length > 0) {
+            $menuContainer
+                .hide()
+                .attr('aria-hidden', 'true')
+                .off('keydown.dt-context-menu')
+                .removeData('activeIndex');
+        }
+
+        $(document).off('click.dt-context-menu');
+        $(globalThis).off('scroll.dt-context-menu resize.dt-context-menu');
+
+        restoreFocus();
+    }
+
+    /**
+     * Copy text to clipboard with fallback.
+     */
+    function copyToClipboard(text) {
+        if (navigator.clipboard?.writeText) {
+            navigator.clipboard.writeText(text)
+                .then(() => {
+                    abp.notify.success((abp.localization.getResource('GrantManager')('DataTable:ContextMenu:CopiedToClipboard') ?? 'Copied to clipboard'),'Success');
+                })
+                .catch(() => {
+                    fallbackCopy(text);
+                });
+        } else {
+            fallbackCopy(text);
+        }
+    }
+
+    /**
+     * Fallback copy using textarea hack (legacy support).
+     */
+    function fallbackCopy(text) {
+        const $textarea = $('<textarea>')
+            .val(text)
+            .css({
+                position: 'fixed',
+                left: OFFSCREEN_OFFSET,
+                top: OFFSCREEN_OFFSET
+            })
+            .appendTo('body');
+
+        try {
+            $textarea[0]?.select?.();
+            const execCommand = document['execCommand']?.bind(document);
+            const success = execCommand ? execCommand('copy') : false;
+            if (success) {
+                abp.notify.success(
+                    (abp.localization.getResource('GrantManager')('DataTable:ContextMenu:CopiedToClipboard') ?? 'Copied to clipboard'),
+                    'Success'
+                );
+            } else {
+                abp.notify.error('Copy failed. Please try again.', 'Error');
+            }
+        } catch (err) {
+            console.debug('Fallback copy error:', err);
+            abp.notify.error('Copy failed. Please try again.', 'Error');
+        } finally {
+            $textarea.remove();
+        }
+    }
+
+    /**
+     * Add filter toolbar item to menu.
+     */
+    function addFilterItem(toolbarItems, labels, dtApi) {
+        const $filterBtn = getFilterButton(dtApi);
+        const filterRowPlugin = getFilterRowPlugin(dtApi);
+        if ($filterBtn.length > 0 && $filterBtn.is(':visible') && filterRowPlugin) {
+            toolbarItems.push({
+                label: labels.filter,
+                filterAction: true
+            });
+        }
+    }
+
+    /**
+     * Add clear filter toolbar item to menu if filters are active.
+     */
+    function addClearFilterItem(toolbarItems, labels, dtApi) {
+        const filterRowPlugin = getFilterRowPlugin(dtApi);
+        if (filterRowPlugin) {
+            const hasColumnFilters = getFilterInputs(dtApi).toArray().some(function (element) {
+                return Boolean($(element).val()?.trim?.());
+            });
+            const hasSearchFilter = Boolean(dtApi.search?.()?.trim?.());
+            const hasActiveFilters = hasColumnFilters || hasSearchFilter;
+
+            if (hasActiveFilters) {
+                toolbarItems.push({
+                    label: labels.clearFilter,
+                    clearFilterAction: true
+                });
+            }
+        }
+    }
+
+    /**
+     * Render filter menu item.
+     */
+    function renderFilterMenuItem($menuContainer, item, $cell, dtApi) {
+        appendMenuAction($menuContainer, item.label, function (e) {
+            handleFilterAction(e, $cell, dtApi);
+        });
+    }
+
+    /**
+     * Render clear filter menu item.
+     */
+    function renderClearFilterMenuItem($menuContainer, item, dtApi) {
+        appendMenuAction($menuContainer, item.label, function (e) {
+            handleClearFilterAction(e, dtApi);
+        });
+    }
+
+    /**
+     * Render toolbar button menu item.
+     */
+    function renderToolbarButtonMenuItem($menuContainer, item) {
+        appendMenuAction($menuContainer, item.label, function (e) {
+            handleToolbarButtonClick(e, item.$btn);
+        });
+    }
+
+    /**
+     * Render custom action menu item.
+     */
+    function renderCustomActionMenuItem($menuContainer, $btn, btnText) {
+        appendMenuAction($menuContainer, btnText, function (e) {
+            handleToolbarButtonClick(e, $btn);
+        });
+    }
+
+    /**
+     * Initialize a context menu for a DataTable.
+     * Features:
+     * - Right-click selection: if row not selected, select it; if already selected, keep selection
+     * - Copy: copies the right-clicked cell's rendered text to clipboard
+     * - Toolbar items: Filtering
+     * - Custom actions: mirrors visible/enabled ActionBar buttons
+     * 
+     * @param {DataTables.Api} dtApi - The initialized DataTable API instance
+     * @param {Object} options - Configuration options
+     * @param {boolean} [options.enabled=true] - Whether context menu is enabled
+     * @param {string} [options.actionsSelector='[data-selector$="-table-actions"]'] - Selector for custom action buttons
+     * @param {boolean} [options.copyEnabled=true] - Whether Copy action is available
+     * @param {Object} [options.labels={}] - Localization overrides { copy, filter, clearFilter }
+     */
+    globalThis.initializeTableContextMenu = function (dtApi, options) {
+        options = options ?? {};
+
+        const enabled = options.enabled !== false;
+        const actionsSelector = options.actionsSelector ?? '[data-selector$="-table-actions"]';
+        const copyEnabled = options.copyEnabled !== false;
+        const labels = options.labels ?? {};
+
+        if (!enabled || !dtApi?.table) {
+            return;
+        }
+
+        // Initialize labels with defaults
+        const l = abp.localization.getResource('GrantManager');
+        const defaultLabels = {
+            copy: l('DataTable:ContextMenu:Copy') ?? 'Copy',
+            filter: l('DataTable:ContextMenu:Filter') ?? 'Filter',
+            clearFilter: l('DataTable:ContextMenu:ClearFilter') ?? 'Clear Filters'
+        };
+
+        const finalLabels = $.extend({}, defaultLabels, labels);
+
+        // Create menu container (single, reused)
+        let $menuContainer = getMenuContainer();
+        if ($menuContainer.length === 0) {
+            $menuContainer = $('<ul id="dt-context-menu" class="dt-context-menu" style="display: none;" role="menu" aria-hidden="true"></ul>');
+            $('body').append($menuContainer);
+        }
+
+        // Event handler for right-click on table
+        const dtBody = dtApi.table()?.body?.();
+        if (dtBody) {
+            $(dtBody).off('contextmenu.dt-context-menu').on('contextmenu.dt-context-menu', function (e) {
+                // Allow browser's default context menu when Ctrl is held
+                if (e.ctrlKey) {
+                    return;
+                }
+
+                e.preventDefault();
+                e.stopPropagation();
+
+                const $cell = $(e.target).closest('td, th');
+                if ($cell.length === 0) {
+                    return;
+                }
+
+                const $row = $cell.closest('tr');
+                const rowNode = $row[0];
+                if (!rowNode) {
+                    return;
+                }
+
+                const rowIndex = dtApi.row(rowNode)?.index?.();
+                if (rowIndex === undefined || rowIndex === -1) {
+                    return;
+                }
+
+                handleRowSelection(dtApi, rowIndex, () => {
+                    buildAndShowMenu(e.clientX, e.clientY, $cell, dtApi, finalLabels, actionsSelector, copyEnabled);
+                });
+            });
+        }
+
+        /**
+         * Build and display the context menu at the given coordinates.
+         */
+        function buildAndShowMenu(pageX, pageY, $cell, dtApi, labels, actionsSelector, copyEnabled) {
+            const $menuContainer = getMenuContainer();
+            $menuContainer.empty();
+
+            // Copy
+            if (copyEnabled) {
+                const cellText = ($cell.text() ?? '').trim();
+                appendMenuAction($menuContainer, labels.copy, function (e) {
+                    e.preventDefault();
+                    copyToClipboard(cellText);
+                    hideMenu();
+                });
+            }
+
+            // Toolbar
+            const toolbarItems = [];
+
+            addFilterItem(toolbarItems, labels, dtApi);
+            addClearFilterItem(toolbarItems, labels, dtApi);
+
+            if (toolbarItems.length > 0) {
+                if (copyEnabled)
+                    $menuContainer.append($('<li class="dt-context-menu-separator"></li>'));
+
+                toolbarItems.forEach(function (item) {
+                    if (item.filterAction) {
+                        renderFilterMenuItem($menuContainer, item, $cell, dtApi);
+                    } else if (item.clearFilterAction) {
+                        renderClearFilterMenuItem($menuContainer, item, dtApi);
+                    } else if (item.$btn?.length > 0) {
+                        renderToolbarButtonMenuItem($menuContainer, item);
+                    }
+                });
+            }
+
+            // Custom Actions (ActionBar buttons)
+            const $customBtns = findScopedElements(dtApi, actionsSelector).filter(function () {
+                return isButtonEnabled($(this));
+            });
+
+            if ($customBtns.length > 0) {
+                if (copyEnabled || toolbarItems.length > 0)
+                    $menuContainer.append($('<li class="dt-context-menu-separator"></li>'));
+
+                $customBtns.each(function () {
+                    const $btn = $(this);
+                    const btnText = ($btn.text() ?? '').trim();
+
+                    if (btnText?.length > 0) {
+                        renderCustomActionMenuItem($menuContainer, $btn, btnText);
+                    }
+                });
+            }
+
+            // Attach event handlers
+            $(document).off('click.dt-context-menu').on('click.dt-context-menu', dismissClickHandler);
+            $(globalThis)
+                .off('scroll.dt-context-menu resize.dt-context-menu')
+                .on('scroll.dt-context-menu', dismissScrollHandler)
+                .on('resize.dt-context-menu', dismissScrollHandler);
+            $menuContainer.off('keydown.dt-context-menu').on('keydown.dt-context-menu', handleMenuKeydown);
+
+            showMenu($menuContainer, pageX, pageY, $cell[0]);
+        }
+    };
+
+}(jQuery));
diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
index 09363e3316..a4adc1a13e 100644
--- a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
@@ -230,7 +230,10 @@ function initializeDataTable(options) {
         onStateLoaded,
         fixedHeaders = false,
         lengthMenu = [25, 50, 75, 100, -1],
-        deferRender = false
+        deferRender = false,
+        enableContextMenu = false,
+        contextMenuActionsSelector = '[data-selector$="-table-actions"]',
+        contextMenuLabels = {}
     } = options;
 
     // Process columns and visibility
@@ -453,6 +456,16 @@ function initializeDataTable(options) {
         iDt.settings()[0]._scrollResize = new DataTable.ScrollResize(iDt);
     }
 
+    // Initialize Context Menu plugin if enabled
+    if (enableContextMenu && typeof window.initializeTableContextMenu === 'function') {
+        initializeTableContextMenu(iDt, {
+            enabled: true,
+            actionsSelector: contextMenuActionsSelector,
+            copyEnabled: true,
+            labels: contextMenuLabels
+        });
+    }
+
     return iDt;
 }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
index ec090bfc29..392682daea 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
@@ -573,6 +573,11 @@
     "TenantList:ConfigurationAction": "Configuration",
     "TenantList:LicencePlate": "Licence Plate",
     "TenantList:CasClientCode": "CAS Client Code",
-    "TenantList:SearchMinChars": "Please enter at least 2 characters to search."
+    "TenantList:SearchMinChars": "Please enter at least 2 characters to search.",
+
+    "DataTable:ContextMenu:Copy": "Copy",
+    "DataTable:ContextMenu:CopiedToClipboard": "Copied to clipboard",
+    "DataTable:ContextMenu:Filter": "Filter",
+    "DataTable:ContextMenu:ClearFilter": "Clear Filters"
   }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
index 820ef194c2..c79744f926 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
@@ -607,10 +607,11 @@ $(function () {
                 }
             }
             return null;
-        }
+        },
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="applicants-table-actions"]'
     });
 
-
     // Handle row selection and publish events for ActionBar
     dataTable.on('select', function (e, dt, type, indexes) {
         if (type === 'row' && indexes?.length) {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Index.js
index 05cd641f8d..c9ce2c65c0 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/ApplicationForms/Index.js
@@ -128,7 +128,9 @@
         dynamicButtonContainerId: 'dynamicButtonContainerId',
         useNullPlaceholder: true,
         externalSearchId: 'search-forms',
-        fixedHeaders: true
+        fixedHeaders: true,
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="forms-table-actions"]'
     });
 
     createModal.onResult(function () {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
index 7366c7286a..fda92e5ea5 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
@@ -462,7 +462,9 @@ $(function () {
                     dtApi.ajax.reload(null, false);
                 }
                 initialLoad = false; // Reset flag after use
-            }
+            },
+            enableContextMenu: true,
+            contextMenuActionsSelector: '[data-selector="applications-table-actions"]'
         });
 
         dataTable.on('select', function (e, dt, type, indexes) {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantPrograms/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantPrograms/Index.js
index 1def43a2f3..6296adff43 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantPrograms/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantPrograms/Index.js
@@ -61,7 +61,9 @@
         dataTableName: 'UserGrantProgramsTable',
         dynamicButtonContainerId: 'dynamicButtonContainerId',
         externalSearchId: 'search-grant-programs',
-        disableColumnSelect: true
+        disableColumnSelect: true,
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="programs-table-actions"]'
     });
 });
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Intakes/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Intakes/Index.js
index 18b6f5f0fd..3ca3264525 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Intakes/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Intakes/Index.js
@@ -108,7 +108,9 @@
         dynamicButtonContainerId: 'dynamicButtonContainerId',
         useNullPlaceholder: true,
         externalSearchId: 'search-intakes',
-        fixedHeaders: true
+        fixedHeaders: true,
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="intakes-table-actions"]'
     });
 
     createModal.onResult(function () {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/PaymentHistory/Details.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/PaymentHistory/Details.js
index 890582ea83..fea0af5c6d 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/PaymentHistory/Details.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/PaymentHistory/Details.js
@@ -42,6 +42,8 @@
         dataTableName: 'AuditHistoryTable',
         dynamicButtonContainerId: 'dynamicButtonContainerId',
         externalSearchId: 'search-payment-history',
+        enableContextMenu: true,
+        contextMenuActionsSelector: '[data-selector="paymenthistory-table-actions"]'
     });
 
     function getColumns() {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantsActionBar/Default.cshtml b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantsActionBar/Default.cshtml
index e3cd75cd24..e3f11a5e69 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantsActionBar/Default.cshtml
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantsActionBar/Default.cshtml
@@ -26,6 +26,7 @@
         {
             <abp-button id="mergeApplicants"
                         text="Merge"
+                        data-selector="applicants-table-actions"
                         class="custom-table-btn flex-none btn btn-secondary d-none"
                         button-type="Secondary" />
         }

From c51a419a8ac5b6e42c86749cfaf49afc65efeca4 Mon Sep 17 00:00:00 2001
From: David Bright <david.bright@gov.bc.ca>
Date: Fri, 3 Jul 2026 13:11:58 -0700
Subject: [PATCH 45/61] AB#33673 - SonarQube es2020 - Prefer `globalThis` over
 `window`.

---
 .../src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
index a4adc1a13e..981f3ec37c 100644
--- a/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
+++ b/applications/Unity.GrantManager/modules/Unity.Theme.UX2/src/Unity.Theme.UX2/wwwroot/themes/ux2/table-utils.js
@@ -457,7 +457,7 @@ function initializeDataTable(options) {
     }
 
     // Initialize Context Menu plugin if enabled
-    if (enableContextMenu && typeof window.initializeTableContextMenu === 'function') {
+    if (enableContextMenu && typeof globalThis.initializeTableContextMenu === 'function') {
         initializeTableContextMenu(iDt, {
             enabled: true,
             actionsSelector: contextMenuActionsSelector,

From da1cda086f2b8c2803112cd902361bf3117f8ab4 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 13:18:00 -0700
Subject: [PATCH 46/61] AB#32307 remove public ai generate-all endpoint

---
 .../Generation/IAIGenerationAppService.cs     |  2 --
 .../AIPermissionDefinitionProvider.cs         |  1 -
 .../Permissions/AIPermissions.cs              |  1 -
 .../Generation/AIGenerationAppService.cs      | 32 -----------------
 .../AIGenerationStatusAppService.cs           | 13 ++++---
 .../AIGenerationRequestJobHelper.cs           |  4 +--
 .../20260624191335_RefreshAiSchema.cs         |  1 +
 .../Automation/AIGenerationAppServiceTests.cs | 36 -------------------
 .../AIGenerationStatusAppServiceTests.cs      | 10 ++++--
 9 files changed, 17 insertions(+), 83 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Generation/IAIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Generation/IAIGenerationAppService.cs
index 580d7dc09a..adaf1696a0 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Generation/IAIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Generation/IAIGenerationAppService.cs
@@ -14,6 +14,4 @@ public interface IAIGenerationAppService : IApplicationService
     Task<ApplicationAnalysisResultDto> GenerateApplicationAnalysisAsync(Guid applicationId, string? promptVersion = null);
 
     Task<ApplicationScoringResultDto> GenerateApplicationScoringAsync(Guid applicationId, string? promptVersion = null);
-
-    Task<ApplicationContentResultDto> GenerateContentAsync(Guid applicationId, string? promptVersion = null);
 }
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
index e0191840be..3e4a2a7b9d 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissionDefinitionProvider.cs
@@ -63,7 +63,6 @@ public override void Define(IPermissionDefinitionContext context)
             "Unity.AI.Scoring",
             "Unity.AI.AttachmentSummaries",
             "Unity.AI.ApplicationAnalysis"));
-
     }
 
     private static LocalizableString L(string name)
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
index aef7861607..b9ea59607f 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/Permissions/AIPermissions.cs
@@ -21,7 +21,6 @@ public static class Analysis
         public const string GenerateApplicationAnalysis = GroupName + ".GenerateApplicationAnalysis";
         public const string GenerateAttachmentSummaries = GroupName + ".GenerateAttachmentSummaries";
         public const string GenerateScoring             = GroupName + ".GenerateScoring";
-        public const string GenerateAll                 = GroupName + ".GenerateAll";
     }
 
     public static class Configuration
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index 0c908bced1..96ca1a9dbf 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -75,36 +75,4 @@ await featureGuard.EnsureEnabledAsync(
         await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, currentTenant.Id, promptVersion);
         return new ApplicationScoringResultDto { Completed = false };
     }
-
-    [Authorize(AIPermissions.Analysis.GenerateAll)]
-    [HttpPost("all")]
-    public virtual async Task<ApplicationContentResultDto> GenerateContentAsync(Guid applicationId, string? promptVersion = null)
-    {
-        var hasQueuedStage = false;
-
-        if (await _featureChecker.IsEnabledAsync(AIFeatures.AttachmentSummaries))
-        {
-            await aiGenerationQueue.QueueAttachmentSummaryAsync(applicationId, currentTenant.Id, promptVersion);
-            hasQueuedStage = true;
-        }
-
-        if (await _featureChecker.IsEnabledAsync(AIFeatures.ApplicationAnalysis))
-        {
-            await aiGenerationQueue.QueueApplicationAnalysisAsync(applicationId, currentTenant.Id, promptVersion);
-            hasQueuedStage = true;
-        }
-
-        if (await _featureChecker.IsEnabledAsync(AIFeatures.Scoring))
-        {
-            await aiGenerationQueue.QueueApplicationScoringAsync(applicationId, currentTenant.Id, promptVersion);
-            hasQueuedStage = true;
-        }
-
-        if (!hasQueuedStage)
-        {
-            throw new UserFriendlyException(L[AILocalizationKeys.GenerateAllDisabled]);
-        }
-
-        return new ApplicationContentResultDto { Completed = false };
-    }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
index c78c67d233..a4d311a8df 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/AIGenerationStatusAppService.cs
@@ -6,13 +6,15 @@
 using Volo.Abp.Application.Services;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.Linq;
 
 namespace Unity.GrantManager.GrantApplications;
 
 public class AIGenerationStatusAppService(
     IRepository<AIGenerationRequest, Guid> generationRequestRepository,
     IRepository<AIOperation, Guid> operationRepository,
-    ICurrentTenant currentTenant)
+    ICurrentTenant currentTenant,
+    IAsyncQueryableExecuter asyncQueryableExecuter)
     : ApplicationService, IAIGenerationStatusAppService
 {
     public virtual async Task<AIGenerationRequestDto?> GetLatestAsync(Guid applicationId, string operationType, Guid? tenantId = null)
@@ -33,14 +35,14 @@ public class AIGenerationStatusAppService(
         var query = await generationRequestRepository.GetQueryableAsync();
         var resolvedTenantId = tenantId ?? currentTenant.Id;
 
-        var item = query
+        var item = await asyncQueryableExecuter.FirstOrDefaultAsync(
+            query
             .Where(x =>
                 x.ApplicationId == applicationId &&
                 x.OperationId == operation.Id &&
                 x.TenantId == resolvedTenantId)
             .OrderByDescending(x => x.CreationTime)
-            .ThenByDescending(x => x.Id)
-            .FirstOrDefault();
+            .ThenByDescending(x => x.Id));
 
         return item == null
             ? null
@@ -61,6 +63,7 @@ public class AIGenerationStatusAppService(
     private async Task<AIOperation?> ResolveOperationAsync(string operationName)
     {
         var operations = await operationRepository.GetQueryableAsync();
-        return operations.FirstOrDefault(operation => operation.Name == operationName);
+        return await asyncQueryableExecuter.FirstOrDefaultAsync(
+            operations.Where(operation => operation.Name == operationName));
     }
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
index 40c138ab46..7a28bd3c2c 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/AIGenerationRequestJobHelper.cs
@@ -142,9 +142,7 @@ private static async Task<AIOperation> ResolveOperationAsync(
             throw new ArgumentException($"Unknown AI operation type '{operationType}'.", nameof(operationType));
         }
 
-        var operations = await operationRepository.GetListAsync();
-        var operation = operations.FirstOrDefault(item =>
-            string.Equals(item.Name, operationName, StringComparison.OrdinalIgnoreCase));
+        var operation = await operationRepository.FirstOrDefaultAsync(item => item.Name == operationName);
 
         return operation ?? throw new InvalidOperationException($"AI operation '{operationType}' is not configured.");
     }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
index eedcddfcbb..1706bb14e5 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/HostMigrations/20260624191335_RefreshAiSchema.cs
@@ -13,6 +13,7 @@ protected override void Up(MigrationBuilder migrationBuilder)
         {
             migrationBuilder.Sql(
                 """
+                CREATE SCHEMA IF NOT EXISTS "AI";
                 DROP TABLE IF EXISTS "AI"."AIRequests";
                 DROP TABLE IF EXISTS "AI"."AIOperations";
                 DROP TABLE IF EXISTS "AI"."AIModels";
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
index 03e0d3639d..383e6e49ba 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
@@ -3,7 +3,6 @@
 using Shouldly;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading.Tasks;
 using Unity.AI.Generation;
 using Unity.AI.Localization;
@@ -21,41 +20,6 @@ namespace Unity.GrantManager.GrantApplications.Automation;
 
 public class AIGenerationAppServiceTests(ITestOutputHelper outputHelper) : GrantManagerApplicationTestBase(outputHelper)
 {
-    [Fact]
-    public async Task GenerateContentAsync_Should_Return_Completed_Result()
-    {
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries").Returns(true);
-        featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(true);
-        featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(true);
-        var localizer = Substitute.For<IStringLocalizer<AIResource>>();
-        var featureGuard = new AIFeatureGuard(featureChecker, localizer);
-
-        var queue = Substitute.For<IApplicationAIGenerationQueue>();
-        queue.QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>())
-            .Returns(Task.CompletedTask);
-        queue.QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
-            .Returns(Task.CompletedTask);
-        queue.QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>())
-            .Returns(Task.CompletedTask);
-        var currentTenant = Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>();
-        currentTenant.Id.Returns(Guid.NewGuid());
-
-        var service = new AIGenerationAppService(
-            queue,
-            featureGuard,
-            featureChecker,
-            currentTenant);
-
-        var result = await service.GenerateContentAsync(Guid.NewGuid());
-
-        result.ShouldNotBeNull();
-        result.Completed.ShouldBeFalse();
-        await queue.Received(1).QueueAttachmentSummaryAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>(), Arg.Any<List<Guid>?>());
-        await queue.Received(1).QueueApplicationAnalysisAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
-        await queue.Received(1).QueueApplicationScoringAsync(Arg.Any<Guid>(), Arg.Any<Guid?>(), Arg.Any<string?>());
-    }
-
     [Fact]
     public async Task GenerateAttachmentSummariesAsync_Should_Validate_Against_Application_Ownership()
     {
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
index f0659db596..ad724b3dd6 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationStatusAppServiceTests.cs
@@ -6,6 +6,7 @@
 using Unity.AI.Domain;
 using Unity.GrantManager.GrantApplications;
 using Volo.Abp.Domain.Repositories;
+using Volo.Abp.Linq;
 using Volo.Abp.MultiTenancy;
 using Xunit;
 using Xunit.Abstractions;
@@ -40,11 +41,12 @@ public async Task GetLatestAsync_Should_Respect_Current_Tenant()
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+        var asyncQueryableExecuter = new AsyncQueryableExecuter(Array.Empty<IAsyncQueryableProvider>());
 
         var currentTenant = Substitute.For<ICurrentTenant>();
         currentTenant.Id.Returns(tenantId);
 
-        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant, asyncQueryableExecuter);
 
         var result = await service.GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
 
@@ -76,11 +78,12 @@ public async Task GetLatestAsync_Should_Return_History_For_Inactive_Operation()
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+        var asyncQueryableExecuter = new AsyncQueryableExecuter(Array.Empty<IAsyncQueryableProvider>());
 
         var currentTenant = Substitute.For<ICurrentTenant>();
         currentTenant.Id.Returns(tenantId);
 
-        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant, asyncQueryableExecuter);
 
         var result = await service.GetLatestAsync(applicationId, AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType);
 
@@ -110,11 +113,12 @@ public async Task GetLatestAsync_Should_Reject_Legacy_Operation_Name()
         repository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIGenerationRequest>>(requests.AsQueryable()));
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository.GetQueryableAsync().Returns(Task.FromResult<IQueryable<AIOperation>>(operations.AsQueryable()));
+        var asyncQueryableExecuter = new AsyncQueryableExecuter(Array.Empty<IAsyncQueryableProvider>());
 
         var currentTenant = Substitute.For<ICurrentTenant>();
         currentTenant.Id.Returns(tenantId);
 
-        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant);
+        var service = new AIGenerationStatusAppService(repository, operationRepository, currentTenant, asyncQueryableExecuter);
 
         var result = await service.GetLatestAsync(applicationId, "legacy-operation-name");
 

From 24ca09522f9a3feaf9d864e94e253df509e23da1 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 13:36:01 -0700
Subject: [PATCH 47/61] AB#32307 tighten AI prompt and queue behavior

---
 .../Prompts/AIPromptAppService.cs             | 22 +++++++++++
 .../ApplicationAIGenerationQueue.cs           |  8 ++--
 .../GrantApplicationAppService.cs             | 38 +++++++++----------
 .../ChefsAttachments/ChefsAttachments.js      |  3 ++
 .../Automation/AIGenerationQueueTests.cs      |  7 ++--
 5 files changed, 51 insertions(+), 27 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
index e5a58be358..90867f2ab6 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
@@ -11,6 +11,7 @@
 using Volo.Abp.Application.Services;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp;
 
 namespace Unity.AI.Prompts;
 
@@ -77,6 +78,16 @@ public override async Task<AIPromptDto> CreateAsync(CreateUpdateAIPromptDto inpu
         using (_multiTenantDataFilter.Disable())
         {
             var prompt = await Repository.GetAsync(input.PromptId);
+            var existingVersion = await Repository.FirstOrDefaultAsync(p =>
+                p.TenantId == prompt.TenantId &&
+                p.Name == prompt.Name &&
+                p.VersionNumber == input.VersionNumber);
+            if (existingVersion != null)
+            {
+                throw new UserFriendlyException(
+                    $"AI prompt '{prompt.Name}' already has version {input.VersionNumber}.");
+            }
+
             var entity = await Repository.InsertAsync(
                 new AIPrompt(
                     Guid.CreateVersion7(),
@@ -100,6 +111,17 @@ public override async Task<AIPromptDto> UpdateAsync(Guid id, CreateUpdateAIPromp
         using (_multiTenantDataFilter.Disable())
         {
             var entity = await Repository.GetAsync(id);
+            var conflictingVersion = await Repository.FirstOrDefaultAsync(p =>
+                p.Id != id &&
+                p.TenantId == entity.TenantId &&
+                p.Name == entity.Name &&
+                p.VersionNumber == input.VersionNumber);
+            if (conflictingVersion != null)
+            {
+                throw new UserFriendlyException(
+                    $"AI prompt '{entity.Name}' already has version {input.VersionNumber}.");
+            }
+
             entity.VersionNumber = input.VersionNumber;
             entity.SystemPrompt = input.SystemPrompt;
             entity.UserPrompt = input.UserPrompt;
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
index 334016b809..dbcdc17c33 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/ApplicationAIGenerationQueue.cs
@@ -218,10 +218,10 @@ private async Task<AIOperation> ResolveOperationAsync(string operationType)
     {
         var operationName = ResolveOperationName(operationType);
         var operations = await operationRepository.GetQueryableAsync();
-        var allOperations = await _asyncQueryableExecuter.ToListAsync(operations);
-
-        var operation = allOperations.FirstOrDefault(operation =>
-            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
+        var operation = await _asyncQueryableExecuter.FirstOrDefaultAsync(
+            operations.Where(operation =>
+                operation.IsActive &&
+                operation.Name == operationName));
 
         if (operation == null)
         {
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index 42e99216cc..ebfeab9fea 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -1267,25 +1267,25 @@ private async Task<AIGenerationStatusDto> CreateGenerationStatusAsync(AIGenerati
 
     private async Task EnsureAIGenerationStatusAccessAsync(string operationType)
     {
-        switch (operationType)
-        {
-            case AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType:
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
-                return;
-            case AIGenerationRequestKeyHelper.AttachmentSummaryOperationType:
-        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
-                return;
-            case AIGenerationRequestKeyHelper.ApplicationScoringOperationType:
-        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
-                return;
-            case AIGenerationRequestKeyHelper.PipelineOperationType:
-                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
-        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
-        await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
-                return;
-            default:
-                throw new UserFriendlyException("Unknown AI generation operation type.");
-        }
+        switch (operationType)
+        {
+            case AIGenerationRequestKeyHelper.ApplicationAnalysisOperationType:
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
+                return;
+            case AIGenerationRequestKeyHelper.AttachmentSummaryOperationType:
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
+                return;
+            case AIGenerationRequestKeyHelper.ApplicationScoringOperationType:
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
+                return;
+            case AIGenerationRequestKeyHelper.PipelineOperationType:
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewApplicationAnalysis);
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewAttachmentSummary);
+                await AuthorizationService.CheckAsync(AIPermissions.Analysis.ViewScoringResult);
+                return;
+            default:
+                throw new UserFriendlyException("Unknown AI generation operation type.");
+        }
     }
 
     private async Task EnsureAttachmentSummariesEnabledAsync()
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
index 7b95a6289d..2e0f6767d0 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ChefsAttachments/ChefsAttachments.js
@@ -242,6 +242,9 @@ $(function () {
     function pollAttachmentSummaryGeneration(applicationId, $button, originalHtml) {
         if (!globalThis.AIGenerationButtonState?.monitor) {
             console.error('AIGenerationButtonState is not available; cannot poll attachment summary generation.');
+            abp.message.error('AI attachment summary polling is unavailable. Please refresh and try again.');
+            globalThis.AIGenerationButtonState?.restore($button);
+            $button.html(originalHtml ?? $button.html()).prop('disabled', false);
             return;
         }
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
index dc40cfb149..a1668c20b9 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationQueueTests.cs
@@ -33,8 +33,6 @@ public class AIGenerationQueueTests(ITestOutputHelper outputHelper) : GrantManag
     private static readonly Guid AttachmentSummaryOperationId = Guid.Parse("11111111-1111-1111-1111-111111111111");
     private static readonly Guid ApplicationAnalysisOperationId = Guid.Parse("22222222-2222-2222-2222-222222222222");
     private static readonly Guid ApplicationScoringOperationId = Guid.Parse("33333333-3333-3333-3333-333333333333");
-    private static readonly Guid DefaultOperationId = Guid.Parse("55555555-5555-5555-5555-555555555555");
-
     [Fact]
     public async Task QueueAllAIStagesAsync_Should_Enqueue_Pipeline_Job_When_None_Exists()
     {
@@ -383,6 +381,8 @@ private static ApplicationAIGenerationQueue CreateQueue(
         asyncQueryableExecuter ??= Substitute.For<IAsyncQueryableExecuter>();
         asyncQueryableExecuter.ToListAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().ToList()));
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().FirstOrDefault()));
         asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIGenerationRequest>>(), Arg.Any<CancellationToken>())
             .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIGenerationRequest>>().FirstOrDefault()));
 
@@ -408,8 +408,7 @@ private static IRepository<AIOperation, Guid> CreateOperationRepository()
         {
             new(AttachmentSummaryOperationId, "AttachmentSummary", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
             new(ApplicationAnalysisOperationId, "ApplicationAnalysis", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
-            new(ApplicationScoringOperationId, "ApplicationScoring", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true },
-            new(DefaultOperationId, "Default", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true }
+            new(ApplicationScoringOperationId, "ApplicationScoring", Guid.NewGuid(), Guid.NewGuid()) { IsActive = true }
         };
 
         var repository = Substitute.For<IRepository<AIOperation, Guid>>();

From 5042bef5bfa243f70cf437db6ae99a00af5c1c46 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 13:56:22 -0700
Subject: [PATCH 48/61] AB#32307 tighten AI runtime resolution

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs | 23 ++++---
 .../DataSeed/AIModelDataSeeder.cs             |  2 +-
 .../Generation/AIGenerationAppService.cs      |  3 -
 .../RunApplicationAIPipelineJob.cs            |  2 +-
 .../OpenAIConfigurationResolverTests.cs       | 69 ++++---------------
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   | 19 +++--
 .../Automation/AIGenerationAppServiceTests.cs |  1 -
 7 files changed, 46 insertions(+), 73 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index f5cedd4752..b06930e7d7 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -10,6 +10,7 @@
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.Linq;
 
 namespace Unity.AI.Runtime;
 
@@ -18,7 +19,8 @@ public class OpenAIConfigurationResolver(
     IRepository<AIOperation, Guid> operationRepository,
     IRepository<AIPrompt, Guid> promptRepository,
     IConfiguration configuration,
-    IDataFilter<IMultiTenant> multiTenantDataFilter) : ITransientDependency
+    IDataFilter<IMultiTenant> multiTenantDataFilter,
+    IAsyncQueryableExecuter asyncQueryableExecuter) : ITransientDependency
 {
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
@@ -30,6 +32,7 @@ public class OpenAIConfigurationResolver(
     private readonly IRepository<AIPrompt, Guid> _promptRepository = promptRepository;
     private readonly IConfiguration _configuration = configuration;
     private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter = multiTenantDataFilter;
+    private readonly IAsyncQueryableExecuter _asyncQueryableExecuter = asyncQueryableExecuter;
 
     public string ResolveProviderName() => Required("Azure:Operations:Defaults:Provider");
 
@@ -58,6 +61,10 @@ public async Task<OpenAIOperationSettings> ResolveOperationSettingsAsync(
         var modelSettings = ResolveModelSettings(model);
         var providerName = Required("Azure:Operations:Defaults:Provider");
         var endpoint = Required($"Azure:{providerName}:Endpoint");
+        if (!Uri.TryCreate(endpoint, UriKind.Absolute, out _))
+        {
+            throw new InvalidOperationException($"Azure:{providerName}:Endpoint must be a valid absolute URI.");
+        }
         var prompt = await LoadPromptAsync(operation.AIPromptId, cancellationToken);
         if (!prompt.IsActive)
         {
@@ -200,16 +207,14 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
 
     private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
-        var operations = await _operationRepository.GetListAsync(cancellationToken: cancellationToken);
-        var configuredOperation = operations.FirstOrDefault(operation =>
-            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
+        var operations = await _operationRepository.GetQueryableAsync();
+        var configuredOperation = await _asyncQueryableExecuter.FirstOrDefaultAsync(
+            operations.Where(operation =>
+                operation.IsActive &&
+                operation.Name == operationName),
+            cancellationToken);
         if (configuredOperation != null)
         {
-            if (!configuredOperation.IsActive)
-            {
-                return null;
-            }
-
             return configuredOperation;
         }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
index facd43663e..7839db8e01 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIModelDataSeeder.cs
@@ -45,7 +45,7 @@ private async Task EnsureModelAsync(BuiltInModelDefinition definition)
         {
             existing.IsActive = true;
             existing.SettingsJson = JsonSerializer.Serialize(settings);
-            await modelRepository.UpdateAsync(existing);
+            await modelRepository.UpdateAsync(existing, autoSave: true);
             return;
         }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
index 96ca1a9dbf..9645190884 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Generation/AIGenerationAppService.cs
@@ -22,12 +22,9 @@ namespace Unity.AI.Generation;
 public class AIGenerationAppService(
     IApplicationAIGenerationQueue aiGenerationQueue,
     AIFeatureGuard featureGuard,
-    IFeatureChecker featureChecker,
     ICurrentTenant currentTenant)
     : AIAppService, IAIGenerationAppService
 {
-    private readonly IFeatureChecker _featureChecker = featureChecker;
-
     [Authorize(AIPermissions.Analysis.GenerateAttachmentSummaries)]
     [HttpPost("attachment-summary")]
     public virtual async Task<List<AttachmentSummaryResultDto>> GenerateAttachmentSummariesAsync(GenerateAttachmentSummariesInputDto input)
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
index c922c3879a..4c378a2228 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
@@ -34,7 +34,7 @@ public override async Task ExecuteAsync(RunApplicationAIPipelineJobArgs args)
     {
         using var logScope = AIGenerationLogScope.Begin(
             logger,
-            "pipeline",
+            AIGenerationRequestKeyHelper.PipelineOperationType,
             args.ApplicationId,
             args.TenantId,
             args.PromptVersion,
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index 7d64501c80..d4c2f1a7f6 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -15,6 +15,7 @@
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.Linq;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Runtime;
@@ -53,8 +54,8 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
             });
 
         operationRepository
-            .GetListAsync()
-            .Returns(Task.FromResult(new List<AIOperation>
+            .GetQueryableAsync()
+            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
             {
                 new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
                 {
@@ -62,22 +63,7 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
                     CompletionTokens = 2222,
                     IsActive = true
                 }
-            }));
-        operationRepository
-            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
-            .Returns(callInfo =>
-            {
-                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
-                return Task.FromResult(new List<AIOperation>
-                {
-                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
-                    {
-                        ExecutionMode = AIExecutionMode.Sequential,
-                        CompletionTokens = 2222,
-                        IsActive = true
-                    }
-                }.Where(predicate.Compile()).ToList());
-            });
+            }.AsQueryable()));
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -130,8 +116,8 @@ public async Task Should_Throw_When_Operation_Is_Missing()
             });
 
         operationRepository
-            .GetListAsync()
-            .Returns(Task.FromResult(new List<AIOperation>
+            .GetQueryableAsync()
+            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
             {
                 new(Guid.NewGuid(), "Default", modelId, promptId)
                 {
@@ -139,22 +125,7 @@ public async Task Should_Throw_When_Operation_Is_Missing()
                     CompletionTokens = 2000,
                     IsActive = true
                 }
-            }));
-        operationRepository
-            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
-            .Returns(callInfo =>
-            {
-                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
-                return Task.FromResult(new List<AIOperation>
-                {
-                    new(Guid.NewGuid(), "Default", modelId, promptId)
-                    {
-                        ExecutionMode = AIExecutionMode.Sequential,
-                        CompletionTokens = 2000,
-                        IsActive = true
-                    }
-                }.Where(predicate.Compile()).ToList());
-            });
+            }.AsQueryable()));
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -268,29 +239,15 @@ public async Task Should_Resolve_Operation_Settings_From_Host_Context()
             });
 
         operationRepository
-            .GetListAsync()
-            .Returns(Task.FromResult(new List<AIOperation>
+            .GetQueryableAsync()
+            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
             {
                 new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
                 {
                     IsActive = true,
                     CompletionTokens = 2000
                 }
-            }));
-        operationRepository
-            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
-            .Returns(callInfo =>
-            {
-                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
-                return Task.FromResult(new List<AIOperation>
-                {
-                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
-                    {
-                        IsActive = true,
-                        CompletionTokens = 2000
-                    }
-                }.Where(predicate.Compile()).ToList());
-            });
+            }.AsQueryable()));
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -347,13 +304,17 @@ private static OpenAIConfigurationResolver CreateResolver(
 
         var filter = multiTenantDataFilter ?? Substitute.For<IDataFilter<IMultiTenant>>();
         filter.Disable().Returns(Substitute.For<IDisposable>());
+        var asyncQueryableExecuter = Substitute.For<IAsyncQueryableExecuter>();
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().FirstOrDefault()));
 
         return new OpenAIConfigurationResolver(
             modelRepository ?? CreateEmptyModelRepository(),
             operationRepository ?? CreateEmptyOperationRepository(),
             promptRepository ?? CreateEmptyPromptRepository(),
             configuration,
-            filter);
+            filter,
+            asyncQueryableExecuter);
     }
 
     private static IRepository<AIModel, Guid> CreateEmptyModelRepository()
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index a8c3d9bd1f..d72b62712d 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -3,7 +3,9 @@
 using Shouldly;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
+using System.Threading;
 using System.Threading.Tasks;
 using Unity.AI.Domain;
 using Unity.AI.Operations;
@@ -12,6 +14,7 @@
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
+using Volo.Abp.Linq;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Runtime;
@@ -23,7 +26,7 @@ public async Task Should_Throw_When_Analysis_Operation_Is_Not_Configured()
     {
         var resolver = CreateResolverWithNoOperations();
 
-        await Should.ThrowAsync<ArgumentNullException>(() =>
+        await Should.ThrowAsync<InvalidOperationException>(() =>
             resolver.ResolveOperationSettingsAsync(AIPromptTypes.ApplicationAnalysis));
     }
 
@@ -36,19 +39,27 @@ private static OpenAIConfigurationResolver CreateResolverWithNoOperations()
 
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository
-            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
-            .Returns(Task.FromResult(new List<AIOperation>()));
+            .GetQueryableAsync()
+            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>().AsQueryable()));
 
         var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
         var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build();
         var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
         multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
+        var asyncQueryableExecuter = Substitute.For<IAsyncQueryableExecuter>();
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().FirstOrDefault()));
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIModel>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIModel>>().FirstOrDefault()));
+        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIPrompt>>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIPrompt>>().FirstOrDefault()));
 
         return new OpenAIConfigurationResolver(
             modelRepository,
             operationRepository,
             promptRepository,
             configuration,
-            multiTenantDataFilter);
+            multiTenantDataFilter,
+            asyncQueryableExecuter);
     }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
index 383e6e49ba..f9149ef6ff 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/AIGenerationAppServiceTests.cs
@@ -34,7 +34,6 @@ public async Task GenerateAttachmentSummariesAsync_Should_Validate_Against_Appli
         var service = new AIGenerationAppService(
             Substitute.For<IApplicationAIGenerationQueue>(),
             featureGuard,
-            featureChecker,
             Substitute.For<Volo.Abp.MultiTenancy.ICurrentTenant>());
 
         var result = await service.GenerateAttachmentSummariesAsync(new GenerateAttachmentSummariesInputDto

From 9c845e32793a4bf1dfc0b9360435c636767f99ac Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 14:07:58 -0700
Subject: [PATCH 49/61] AB#32307 clean pipeline job tests

---
 .../OpenAIConfigurationResolverTests.cs       |  2 +-
 .../RunApplicationAIPipelineJobTests.cs       | 22 +++++++++++++------
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index d4c2f1a7f6..5a95f55347 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -23,7 +23,7 @@ namespace Unity.GrantManager.AI.Runtime;
 public class OpenAIConfigurationResolverTests
 {
     [Fact]
-    public async Task Should_Resolve_Operation_From_Default_When_Named_Operation_Is_Present()
+    public async Task Should_Throw_When_No_Operations_Are_Configured()
     {
         var resolver = CreateResolver();
 
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
index 773583a2c2..a87ace11fd 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
@@ -26,12 +26,6 @@ namespace Unity.GrantManager.GrantApplications.Automation;
 
 public class RunApplicationAIPipelineJobTests(ITestOutputHelper outputHelper) : GrantManagerApplicationTestBase(outputHelper)
 {
-    private static readonly Guid AttachmentSummaryOperationId = Guid.Parse("11111111-1111-1111-1111-111111111111");
-    private static readonly Guid ApplicationAnalysisOperationId = Guid.Parse("22222222-2222-2222-2222-222222222222");
-    private static readonly Guid ApplicationScoringOperationId = Guid.Parse("33333333-3333-3333-3333-333333333333");
-    private static readonly Guid PipelineOperationId = Guid.Parse("44444444-4444-4444-4444-444444444444");
-    private static readonly Guid DefaultOperationId = Guid.Parse("55555555-5555-5555-5555-555555555555");
-
     [Fact]
     public async Task ExecuteAsync_Should_Mark_Request_Completed_When_Features_Disabled()
     {
@@ -40,8 +34,17 @@ public async Task ExecuteAsync_Should_Mark_Request_Completed_When_Features_Disab
 
         var applicationId = Guid.NewGuid();
         var tenantId = Guid.NewGuid();
+        var attachmentSummaryService = Substitute.For<IAttachmentSummaryService>();
+        var applicationAnalysisService = Substitute.For<IApplicationAnalysisService>();
+        var applicationScoringService = Substitute.For<IApplicationScoringService>();
+        var applicationRepository = Substitute.For<IApplicationRepository>();
 
-        var job = BuildJob(featureChecker);
+        var job = BuildJob(
+            featureChecker,
+            attachmentSummaryService: attachmentSummaryService,
+            applicationAnalysisService: applicationAnalysisService,
+            applicationScoringService: applicationScoringService,
+            applicationRepository: applicationRepository);
         var requestedByUserId = Guid.NewGuid();
 
         await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
@@ -51,6 +54,11 @@ await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
             TenantId = tenantId
         });
 
+        await attachmentSummaryService.DidNotReceive().GenerateAndSaveAsync(Arg.Any<List<Guid>>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
+        await applicationAnalysisService.DidNotReceive().RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>());
+        await applicationScoringService.DidNotReceive().RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>());
+        await applicationRepository.DidNotReceive().GetAsync(Arg.Any<Guid>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
+        await applicationRepository.DidNotReceive().UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]

From f34c477b3477f13f007c2fb4e7b1e9c8a8b039f4 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 14:27:19 -0700
Subject: [PATCH 50/61] AB#32307 normalize prompt metadata json

---
 .../src/Unity.AI.Application/Prompts/AIPromptAppService.cs    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
index 90867f2ab6..0d6c9b02f9 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Prompts/AIPromptAppService.cs
@@ -97,7 +97,7 @@ public override async Task<AIPromptDto> CreateAsync(CreateUpdateAIPromptDto inpu
                     input.UserPrompt,
                     prompt.TenantId)
                 {
-                    MetadataJson = input.MetadataJson,
+                    MetadataJson = string.IsNullOrWhiteSpace(input.MetadataJson) ? "{}" : input.MetadataJson,
                     IsActive = input.IsActive
                 });
 
@@ -125,7 +125,7 @@ public override async Task<AIPromptDto> UpdateAsync(Guid id, CreateUpdateAIPromp
             entity.VersionNumber = input.VersionNumber;
             entity.SystemPrompt = input.SystemPrompt;
             entity.UserPrompt = input.UserPrompt;
-            entity.MetadataJson = input.MetadataJson;
+            entity.MetadataJson = string.IsNullOrWhiteSpace(input.MetadataJson) ? "{}" : input.MetadataJson;
             entity.IsActive = input.IsActive;
             entity = await Repository.UpdateAsync(entity);
             return ObjectMapper.Map<AIPrompt, AIPromptDto>(entity);

From 21066ee71b98f56c83a2f2208c2806fe1a3848b7 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 15:08:13 -0700
Subject: [PATCH 51/61] AB#32307 finalize AI runtime cleanup

---
 .../AI/Runtime/OpenAIConfigurationResolver.cs |  21 +-
 .../DataSeed/AIOperationDataSeeder.cs         |   2 +-
 .../Domain/AIOperation.cs                     |   2 +-
 .../RateLimit/AIRateLimiter.cs                |   2 -
 .../RunApplicationAIPipelineJobArgs.cs        |  11 -
 .../RunApplicationAIPipelineJob.cs            | 148 ---------
 .../AI/RateLimit/AIRateLimiterTests.cs        |   2 +-
 .../RunApplicationAIPipelineJobTests.cs       | 286 ------------------
 8 files changed, 9 insertions(+), 465 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
 delete mode 100644 applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs

diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
index b06930e7d7..7490142fbe 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Runtime/OpenAIConfigurationResolver.cs
@@ -10,7 +10,6 @@
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
-using Volo.Abp.Linq;
 
 namespace Unity.AI.Runtime;
 
@@ -19,8 +18,7 @@ public class OpenAIConfigurationResolver(
     IRepository<AIOperation, Guid> operationRepository,
     IRepository<AIPrompt, Guid> promptRepository,
     IConfiguration configuration,
-    IDataFilter<IMultiTenant> multiTenantDataFilter,
-    IAsyncQueryableExecuter asyncQueryableExecuter) : ITransientDependency
+    IDataFilter<IMultiTenant> multiTenantDataFilter) : ITransientDependency
 {
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
@@ -32,7 +30,6 @@ public class OpenAIConfigurationResolver(
     private readonly IRepository<AIPrompt, Guid> _promptRepository = promptRepository;
     private readonly IConfiguration _configuration = configuration;
     private readonly IDataFilter<IMultiTenant> _multiTenantDataFilter = multiTenantDataFilter;
-    private readonly IAsyncQueryableExecuter _asyncQueryableExecuter = asyncQueryableExecuter;
 
     public string ResolveProviderName() => Required("Azure:Operations:Defaults:Provider");
 
@@ -207,18 +204,12 @@ public async Task<string> ResolveProfileNameAsync(string? modelName = null, Canc
 
     private async Task<AIOperation?> ResolveOperationAsync(string operationName, CancellationToken cancellationToken)
     {
-        var operations = await _operationRepository.GetQueryableAsync();
-        var configuredOperation = await _asyncQueryableExecuter.FirstOrDefaultAsync(
-            operations.Where(operation =>
-                operation.IsActive &&
-                operation.Name == operationName),
-            cancellationToken);
-        if (configuredOperation != null)
-        {
-            return configuredOperation;
-        }
+        var operations = await _operationRepository.GetListAsync(
+            operation => operation.IsActive,
+            cancellationToken: cancellationToken);
 
-        return null;
+        return operations.FirstOrDefault(operation =>
+            string.Equals(operation.Name, operationName, StringComparison.OrdinalIgnoreCase));
     }
 
     private static AIModelSettings ResolveModelSettings(AIModel model)
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
index 41236c47f6..ea6b298d20 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/DataSeed/AIOperationDataSeeder.cs
@@ -74,7 +74,7 @@ private async Task EnsureOperationAsync(BuiltInOperationDefinition definition, A
             existing.ExecutionMode = AIExecutionMode.Sequential;
             existing.CompletionTokens = definition.CompletionTokens;
             existing.IsActive = true;
-            await operationRepository.UpdateAsync(existing);
+            await operationRepository.UpdateAsync(existing, autoSave: true);
             return;
         }
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
index eee9427cf2..c4aa1f229f 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/Domain/AIOperation.cs
@@ -14,7 +14,7 @@ public class AIOperation : AuditedAggregateRoot<Guid>
 
     public Guid AIPromptId { get; set; }
 
-    public AIPrompt AIPrompt { get; set; } = default!;
+    public AIPrompt? AIPrompt { get; set; }
 
     public AIExecutionMode ExecutionMode { get; set; } = AIExecutionMode.Sequential;
 
diff --git a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
index 2043986adf..2f0f06f309 100644
--- a/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
+++ b/applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/RateLimit/AIRateLimiter.cs
@@ -59,8 +59,6 @@ public virtual async Task EnsureAsync()
                 throw new UserFriendlyException(
                     $"AI generation is rate limited. Try again in {remaining} second{(remaining == 1 ? "" : "s")}.");
             }
-
-            await StampAsync(userId, CooldownSeconds);
         }
     }
 
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
deleted file mode 100644
index 7eab9ed4d8..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJobArgs.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-
-namespace Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
-
-public class RunApplicationAIPipelineJobArgs
-{
-    public Guid ApplicationId { get; set; }
-    public Guid? TenantId { get; set; }
-    public Guid? RequestedByUserId { get; set; }
-    public string? PromptVersion { get; set; }
-}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
deleted file mode 100644
index 4c378a2228..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/Automation/BackgroundJobs/RunApplicationAIPipelineJob.cs
+++ /dev/null
@@ -1,148 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Unity.AI.Operations;
-using Unity.AI.RateLimit;
-using Unity.GrantManager.Applications;
-using Unity.GrantManager.GrantApplications.Automation.Events;
-using Volo.Abp;
-using Volo.Abp.BackgroundJobs;
-using Volo.Abp.DependencyInjection;
-using Volo.Abp.EventBus.Local;
-using Volo.Abp.Features;
-using Volo.Abp.MultiTenancy;
-using Volo.Abp.ObjectMapping;
-
-namespace Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
-
-public class RunApplicationAIPipelineJob(
-    IApplicationChefsFileAttachmentRepository applicationChefsFileAttachmentRepository,
-    IAIApplicationInputBuilder inputBuilder,
-    IAttachmentSummaryService attachmentSummaryService,
-    IApplicationAnalysisService applicationAnalysisService,
-    IApplicationScoringService applicationScoringService,
-    IApplicationRepository applicationRepository,
-    IFeatureChecker featureChecker,
-    ILocalEventBus localEventBus,
-    ICurrentTenant currentTenant,
-    IObjectMapper objectMapper,
-    ILogger<RunApplicationAIPipelineJob> logger) : AsyncBackgroundJob<RunApplicationAIPipelineJobArgs>, ITransientDependency
-{
-    public override async Task ExecuteAsync(RunApplicationAIPipelineJobArgs args)
-    {
-        using var logScope = AIGenerationLogScope.Begin(
-            logger,
-            AIGenerationRequestKeyHelper.PipelineOperationType,
-            args.ApplicationId,
-            args.TenantId,
-            args.PromptVersion,
-            args.RequestedByUserId);
-
-        using (currentTenant.Change(args.TenantId))
-        {
-            var attachmentSummariesEnabled = await featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries");
-            var applicationAnalysisEnabled = await featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis");
-            var scoringEnabled = await featureChecker.IsEnabledAsync("Unity.AI.Scoring");
-            AIApplicationPromptDataDto? applicationInput = null;
-
-            if (!attachmentSummariesEnabled && !applicationAnalysisEnabled && !scoringEnabled)
-            {
-                logger.LogDebug("All AI features are disabled, skipping queued AI generation for application {ApplicationId}.", args.ApplicationId);
-                return;
-            }
-
-            var application = (applicationAnalysisEnabled || scoringEnabled)
-                ? await applicationRepository.GetAsync(args.ApplicationId)
-                : null;
-            applicationInput = application == null
-                ? null
-                : objectMapper.Map<Application, AIApplicationPromptDataDto>(application);
-
-            if (attachmentSummariesEnabled)
-            {
-                var attachmentIds = await GetAttachmentIdsAsync(args.ApplicationId);
-                if (attachmentIds.Count > 0)
-                {
-                    await attachmentSummaryService.GenerateAndSaveAsync(attachmentIds, args.PromptVersion);
-                }
-                else
-                {
-                    logger.LogDebug("Skipping AI attachment summaries for application {ApplicationId} because no attachments were available.", args.ApplicationId);
-                }
-            }
-
-            Exception? analysisException = null;
-            Exception? scoringException = null;
-
-            if (applicationAnalysisEnabled)
-            {
-                try
-                {
-                    var analysisInput = await inputBuilder.BuildApplicationAnalysisInputAsync(applicationInput!, args.PromptVersion);
-                    var analysisJson = await applicationAnalysisService.RegenerateAsync(analysisInput);
-                    application!.AIAnalysis = analysisJson;
-                    await applicationRepository.UpdateAsync(application);
-                }
-                catch (UserFriendlyException ex)
-                {
-                    logger.LogDebug(ex, "Skipping AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
-                }
-                catch (Exception ex)
-                {
-                    analysisException = ex;
-                    logger.LogError(ex, "Error executing AI application analysis stage for application {ApplicationId}.", args.ApplicationId);
-                }
-            }
-
-            if (scoringEnabled)
-            {
-                try
-                {
-                    var scoringInput = await inputBuilder.BuildApplicationScoringInputAsync(applicationInput!, args.PromptVersion);
-                    var scoresheetAnswers = await applicationScoringService.RegenerateAsync(scoringInput);
-                    application!.AIScoresheetAnswers = scoresheetAnswers;
-                    await applicationRepository.UpdateAsync(application);
-                    await localEventBus.PublishAsync(new ApplicationAIScoringGeneratedEvent
-                    {
-                        ApplicationId = args.ApplicationId
-                    });
-                }
-                catch (UserFriendlyException ex)
-                {
-                    logger.LogDebug(ex, "Skipping AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
-                }
-                catch (Exception ex)
-                {
-                    scoringException = ex;
-                    logger.LogError(ex, "Error executing AI application scoring stage for application {ApplicationId}.", args.ApplicationId);
-                }
-            }
-
-            if (analysisException != null && scoringException != null)
-            {
-                throw new AggregateException(
-                    $"AI pipeline failed for application {args.ApplicationId} in multiple stages.",
-                    analysisException,
-                    scoringException);
-            }
-
-            if (analysisException != null)
-            {
-                throw analysisException;
-            }
-
-            if (scoringException != null)
-            {
-                throw scoringException;
-            }
-        }
-    }
-
-    private async Task<List<Guid>> GetAttachmentIdsAsync(Guid applicationId)
-    {
-        var attachments = await applicationChefsFileAttachmentRepository.GetListAsync(a => a.ApplicationId == applicationId);
-        return attachments.Select(a => a.Id).ToList();
-    }
-}
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
index 60517dd481..ab35d12f62 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/RateLimit/AIRateLimiterTests.cs
@@ -73,7 +73,7 @@ public async Task EnsureAsync_AllowsThrough_When_NoCooldown()
     {
         await NewLimiter().EnsureAsync();
         var state = await NewLimiter().GetStateAsync();
-        state.RetryAfterSeconds.ShouldBeInRange(1, 60);
+        state.RetryAfterSeconds.ShouldBe(0);
     }
 
     [Fact]
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
deleted file mode 100644
index a87ace11fd..0000000000
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/GrantApplications/Automation/RunApplicationAIPipelineJobTests.cs
+++ /dev/null
@@ -1,286 +0,0 @@
-using Microsoft.Extensions.Logging.Abstractions;
-using NSubstitute;
-using Shouldly;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Unity.AI.Domain;
-using Unity.AI.Operations;
-using Unity.GrantManager.Applications;
-using Unity.GrantManager.GrantApplications.Automation.BackgroundJobs;
-using Unity.AI.RateLimit;
-using Volo.Abp;
-using Volo.Abp.Domain.Entities;
-using Volo.Abp.Domain.Repositories;
-using Volo.Abp.EventBus.Local;
-using Volo.Abp.Features;
-using Volo.Abp.MultiTenancy;
-using Volo.Abp.ObjectMapping;
-using Volo.Abp.Uow;
-using Xunit;
-using Xunit.Abstractions;
-
-namespace Unity.GrantManager.GrantApplications.Automation;
-
-public class RunApplicationAIPipelineJobTests(ITestOutputHelper outputHelper) : GrantManagerApplicationTestBase(outputHelper)
-{
-    [Fact]
-    public async Task ExecuteAsync_Should_Mark_Request_Completed_When_Features_Disabled()
-    {
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync(Arg.Any<string>()).Returns(false);
-
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-        var attachmentSummaryService = Substitute.For<IAttachmentSummaryService>();
-        var applicationAnalysisService = Substitute.For<IApplicationAnalysisService>();
-        var applicationScoringService = Substitute.For<IApplicationScoringService>();
-        var applicationRepository = Substitute.For<IApplicationRepository>();
-
-        var job = BuildJob(
-            featureChecker,
-            attachmentSummaryService: attachmentSummaryService,
-            applicationAnalysisService: applicationAnalysisService,
-            applicationScoringService: applicationScoringService,
-            applicationRepository: applicationRepository);
-        var requestedByUserId = Guid.NewGuid();
-
-        await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
-        {
-            ApplicationId = applicationId,
-            RequestedByUserId = requestedByUserId,
-            TenantId = tenantId
-        });
-
-        await attachmentSummaryService.DidNotReceive().GenerateAndSaveAsync(Arg.Any<List<Guid>>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
-        await applicationAnalysisService.DidNotReceive().RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>());
-        await applicationScoringService.DidNotReceive().RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>());
-        await applicationRepository.DidNotReceive().GetAsync(Arg.Any<Guid>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-        await applicationRepository.DidNotReceive().UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>());
-    }
-
-    [Fact]
-    public async Task ExecuteAsync_Should_Publish_Event_When_Pipeline_Scoring_Completes()
-    {
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries").Returns(false);
-        featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(false);
-        featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(true);
-
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-
-        var scoringService = Substitute.For<IApplicationScoringService>();
-        scoringService.RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>())
-            .Returns("{}");
-        var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
-        inputBuilder.BuildApplicationScoringInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = applicationId });
-        var applicationRepository = Substitute.For<IApplicationRepository>();
-        var application = new Application
-        {
-            ApplicationFormId = Guid.NewGuid()
-        };
-        applicationRepository.GetAsync(applicationId).Returns(application);
-        applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
-        var objectMapper = Substitute.For<IObjectMapper>();
-        objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
-            .Returns(new AIApplicationPromptDataDto
-            {
-                ApplicationId = applicationId,
-                ApplicationFormId = application.ApplicationFormId
-            });
-
-        var localEventBus = Substitute.For<ILocalEventBus>();
-        var requestedByUserId = Guid.NewGuid();
-
-        var job = BuildJob(
-            featureChecker,
-            localEventBus: localEventBus,
-            applicationScoringService: scoringService,
-            inputBuilder: inputBuilder,
-            applicationRepository: applicationRepository,
-            objectMapper: objectMapper);
-
-        await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
-        {
-            ApplicationId = applicationId,
-            RequestedByUserId = requestedByUserId,
-            TenantId = tenantId
-        });
-
-        await applicationRepository.Received(1).GetAsync(applicationId);
-        await localEventBus.Received(1).PublishAsync(
-            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == applicationId));
-    }
-
-    [Fact]
-    public async Task ExecuteAsync_Should_Skip_Unavailable_Stage_And_Run_Available_Stage()
-    {
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries").Returns(true);
-        featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(true);
-        featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(false);
-
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-        var attachmentRepository = Substitute.For<IApplicationChefsFileAttachmentRepository>();
-        attachmentRepository.GetListAsync(Arg.Any<System.Linq.Expressions.Expression<Func<ApplicationChefsFileAttachment, bool>>>())
-            .Returns(new List<ApplicationChefsFileAttachment>
-            {
-                CreateAttachment(applicationId)
-            });
-
-        var attachmentSummaryService = Substitute.For<IAttachmentSummaryService>();
-        attachmentSummaryService.GenerateAndSaveAsync(Arg.Any<List<Guid>>(), Arg.Any<string?>())
-            .Returns(new List<string>());
-
-        var applicationAnalysisService = Substitute.For<IApplicationAnalysisService>();
-        applicationAnalysisService.RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>())
-            .Returns("{}");
-        var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
-        inputBuilder.BuildApplicationAnalysisInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = applicationId });
-        var applicationRepository = Substitute.For<IApplicationRepository>();
-        var application = new Application
-        {
-            ApplicationFormId = Guid.NewGuid()
-        };
-        applicationRepository.GetAsync(applicationId).Returns(application);
-        applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
-        var objectMapper = Substitute.For<IObjectMapper>();
-        objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
-            .Returns(new AIApplicationPromptDataDto
-            {
-                ApplicationId = applicationId,
-                ApplicationFormId = application.ApplicationFormId
-            });
-
-        var job = BuildJob(
-            featureChecker,
-            attachmentRepository: attachmentRepository,
-            attachmentSummaryService: attachmentSummaryService,
-            applicationAnalysisService: applicationAnalysisService,
-            inputBuilder: inputBuilder,
-            applicationRepository: applicationRepository,
-            objectMapper: objectMapper);
-
-        await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
-        {
-            ApplicationId = applicationId,
-            RequestedByUserId = Guid.NewGuid(),
-            TenantId = tenantId
-        });
-
-        await applicationRepository.Received(1).GetAsync(applicationId);
-        await attachmentSummaryService.Received(1).GenerateAndSaveAsync(Arg.Any<List<Guid>>(), Arg.Any<string?>());
-        await applicationAnalysisService.Received(1).RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>());
-    }
-
-    [Fact]
-    public async Task ExecuteAsync_Should_Skip_Analysis_UserFriendlyException_And_Continue_To_Scoring()
-    {
-        var featureChecker = Substitute.For<IFeatureChecker>();
-        featureChecker.IsEnabledAsync("Unity.AI.AttachmentSummaries").Returns(false);
-        featureChecker.IsEnabledAsync("Unity.AI.ApplicationAnalysis").Returns(true);
-        featureChecker.IsEnabledAsync("Unity.AI.Scoring").Returns(true);
-
-        var applicationId = Guid.NewGuid();
-        var tenantId = Guid.NewGuid();
-
-        var analysisService = Substitute.For<IApplicationAnalysisService>();
-        analysisService.RegenerateAsync(Arg.Any<ApplicationAnalysisOperationInputDto>(), Arg.Any<CancellationToken>())
-            .Returns<Task>(callInfo => throw new UserFriendlyException("analysis prerequisites missing"));
-
-        var scoringService = Substitute.For<IApplicationScoringService>();
-        scoringService.RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>())
-            .Returns("{}");
-
-        var inputBuilder = Substitute.For<IAIApplicationInputBuilder>();
-        inputBuilder.BuildApplicationAnalysisInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationAnalysisOperationInputDto { ApplicationId = applicationId });
-        inputBuilder.BuildApplicationScoringInputAsync(Arg.Any<AIApplicationPromptDataDto>(), Arg.Any<string?>())
-            .Returns(new ApplicationScoringOperationInputDto { ApplicationId = applicationId });
-
-        var applicationRepository = Substitute.For<IApplicationRepository>();
-        var application = new Application
-        {
-            ApplicationFormId = Guid.NewGuid()
-        };
-        applicationRepository.GetAsync(applicationId).Returns(application);
-        applicationRepository.UpdateAsync(Arg.Any<Application>(), Arg.Any<bool>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<Application>()));
-        var objectMapper = Substitute.For<IObjectMapper>();
-        objectMapper.Map<Application, AIApplicationPromptDataDto>(Arg.Any<Application>())
-            .Returns(new AIApplicationPromptDataDto
-            {
-                ApplicationId = applicationId,
-                ApplicationFormId = application.ApplicationFormId
-            });
-
-        var localEventBus = Substitute.For<ILocalEventBus>();
-        var requestedByUserId = Guid.NewGuid();
-
-        var job = BuildJob(
-            featureChecker,
-            localEventBus: localEventBus,
-            applicationAnalysisService: analysisService,
-            applicationScoringService: scoringService,
-            inputBuilder: inputBuilder,
-            applicationRepository: applicationRepository,
-            objectMapper: objectMapper);
-
-        await job.ExecuteAsync(new RunApplicationAIPipelineJobArgs
-        {
-            ApplicationId = applicationId,
-            RequestedByUserId = requestedByUserId,
-            TenantId = tenantId
-        });
-
-        await applicationRepository.Received(1).GetAsync(applicationId);
-        await scoringService.Received(1).RegenerateAsync(Arg.Any<ApplicationScoringOperationInputDto>(), Arg.Any<CancellationToken>());
-        await localEventBus.Received(1).PublishAsync(
-            Arg.Is<Automation.Events.ApplicationAIScoringGeneratedEvent>(x => x.ApplicationId == applicationId));
-    }
-
-    private RunApplicationAIPipelineJob BuildJob(
-        IFeatureChecker featureChecker,
-        ILocalEventBus? localEventBus = null,
-        IApplicationChefsFileAttachmentRepository? attachmentRepository = null,
-        IAttachmentSummaryService? attachmentSummaryService = null,
-        IApplicationAnalysisService? applicationAnalysisService = null,
-        IApplicationScoringService? applicationScoringService = null,
-        IAIApplicationInputBuilder? inputBuilder = null,
-        IApplicationRepository? applicationRepository = null,
-        IObjectMapper? objectMapper = null)
-    {
-        return new RunApplicationAIPipelineJob(
-            attachmentRepository ?? Substitute.For<IApplicationChefsFileAttachmentRepository>(),
-            inputBuilder ?? Substitute.For<IAIApplicationInputBuilder>(),
-            attachmentSummaryService ?? Substitute.For<IAttachmentSummaryService>(),
-            applicationAnalysisService ?? Substitute.For<IApplicationAnalysisService>(),
-            applicationScoringService ?? Substitute.For<IApplicationScoringService>(),
-            applicationRepository ?? Substitute.For<IApplicationRepository>(),
-            featureChecker,
-            localEventBus ?? Substitute.For<ILocalEventBus>(),
-            Substitute.For<ICurrentTenant>(),
-            objectMapper ?? Substitute.For<IObjectMapper>(),
-            NullLogger<RunApplicationAIPipelineJob>.Instance);
-    }
-
-    private static ApplicationChefsFileAttachment CreateAttachment(Guid applicationId)
-    {
-        var attachment = new ApplicationChefsFileAttachment
-        {
-            ApplicationId = applicationId
-        };
-
-        EntityHelper.TrySetId(attachment, () => Guid.NewGuid());
-
-        return attachment;
-    }
-}

From 6aa29a1406b2746e7a3779280eebf3c9eef7e65f Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 15:15:15 -0700
Subject: [PATCH 52/61] AB#32307 fix AI resolver test constructor calls

---
 .../AI/Runtime/OpenAIConfigurationResolverTests.cs   |  8 +-------
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs          | 12 +-----------
 2 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index 5a95f55347..1f87810d84 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -15,7 +15,6 @@
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
-using Volo.Abp.Linq;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Runtime;
@@ -304,17 +303,12 @@ private static OpenAIConfigurationResolver CreateResolver(
 
         var filter = multiTenantDataFilter ?? Substitute.For<IDataFilter<IMultiTenant>>();
         filter.Disable().Returns(Substitute.For<IDisposable>());
-        var asyncQueryableExecuter = Substitute.For<IAsyncQueryableExecuter>();
-        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().FirstOrDefault()));
-
         return new OpenAIConfigurationResolver(
             modelRepository ?? CreateEmptyModelRepository(),
             operationRepository ?? CreateEmptyOperationRepository(),
             promptRepository ?? CreateEmptyPromptRepository(),
             configuration,
-            filter,
-            asyncQueryableExecuter);
+            filter);
     }
 
     private static IRepository<AIModel, Guid> CreateEmptyModelRepository()
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index d72b62712d..a16bbd6979 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -14,7 +14,6 @@
 using Volo.Abp.Data;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.MultiTenancy;
-using Volo.Abp.Linq;
 using Xunit;
 
 namespace Unity.GrantManager.AI.Runtime;
@@ -46,20 +45,11 @@ private static OpenAIConfigurationResolver CreateResolverWithNoOperations()
         var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build();
         var multiTenantDataFilter = Substitute.For<IDataFilter<IMultiTenant>>();
         multiTenantDataFilter.Disable().Returns(Substitute.For<IDisposable>());
-        var asyncQueryableExecuter = Substitute.For<IAsyncQueryableExecuter>();
-        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIOperation>>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIOperation>>().FirstOrDefault()));
-        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIModel>>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIModel>>().FirstOrDefault()));
-        asyncQueryableExecuter.FirstOrDefaultAsync(Arg.Any<IQueryable<AIPrompt>>(), Arg.Any<CancellationToken>())
-            .Returns(callInfo => Task.FromResult(callInfo.Arg<IQueryable<AIPrompt>>().FirstOrDefault()));
-
         return new OpenAIConfigurationResolver(
             modelRepository,
             operationRepository,
             promptRepository,
             configuration,
-            multiTenantDataFilter,
-            asyncQueryableExecuter);
+            multiTenantDataFilter);
     }
 }

From 8d5e2e30eced1b961755093f038fdaa8400de907 Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 15:20:43 -0700
Subject: [PATCH 53/61] AB#32307 fix AI resolver test stubs

---
 .../OpenAIConfigurationResolverTests.cs       | 61 +++++++++++--------
 .../AI/Runtime/OpenAIRuntimeServiceTests.cs   |  4 +-
 2 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
index 1f87810d84..c40c2f076e 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIConfigurationResolverTests.cs
@@ -53,16 +53,20 @@ public async Task Should_Resolve_Operation_Strictly_From_Database()
             });
 
         operationRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
             {
-                new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
                 {
-                    ExecutionMode = AIExecutionMode.Sequential,
-                    CompletionTokens = 2222,
-                    IsActive = true
-                }
-            }.AsQueryable()));
+                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                    {
+                        ExecutionMode = AIExecutionMode.Sequential,
+                        CompletionTokens = 2222,
+                        IsActive = true
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -115,16 +119,20 @@ public async Task Should_Throw_When_Operation_Is_Missing()
             });
 
         operationRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
             {
-                new(Guid.NewGuid(), "Default", modelId, promptId)
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
                 {
-                    ExecutionMode = AIExecutionMode.Sequential,
-                    CompletionTokens = 2000,
-                    IsActive = true
-                }
-            }.AsQueryable()));
+                    new(Guid.NewGuid(), "Default", modelId, promptId)
+                    {
+                        ExecutionMode = AIExecutionMode.Sequential,
+                        CompletionTokens = 2000,
+                        IsActive = true
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -238,15 +246,19 @@ public async Task Should_Resolve_Operation_Settings_From_Host_Context()
             });
 
         operationRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(callInfo =>
             {
-                new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                var predicate = callInfo.Arg<Expression<Func<AIOperation, bool>>>();
+                return Task.FromResult(new List<AIOperation>
                 {
-                    IsActive = true,
-                    CompletionTokens = 2000
-                }
-            }.AsQueryable()));
+                    new(Guid.NewGuid(), AIPromptTypes.ApplicationAnalysis, modelId, promptId)
+                    {
+                        IsActive = true,
+                        CompletionTokens = 2000
+                    }
+                }.Where(predicate.Compile()).ToList());
+            });
 
         promptRepository
             .GetAsync(promptId, cancellationToken: Arg.Any<CancellationToken>())
@@ -323,9 +335,6 @@ private static IRepository<AIModel, Guid> CreateEmptyModelRepository()
     private static IRepository<AIOperation, Guid> CreateEmptyOperationRepository()
     {
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
-        operationRepository
-            .GetListAsync()
-            .Returns(Task.FromResult(new List<AIOperation>()));
         operationRepository
             .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
             .Returns(Task.FromResult(new List<AIOperation>()));
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
index a16bbd6979..f6777935b1 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIRuntimeServiceTests.cs
@@ -38,8 +38,8 @@ private static OpenAIConfigurationResolver CreateResolverWithNoOperations()
 
         var operationRepository = Substitute.For<IRepository<AIOperation, Guid>>();
         operationRepository
-            .GetQueryableAsync()
-            .Returns(Task.FromResult<IQueryable<AIOperation>>(new List<AIOperation>().AsQueryable()));
+            .GetListAsync(Arg.Any<Expression<Func<AIOperation, bool>>>())
+            .Returns(Task.FromResult(new List<AIOperation>()));
 
         var promptRepository = Substitute.For<IRepository<AIPrompt, Guid>>();
         var configuration = new Microsoft.Extensions.Configuration.ConfigurationBuilder().Build();

From 47cb3548e6665631e6fdb36f2dd37bc8bf5820db Mon Sep 17 00:00:00 2001
From: Jacob Smith <jacob.smith@gov.bc.ca>
Date: Fri, 3 Jul 2026 16:09:41 -0700
Subject: [PATCH 54/61] AB#32307 fix AI test nullability warnings

---
 .../AIProviderPayloadValidatorTests.cs        | 20 ++++++++++++++-----
 .../AI/Runtime/OpenAIResponseParserTests.cs   |  4 +++-
 2 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
index 0805ee495a..acf0bb3cf4 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/AIProviderPayloadValidatorTests.cs
@@ -14,7 +14,9 @@ public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_For_Inva
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("not valid JSON");
+        var reason = result.Reason;
+        reason.ShouldNotBeNull();
+        reason.ShouldContain("not valid JSON");
     }
 
     [Fact]
@@ -32,7 +34,9 @@ public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_Dec
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("decision");
+        var reason = result.Reason;
+        reason.ShouldNotBeNull();
+        reason.ShouldContain("decision");
     }
 
     [Fact]
@@ -110,7 +114,9 @@ public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_All
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("summaries");
+        var reason = result.Reason;
+        reason.ShouldNotBeNull();
+        reason.ShouldContain("summaries");
     }
 
     [Fact]
@@ -131,7 +137,9 @@ public void ValidateApplicationAnalysisJson_Should_Return_InvalidOutput_When_Rec
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("recommendations");
+        var reason = result.Reason;
+        reason.ShouldNotBeNull();
+        reason.ShouldContain("recommendations");
     }
 
     [Fact]
@@ -162,6 +170,8 @@ public void ValidateAttachmentSummaryText_Should_Return_InvalidOutput_For_Empty_
 
         result.IsValid.ShouldBeFalse();
         result.FailureCategory.ShouldBe(AIFailureCategory.InvalidOutput);
-        result.Reason.ShouldContain("empty");
+        var reason = result.Reason;
+        reason.ShouldNotBeNull();
+        reason.ShouldContain("empty");
     }
 }
diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs
index 5111f7a81f..1fcb796ab5 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/AI/Runtime/OpenAIResponseParserTests.cs
@@ -121,7 +121,9 @@ public void ParseApplicationScoringResponse_Should_Parse_Mixed_Answer_Types_From
         result.Answers.ShouldContainKey("q3");
         result.Answers["q1"].Answer.GetInt32().ShouldBe(0);
         result.Answers["q2"].Answer.GetString().ShouldBe("4");
-        result.Answers["q3"].Answer.GetString().ShouldContain("food security");
+        var q3Answer = result.Answers["q3"].Answer.GetString();
+        q3Answer.ShouldNotBeNull();
+        q3Answer.ShouldContain("food security");
     }
 
     [Fact]

From 80d094a775c568e001454e05428c8e87a45085ad Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 6 Jul 2026 09:26:38 -0700
Subject: [PATCH 55/61] [AB#33555] Re-apply EF migration

---
 ...lStatusVisibilityToApplication.Designer.cs | 5239 -----------------
 ...ddExternalStatusVisibilityToApplication.cs |   29 -
 .../GrantTenantDbContextModelSnapshot.cs      |  168 +-
 3 files changed, 3 insertions(+), 5433 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
 delete mode 100644 applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
deleted file mode 100644
index c7835d268d..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.Designer.cs
+++ /dev/null
@@ -1,5239 +0,0 @@
-// <auto-generated />
-using System;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Infrastructure;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-using Unity.GrantManager.EntityFrameworkCore;
-using Volo.Abp.EntityFrameworkCore;
-
-#nullable disable
-
-namespace Unity.GrantManager.Migrations.TenantMigrations
-{
-    [DbContext(typeof(GrantTenantDbContext))]
-    [Migration("20260630150247_AB33555_AddExternalStatusVisibilityToApplication")]
-    partial class AB33555_AddExternalStatusVisibilityToApplication
-    {
-        /// <inheritdoc />
-        protected override void BuildTargetModel(ModelBuilder modelBuilder)
-        {
-#pragma warning disable 612, 618
-            modelBuilder
-                .HasAnnotation("_Abp_DatabaseProvider", EfCoreDatabaseProvider.PostgreSql)
-                .HasAnnotation("ProductVersion", "10.0.3")
-                .HasAnnotation("Relational:MaxIdentifierLength", 63);
-
-            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Value")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ScoresheetId");
-
-                    b.ToTable("ScoresheetInstances", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("QuestionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ScoresheetInstanceId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("QuestionId");
-
-                    b.HasIndex("ScoresheetInstanceId");
-
-                    b.ToTable("Answers", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("Enabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<string>("Label")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("SectionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SectionId");
-
-                    b.ToTable("Questions", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsArchived")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Scoresheets", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ScoresheetId");
-
-                    b.ToTable("ScoresheetSections", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid>("CustomFieldId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("WorksheetInstanceId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetInstanceId");
-
-                    b.ToTable("CustomFieldValues", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("CurrentValue")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UiAnchor")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetCorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("WorksheetCorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("WorksheetInstances", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<long?>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UiAnchor")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetId");
-
-                    b.ToTable("WorksheetLinks", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("Enabled")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<string>("Key")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Label")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid>("SectionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SectionId");
-
-                    b.ToTable("CustomFields", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsArchived")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Version")
-                        .HasColumnType("bigint");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Worksheets", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Definition")
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<long>("Order")
-                        .HasColumnType("bigint");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("WorksheetId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("WorksheetId");
-
-                    b.ToTable("WorksheetSections", "Flex");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicantName")
-                        .IsRequired()
-                        .HasMaxLength(600)
-                        .HasColumnType("character varying(600)");
-
-                    b.Property<string>("ApproxNumberOfEmployees")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("BusinessNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FiscalDay")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("FiscalMonth")
-                        .HasColumnType("text");
-
-                    b.Property<string>("FundingHistoryComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IndigenousOrgInd")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDuplicated")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("IssueTrackingComments")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<decimal?>("MatchPercentage")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("NonRegOrgName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("NonRegisteredBusinessName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrgStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("OrganizationType")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("RedStop")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportsComments")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Sector")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SectorSubSectorIndustryDesc")
-                        .HasColumnType("text");
-
-                    b.Property<DateOnly?>("StartedOperatingDate")
-                        .HasColumnType("date");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubSector")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("SupplierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("UnityApplicantId")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantName");
-
-                    b.HasIndex("OrgName");
-
-                    b.HasIndex("OrgNumber");
-
-                    b.HasIndex("Status");
-
-                    b.HasIndex("SupplierId");
-
-                    b.HasIndex("TenantId");
-
-                    b.HasIndex("UnityApplicantId");
-
-                    b.HasIndex("TenantId", "IsDeleted", "CreationTime")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("Applicants", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("AddressType")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("Country")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Postal")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Street")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Street2")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Unit")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicantAddresses", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("BceidBusinessGuid")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BceidBusinessName")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("BceidUserGuid")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BceidUserName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<int>("ContactOrder")
-                        .HasColumnType("integer");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IdentityEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IdentityName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IdentityProvider")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsConfirmed")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("OidcSubUser")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone2")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Phone2Extension")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PhoneExtension")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RoleForApplicant")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationId")
-                        .IsUnique();
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicantAgents", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("ApplicantAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AIAnalysis")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AIScoresheetAnswers")
-                        .HasColumnType("jsonb");
-
-                    b.Property<string>("Acquisition")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicantElectoralDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal>("ApprovedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<DateTime?>("AssessmentResultDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("AssessmentResultStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("AssessmentStartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Community")
-                        .HasColumnType("text");
-
-                    b.Property<int?>("CommunityPopulation")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime?>("ContractExecutionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ContractNumber")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DeclineRational")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("DefaultSiteId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime?>("DueDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("DueDiligenceStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("EconomicRegion")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ElectoralDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("ExternalStatusVisibility")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("FinalDecisionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("Forestry")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ForestryFocus")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LikelihoodOfFunding")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Notes")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("NotificationDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("OwnerId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Payload")
-                        .HasColumnType("jsonb");
-
-                    b.Property<double?>("PercentageTotalProjectBudget")
-                        .HasColumnType("double precision");
-
-                    b.Property<string>("Place")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("ProjectEndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal?>("ProjectFundingTotal")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ProjectName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<DateTime?>("ProjectStartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ProjectSummary")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("ProposalDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal>("RecommendedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ReferenceNo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("RegionalDistrict")
-                        .HasColumnType("text");
-
-                    b.Property<decimal>("RequestedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("RiskRanking")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityBusinessPhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityCellPhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityFullName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SigningAuthorityTitle")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("SubmissionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal>("TotalProjectBudget")
-                        .HasColumnType("numeric");
-
-                    b.Property<int?>("TotalScore")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("UnityApplicationId")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.HasIndex("ApplicationStatusId");
-
-                    b.HasIndex("OwnerId");
-
-                    b.HasIndex("ReferenceNo");
-
-                    b.HasIndex("TenantId", "SubmissionDate")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("Applications", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssigneeId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Duty")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("AssigneeId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationAssignments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AISummary")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChefsFileId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsSubmissionId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationChefsFileAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContactEmail")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactFullName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactMobilePhone")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactTitle")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ContactWorkPhone")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.ToTable("ApplicationContact", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("AccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApiKey")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicationFormDescription")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ApplicationFormName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<DateTime?>("AttemptedConnectionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<bool>("AutomaticallyGenerateAIAnalysis")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("AvailableChefsFields")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Category")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsApplicationFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsCriteriaFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ConnectionHttpStatus")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<int?>("DefaultPaymentGroup")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<int?>("ElectoralDistrictAddressType")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FormHierarchy")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid>("IntakeId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<bool>("IsDirectApproval")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<bool>("ManuallyInitiateAIAnalysis")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("ParentFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("Payable")
-                        .HasColumnType("boolean");
-
-                    b.Property<decimal?>("PaymentApprovalThreshold")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("Prefix")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<bool>("PreventPayment")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("ScoresheetId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int?>("SuffixType")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int?>("Version")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("IntakeId");
-
-                    b.HasIndex("ParentFormId");
-
-                    b.HasIndex("TenantId", "IsDeleted")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("ApplicationForms", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicationFormVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChefsSubmissionGuid")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid?>("FormVersionId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("OidcSub")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportData")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<string>("Submission")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.ToTable("ApplicationFormSubmissions", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationFormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AvailableChefsFields")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsApplicationFormGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChefsFormVersionGuid")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FormSchema")
-                        .HasColumnType("jsonb");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<bool>("Published")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ReportColumns")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportKeys")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReportViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SubmissionHeaderMapping")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int?>("Version")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationFormId");
-
-                    b.ToTable("ApplicationFormVersion", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LinkType")
-                        .IsRequired()
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("text")
-                        .HasDefaultValue("Related");
-
-                    b.Property<Guid>("LinkedApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationLinks", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExternalStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("InternalStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("NotifiedStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("StatusCode")
-                        .IsRequired()
-                        .HasMaxLength(250)
-                        .HasColumnType("character varying(250)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("StatusCode")
-                        .IsUnique();
-
-                    b.ToTable("ApplicationStatuses", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("TagId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("TagId");
-
-                    b.HasIndex("TenantId", "ApplicationId");
-
-                    b.ToTable("ApplicationTags", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AssessmentId");
-
-                    b.ToTable("AssessmentAttachments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("AuditDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("AuditNote")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditTrackingNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AuditorName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("AuditHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal?>("ApprovedAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FundingNotes")
-                        .HasColumnType("text");
-
-                    b.Property<string>("FundingYear")
-                        .HasColumnType("text");
-
-                    b.Property<string>("GrantCategory")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<decimal?>("OneTimeConsideration")
-                        .HasColumnType("numeric");
-
-                    b.Property<DateTime?>("PaidDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<decimal?>("ReconsiderationAmount")
-                        .HasColumnType("numeric");
-
-                    b.Property<bool?>("RenewedFunding")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal?>("TotalGrantAmount")
-                        .HasColumnType("numeric");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("FundingHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IssueDescription")
-                        .HasColumnType("text");
-
-                    b.Property<string>("IssueHeading")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("ResolutionNote")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("Resolved")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Year")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("IssueTrackings", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FiscalYear")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("IncompleteReport")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Note")
-                        .HasColumnType("text");
-
-                    b.Property<bool?>("Outstanding")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("ReportDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.ToTable("ReportsHistories", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool?>("ApprovalRecommended")
-                        .HasColumnType("boolean");
-
-                    b.Property<Guid>("AssessorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int?>("CleanGrowth")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<int?>("EconomicImpact")
-                        .HasColumnType("integer");
-
-                    b.Property<DateTime?>("EndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<int?>("FinancialAnalysis")
-                        .HasColumnType("integer");
-
-                    b.Property<int?>("InclusiveGrowth")
-                        .HasColumnType("integer");
-
-                    b.Property<bool>("IsAiAssessment")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsComplete")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("AssessorId");
-
-                    b.ToTable("Assessments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicantId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("ApplicantComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("ApplicationComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Comment")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CommenterId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("PinDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AssessmentId");
-
-                    b.HasIndex("CommenterId");
-
-                    b.ToTable("AssessmentComments", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.Contact", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("HomePhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MobilePhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Title")
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<string>("WorkPhoneExtension")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<string>("WorkPhoneNumber")
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Contacts", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<Guid>("ContactId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsPrimary")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("RelatedEntityId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("RelatedEntityType")
-                        .IsRequired()
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<string>("Role")
-                        .HasMaxLength(100)
-                        .HasColumnType("character varying(100)");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("RelatedEntityType", "RelatedEntityId");
-
-                    b.HasIndex("ContactId", "RelatedEntityType", "RelatedEntityId");
-
-                    b.ToTable("ContactLinks", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.GlobalTag.Tag", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Tags", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Identity.Person", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("Badge")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FullName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("OidcDisplayName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("OidcSub")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("OidcSub");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("Persons", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Intakes.Intake", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<double>("Budget")
-                        .HasColumnType("double precision");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<DateTime>("EndDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("IntakeName")
-                        .IsRequired()
-                        .HasMaxLength(255)
-                        .HasColumnType("character varying(255)");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime>("StartDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Intakes", (string)null);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("character varying(1000)");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("DateField")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime>("NotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CreationTime");
-
-                    b.HasIndex("ScheduledNotificationId");
-
-                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
-                        .IsUnique();
-
-                    b.ToTable("ScheduledNotificationTracking", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Type")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailGroups", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("GroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("GroupId");
-
-                    b.ToTable("EmailGroupUsers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLog", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicantId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("AssessmentId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BCC")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Body")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("BodyType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("CC")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChesHttpStatusCode")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("ChesMsgId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ChesResponse")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ChesStatus")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("EmailType")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FromAddress")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("PaymentRequestIds")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Priority")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Recipient")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
-                    b.Property<int>("RetryAttempts")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("SendOnDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<DateTime?>("SentDateTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("Status")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subject")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Tag")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("TemplateName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("ToAddress")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailLogs", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContentType")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DisplayName")
-                        .HasMaxLength(1024)
-                        .HasColumnType("character varying(1024)");
-
-                    b.Property<Guid>("EmailLogId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FileName")
-                        .HasColumnType("text");
-
-                    b.Property<long>("FileSize")
-                        .HasColumnType("bigint");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("S3ObjectKey")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<DateTime>("Time")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("EmailLogId");
-
-                    b.HasIndex("S3ObjectKey");
-
-                    b.ToTable("EmailLogAttachments", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.EmailTemplate", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BodyHTML")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("BodyText")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SendFrom")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subject")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("EmailTemplates", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.Subscriber", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Email")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FirstName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("LastName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Subscribers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroup", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("SubscriptionGroups", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid?>("GroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("SubscriberId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("GroupId");
-
-                    b.HasIndex("SubscriberId");
-
-                    b.ToTable("SubscriptionGroupSubscribers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TemplateVariable", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MapTo")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("Token")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("TemplateVariables", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.Trigger", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("Active")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("InternalName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Name")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Triggers", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("SubscriptionGroupId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("TemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<Guid>("TriggerId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SubscriptionGroupId");
-
-                    b.HasIndex("TemplateId");
-
-                    b.HasIndex("TriggerId");
-
-                    b.ToTable("TriggerSubscriptions", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.AccountCodings.AccountCoding", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("Description")
-                        .HasMaxLength(35)
-                        .HasColumnType("character varying(35)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("MinistryClient")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProjectNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Responsibility")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("ServiceLine")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("Stob")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("AccountCodings", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentConfigurations.PaymentConfiguration", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DefaultAccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("PaymentIdPrefix")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("PaymentConfigurations", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("DecisionDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("DecisionUserId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("PaymentRequestId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("Status")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<int>("Type")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PaymentRequestId");
-
-                    b.ToTable("ExpenseApprovals", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("AccountCodingId")
-                        .HasColumnType("uuid");
-
-                    b.Property<decimal>("Amount")
-                        .HasColumnType("numeric");
-
-                    b.Property<string>("BatchName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<decimal>("BatchNumber")
-                        .HasColumnType("numeric");
-
-                    b.Property<int?>("CasHttpStatusCode")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("CasResponse")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<string>("ContractNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<string>("FsbApNotified")
-                        .HasMaxLength(10)
-                        .HasColumnType("character varying(10)");
-
-                    b.Property<Guid?>("FsbNotificationEmailLogId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime?>("FsbNotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("InvoiceNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("InvoiceStatus")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<bool>("IsRecon")
-                        .HasColumnType("boolean");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Note")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PayeeName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentDate")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PaymentStatus")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ReferenceNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("RequesterName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("SiteId")
-                        .HasColumnType("uuid");
-
-                    b.Property<int>("Status")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("SubmissionConfirmationCode")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierName")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierNumber")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("AccountCodingId");
-
-                    b.HasIndex("CorrelationId");
-
-                    b.HasIndex("CreationTime");
-
-                    b.HasIndex("FsbNotificationEmailLogId");
-
-                    b.HasIndex("ReferenceNumber")
-                        .IsUnique();
-
-                    b.HasIndex("SiteId");
-
-                    b.HasIndex("Status");
-
-                    b.HasIndex("TenantId", "CreationTime")
-                        .HasFilter("\"IsDeleted\" = false");
-
-                    b.ToTable("PaymentRequests", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid>("PaymentRequestId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("TagId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("PaymentRequestId");
-
-                    b.HasIndex("TagId");
-
-                    b.ToTable("PaymentTags", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentThresholds.PaymentThreshold", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("Description")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<decimal?>("Threshold")
-                        .HasColumnType("numeric");
-
-                    b.Property<Guid?>("UserId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("PaymentThresholds", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("AddressLine1")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AddressLine2")
-                        .HasColumnType("text");
-
-                    b.Property<string>("AddressLine3")
-                        .HasColumnType("text");
-
-                    b.Property<string>("BankAccount")
-                        .HasColumnType("text");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Country")
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("EFTAdvicePref")
-                        .HasColumnType("text");
-
-                    b.Property<string>("EmailAddress")
-                        .HasColumnType("text");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("LastUpdatedInCas")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<bool>("MarkDeletedInUse")
-                        .HasColumnType("boolean");
-
-                    b.Property<string>("Number")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("PaymentGroup")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("PostalCode")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SiteProtected")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<Guid>("SupplierId")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("SupplierId");
-
-                    b.ToTable("Sites", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("BusinessNumber")
-                        .HasColumnType("text");
-
-                    b.Property<string>("City")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<DateTime?>("LastUpdatedInCAS")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<string>("MailingAddress")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Name")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Number")
-                        .HasColumnType("text");
-
-                    b.Property<string>("PostalCode")
-                        .HasColumnType("text");
-
-                    b.Property<string>("ProviderId")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Province")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SIN")
-                        .HasColumnType("text");
-
-                    b.Property<string>("StandardIndustryClassification")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Status")
-                        .HasColumnType("text");
-
-                    b.Property<string>("Subcategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("SupplierProtected")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("Suppliers", "Payments");
-                });
-
-            modelBuilder.Entity("Unity.Reporting.Domain.Configuration.ReportColumnsMap", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("CorrelationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("CorrelationProvider")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("Mapping")
-                        .IsRequired()
-                        .HasColumnType("jsonb");
-
-                    b.Property<int>("RoleStatus")
-                        .HasColumnType("integer");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("ViewName")
-                        .IsRequired()
-                        .HasColumnType("text");
-
-                    b.Property<int>("ViewStatus")
-                        .HasColumnType("integer");
-
-                    b.HasKey("Id");
-
-                    b.ToTable("ReportColumnsMaps", "Reporting");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
-                        .WithMany("Instances")
-                        .HasForeignKey("ScoresheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Scoresheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Answer", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Question", "Question")
-                        .WithMany("Answers")
-                        .HasForeignKey("QuestionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", null)
-                        .WithMany("Answers")
-                        .HasForeignKey("ScoresheetInstanceId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Question");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.ScoresheetSection", "Section")
-                        .WithMany("Fields")
-                        .HasForeignKey("SectionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Section");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Scoresheets.Scoresheet", "Scoresheet")
-                        .WithMany("Sections")
-                        .HasForeignKey("ScoresheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Scoresheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.CustomFieldValue", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", null)
-                        .WithMany("Values")
-                        .HasForeignKey("WorksheetInstanceId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetLinks.WorksheetLink", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
-                        .WithMany("Links")
-                        .HasForeignKey("WorksheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Worksheet");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.CustomField", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.WorksheetSection", "Section")
-                        .WithMany("Fields")
-                        .HasForeignKey("SectionId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Section");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.HasOne("Unity.Flex.Domain.Worksheets.Worksheet", "Worksheet")
-                        .WithMany("Sections")
-                        .HasForeignKey("WorksheetId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Worksheet");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAddress", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
-                        .WithMany("ApplicantAddresses")
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicantAddresses")
-                        .HasForeignKey("ApplicationId");
-
-                    b.Navigation("Applicant");
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAgent", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithOne("ApplicantAgent")
-                        .HasForeignKey("Unity.GrantManager.Applications.ApplicantAgent", "ApplicationId");
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicantAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", "Applicant")
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", "ApplicationForm")
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationStatus", "ApplicationStatus")
-                        .WithMany("Applications")
-                        .HasForeignKey("ApplicationStatusId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", "Owner")
-                        .WithMany()
-                        .HasForeignKey("OwnerId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("Applicant");
-
-                    b.Navigation("ApplicationForm");
-
-                    b.Navigation("ApplicationStatus");
-
-                    b.Navigation("Owner");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAssignment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicationAssignments")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", "Assignee")
-                        .WithMany()
-                        .HasForeignKey("AssigneeId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-
-                    b.Navigation("Assignee");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationChefsFileAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationContact", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationForm", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Intakes.Intake", null)
-                        .WithMany()
-                        .HasForeignKey("IntakeId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ParentFormId")
-                        .OnDelete(DeleteBehavior.NoAction);
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormSubmission", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationFormVersion", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.ApplicationForm", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationFormId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationLink", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany("ApplicationLinks")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationTags", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("ApplicationTags")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
-                        .WithMany()
-                        .HasForeignKey("TagId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-
-                    b.Navigation("Tag");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AssessmentAttachment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
-                        .WithMany()
-                        .HasForeignKey("AssessmentId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.AuditHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.FundingHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.IssueTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ReportsHistory", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Assessments.Assessment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", "Application")
-                        .WithMany("Assessments")
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("AssessorId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Application");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicantComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Applicant", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicantId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.ApplicationComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Comments.AssessmentComment", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Assessments.Assessment", null)
-                        .WithMany()
-                        .HasForeignKey("AssessmentId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Identity.Person", null)
-                        .WithMany()
-                        .HasForeignKey("CommenterId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Contacts.ContactLink", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Contacts.Contact", null)
-                        .WithMany()
-                        .HasForeignKey("ContactId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
-                        .WithMany()
-                        .HasForeignKey("ScheduledNotificationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
-                {
-                    b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)
-                        .WithMany()
-                        .HasForeignKey("GroupId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Emails.EmailLogAttachment", b =>
-                {
-                    b.HasOne("Unity.Notifications.Emails.EmailLog", null)
-                        .WithMany()
-                        .HasForeignKey("EmailLogId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.SubscriptionGroupSubscription", b =>
-                {
-                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
-                        .WithMany()
-                        .HasForeignKey("GroupId");
-
-                    b.HasOne("Unity.Notifications.Templates.Subscriber", "Subscriber")
-                        .WithMany()
-                        .HasForeignKey("SubscriberId");
-
-                    b.Navigation("Subscriber");
-
-                    b.Navigation("SubscriptionGroup");
-                });
-
-            modelBuilder.Entity("Unity.Notifications.Templates.TriggerSubscription", b =>
-                {
-                    b.HasOne("Unity.Notifications.Templates.SubscriptionGroup", "SubscriptionGroup")
-                        .WithMany()
-                        .HasForeignKey("SubscriptionGroupId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Notifications.Templates.EmailTemplate", "EmailTemplate")
-                        .WithMany()
-                        .HasForeignKey("TemplateId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.Notifications.Templates.Trigger", "Trigger")
-                        .WithMany()
-                        .HasForeignKey("TriggerId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("EmailTemplate");
-
-                    b.Navigation("SubscriptionGroup");
-
-                    b.Navigation("Trigger");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.ExpenseApproval", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", "PaymentRequest")
-                        .WithMany("ExpenseApprovals")
-                        .HasForeignKey("PaymentRequestId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("PaymentRequest");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.AccountCodings.AccountCoding", "AccountCoding")
-                        .WithMany()
-                        .HasForeignKey("AccountCodingId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.HasOne("Unity.Payments.Domain.Suppliers.Site", "Site")
-                        .WithMany()
-                        .HasForeignKey("SiteId")
-                        .OnDelete(DeleteBehavior.NoAction);
-
-                    b.Navigation("AccountCoding");
-
-                    b.Navigation("Site");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentTags.PaymentTag", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.PaymentRequests.PaymentRequest", null)
-                        .WithMany("PaymentTags")
-                        .HasForeignKey("PaymentRequestId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.GlobalTag.Tag", "Tag")
-                        .WithMany()
-                        .HasForeignKey("TagId")
-                        .OnDelete(DeleteBehavior.NoAction)
-                        .IsRequired();
-
-                    b.Navigation("Tag");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Site", b =>
-                {
-                    b.HasOne("Unity.Payments.Domain.Suppliers.Supplier", "Supplier")
-                        .WithMany("Sites")
-                        .HasForeignKey("SupplierId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.Navigation("Supplier");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.ScoresheetInstances.ScoresheetInstance", b =>
-                {
-                    b.Navigation("Answers");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Question", b =>
-                {
-                    b.Navigation("Answers");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.Scoresheet", b =>
-                {
-                    b.Navigation("Instances");
-
-                    b.Navigation("Sections");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Scoresheets.ScoresheetSection", b =>
-                {
-                    b.Navigation("Fields");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.WorksheetInstances.WorksheetInstance", b =>
-                {
-                    b.Navigation("Values");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.Worksheet", b =>
-                {
-                    b.Navigation("Links");
-
-                    b.Navigation("Sections");
-                });
-
-            modelBuilder.Entity("Unity.Flex.Domain.Worksheets.WorksheetSection", b =>
-                {
-                    b.Navigation("Fields");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Applicant", b =>
-                {
-                    b.Navigation("ApplicantAddresses");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.Application", b =>
-                {
-                    b.Navigation("ApplicantAddresses");
-
-                    b.Navigation("ApplicantAgent");
-
-                    b.Navigation("ApplicationAssignments");
-
-                    b.Navigation("ApplicationLinks");
-
-                    b.Navigation("ApplicationTags");
-
-                    b.Navigation("Assessments");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Applications.ApplicationStatus", b =>
-                {
-                    b.Navigation("Applications");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.PaymentRequests.PaymentRequest", b =>
-                {
-                    b.Navigation("ExpenseApprovals");
-
-                    b.Navigation("PaymentTags");
-                });
-
-            modelBuilder.Entity("Unity.Payments.Domain.Suppliers.Supplier", b =>
-                {
-                    b.Navigation("Sites");
-                });
-#pragma warning restore 612, 618
-        }
-    }
-}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs
deleted file mode 100644
index dde7768fba..0000000000
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/20260630150247_AB33555_AddExternalStatusVisibilityToApplication.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace Unity.GrantManager.Migrations.TenantMigrations
-{
-    /// <inheritdoc />
-    public partial class AB33555_AddExternalStatusVisibilityToApplication : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<bool>(
-                name: "ExternalStatusVisibility",
-                table: "Applications",
-                type: "boolean",
-                nullable: false,
-                defaultValue: false);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropColumn(
-                name: "ExternalStatusVisibility",
-                table: "Applications");
-        }
-    }
-}
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
index f702d3824d..3748b703dd 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/Migrations/TenantMigrations/GrantTenantDbContextModelSnapshot.cs
@@ -886,6 +886,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("OrgStatus")
                         .HasColumnType("text");
 
+                    b.Property<string>("OrganizationSize")
+                        .HasColumnType("text");
+
                     b.Property<string>("OrganizationType")
                         .HasColumnType("text");
 
@@ -1290,9 +1293,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Property<string>("ElectoralDistrict")
                         .HasColumnType("text");
 
-                    b.Property<bool>("ExternalStatusVisibility")
-                        .HasColumnType("boolean");
-
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -3050,142 +3050,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("Intakes", (string)null);
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotification", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ApplicationStatus")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("ApplicationStatusId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("ConcurrencyStamp")
-                        .IsConcurrencyToken()
-                        .IsRequired()
-                        .HasMaxLength(40)
-                        .HasColumnType("character varying(40)")
-                        .HasColumnName("ConcurrencyStamp");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("CreationTime");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("CreatorId");
-
-                    b.Property<string>("DateField")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<Guid?>("DeleterId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("DeleterId");
-
-                    b.Property<DateTime?>("DeletionTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("DeletionTime");
-
-                    b.Property<Guid>("EmailTemplateId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("EventType")
-                        .HasMaxLength(128)
-                        .HasColumnType("character varying(128)");
-
-                    b.Property<string>("ExtraProperties")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("ExtraProperties");
-
-                    b.Property<Guid>("FormId")
-                        .HasColumnType("uuid");
-
-                    b.Property<bool>("IsActive")
-                        .HasColumnType("boolean");
-
-                    b.Property<bool>("IsDeleted")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnType("boolean")
-                        .HasDefaultValue(false)
-                        .HasColumnName("IsDeleted");
-
-                    b.Property<DateTime?>("LastModificationTime")
-                        .HasColumnType("timestamp without time zone")
-                        .HasColumnName("LastModificationTime");
-
-                    b.Property<Guid?>("LastModifierId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("LastModifierId");
-
-                    b.Property<string>("RecipientCategory")
-                        .HasColumnType("text");
-
-                    b.Property<string>("RecipientIdentifier")
-                        .HasColumnType("text");
-
-                    b.Property<Guid?>("TenantId")
-                        .HasColumnType("uuid")
-                        .HasColumnName("TenantId");
-
-                    b.Property<string>("TriggerDetail")
-                        .HasMaxLength(1000)
-                        .HasColumnType("character varying(1000)");
-
-                    b.Property<string>("TriggerType")
-                        .IsRequired()
-                        .HasMaxLength(64)
-                        .HasColumnType("character varying(64)");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("TenantId");
-
-                    b.ToTable("ScheduledNotifications", "Notifications");
-                });
-
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.Property<Guid>("Id")
-                        .HasColumnType("uuid");
-
-                    b.Property<Guid>("ApplicationId")
-                        .HasColumnType("uuid");
-
-                    b.Property<DateTime>("CreationTime")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid?>("CreatorId")
-                        .HasColumnType("uuid");
-
-                    b.Property<string>("DateField")
-                        .IsRequired()
-                        .HasMaxLength(50)
-                        .HasColumnType("character varying(50)");
-
-                    b.Property<DateTime>("NotificationSentDate")
-                        .HasColumnType("timestamp without time zone");
-
-                    b.Property<Guid>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
-                    b.HasKey("Id");
-
-                    b.HasIndex("ApplicationId");
-
-                    b.HasIndex("CreationTime");
-
-                    b.HasIndex("ScheduledNotificationId");
-
-                    b.HasIndex("ApplicationId", "ScheduledNotificationId", "DateField")
-                        .IsUnique();
-
-                    b.ToTable("ScheduledNotificationTracking", "Notifications");
-                });
-
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroup", b =>
                 {
                     b.Property<Guid>("Id")
@@ -3352,10 +3216,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .HasColumnType("uuid")
                         .HasColumnName("CreatorId");
 
-                    b.Property<string>("EmailType")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
                     b.Property<string>("ExtraProperties")
                         .IsRequired()
                         .HasColumnType("text")
@@ -3381,16 +3241,9 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired()
                         .HasColumnType("text");
 
-                    b.Property<string>("Recipient")
-                        .HasMaxLength(32)
-                        .HasColumnType("character varying(32)");
-
                     b.Property<int>("RetryAttempts")
                         .HasColumnType("integer");
 
-                    b.Property<Guid?>("ScheduledNotificationId")
-                        .HasColumnType("uuid");
-
                     b.Property<DateTime?>("SendOnDateTime")
                         .HasColumnType("timestamp without time zone");
 
@@ -5024,21 +4877,6 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                         .IsRequired();
                 });
 
-            modelBuilder.Entity("Unity.GrantManager.Notifications.ScheduledNotificationTracking", b =>
-                {
-                    b.HasOne("Unity.GrantManager.Applications.Application", null)
-                        .WithMany()
-                        .HasForeignKey("ApplicationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-
-                    b.HasOne("Unity.GrantManager.Notifications.ScheduledNotification", null)
-                        .WithMany()
-                        .HasForeignKey("ScheduledNotificationId")
-                        .OnDelete(DeleteBehavior.Cascade)
-                        .IsRequired();
-                });
-
             modelBuilder.Entity("Unity.Notifications.EmailGroups.EmailGroupUser", b =>
                 {
                     b.HasOne("Unity.Notifications.EmailGroups.EmailGroup", null)

From 98b82f0b129995968825a6f764009bf14294f576 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 6 Jul 2026 10:29:32 -0700
Subject: [PATCH 56/61] [AB#33555] Optimize Details Action Bar

---
 .../GrantApplicationLiteDto.cs                |  1 +
 .../IGrantApplicationAppService.cs            |  1 +
 .../GrantApplicationAppService.cs             | 29 +++++++++++++++++--
 .../DetailsActionBar/DetailsActionBar.cs      | 21 ++++----------
 4 files changed, 35 insertions(+), 17 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationLiteDto.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationLiteDto.cs
index 0d9267bc8c..ae10638d09 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationLiteDto.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/GrantApplicationLiteDto.cs
@@ -11,4 +11,5 @@ public class GrantApplicationLiteDto : AuditedEntityDto<Guid>
     public string OrganizationName { get; set; } = string.Empty;
     public string UnityApplicantId { get; set; } = string.Empty;
     public string UnityApplicationId { get; set; } = string.Empty;
+    public bool ExternalStatusVisibility { get; set; } = false;
 }
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
index 2cecd069ab..8064a1f3ba 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/GrantApplications/IGrantApplicationAppService.cs
@@ -18,6 +18,7 @@ public interface IGrantApplicationAppService
     Task<List<GrantApplicationLiteDto>> GetAllApplicationsAsync();
     Task<IList<GrantApplicationDto>> GetApplicationDetailsListAsync(List<Guid> applicationIds);
     Task<GrantApplicationDto> GetAsync(Guid id);
+    Task<GrantApplicationLiteDto> GetBasicAsync(Guid id);
     Task<GrantApplicationDto> TriggerAction(Guid applicationId, GrantApplicationAction triggerAction);
     Task<AIGenerationStatusDto> QueueAIGenerationAsync(Guid applicationId, string? promptVersion = null);
     Task<AIGenerationStatusDto> QueueApplicationAnalysisAsync(Guid applicationId, string? promptVersion = null);
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
index b1bd1fcad9..ac8225770f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantApplications/GrantApplicationAppService.cs
@@ -29,6 +29,7 @@
 using Unity.GrantManager.Payments;
 using Unity.Modules.Shared;
 using Unity.Modules.Shared.Correlation;
+using Unity.Modules.Shared.Specializations;
 using Unity.Payments.PaymentRequests;
 using Volo.Abp;
 using Volo.Abp.Application.Dtos;
@@ -37,7 +38,6 @@
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.Domain.Repositories;
 using Volo.Abp.Features;
-using Unity.Modules.Shared.Specializations;
 
 namespace Unity.GrantManager.GrantApplications;
 
@@ -1393,12 +1393,37 @@ from applicant in applicantGroup.DefaultIfEmpty()
                         UnityApplicationId = applications.UnityApplicationId ?? string.Empty,
                         ApplicantName = applicant != null ? (applicant.ApplicantName ?? GrantManagerConsts.UnknownValue) : GrantManagerConsts.UnknownValue,
                         OrganizationName = applicant != null ? (applicant.OrgName ?? string.Empty) : string.Empty,
-                        UnityApplicantId = applicant != null ? (applicant.UnityApplicantId ?? string.Empty) : string.Empty
+                        UnityApplicantId = applicant != null ? (applicant.UnityApplicantId ?? string.Empty) : string.Empty,
+                        ExternalStatusVisibility = applications.ExternalStatusVisibility
                     };
 
         return await query.ToListAsync();
     }
 
+    public async Task<GrantApplicationLiteDto> GetBasicAsync(Guid id)
+    {
+        var applicationsQuery = await applicationRepository.GetQueryableAsync();
+        var applicantsQuery = await applicantRepository.GetQueryableAsync();
+
+        var query = from applications in applicationsQuery
+                    join applicant in applicantsQuery on applications.ApplicantId equals applicant.Id into applicantGroup
+                    from applicant in applicantGroup.DefaultIfEmpty()
+                    where applications.Id == id
+                    select new GrantApplicationLiteDto
+                    {
+                        Id = applications.Id,
+                        ProjectName = applications.ProjectName,
+                        ReferenceNo = applications.ReferenceNo,
+                        UnityApplicationId = applications.UnityApplicationId ?? string.Empty,
+                        ApplicantName = applicant != null ? (applicant.ApplicantName ?? GrantManagerConsts.UnknownValue) : GrantManagerConsts.UnknownValue,
+                        OrganizationName = applicant != null ? (applicant.OrgName ?? string.Empty) : string.Empty,
+                        UnityApplicantId = applicant != null ? (applicant.UnityApplicantId ?? string.Empty) : string.Empty,
+                        ExternalStatusVisibility = applications.ExternalStatusVisibility
+                    };
+
+        return await query.FirstOrDefaultAsync() ?? throw new EntityNotFoundException();
+    }
+
     private static Dictionary<string, object> ExtractCustomFieldsForWorksheet(dynamic customFields, Guid worksheetId)
     {
         var result = new Dictionary<string, object>();
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
index dc9893a026..34c4a29f37 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/DetailsActionBar/DetailsActionBar.cs
@@ -11,32 +11,23 @@ namespace Unity.GrantManager.Web.Views.Shared.Components.DetailsActionBar;
 
 [Widget(ScriptFiles = new[] { "/Views/Shared/Components/DetailsActionBar/Default.js" , "/Pages/ApplicationTags/ApplicationTags.js" },
     StyleFiles = new[] { "/Views/Shared/Components/ActionBar/Default.css" })]
-public class DetailsActionBar : AbpViewComponent
+public class DetailsActionBar(
+    IGrantApplicationAppService grantApplicationAppService,
+    IAuthorizationService authorizationService) : AbpViewComponent
 {
     [BindProperty]
     public Guid SelectedApplicationId { get; set; }
 
-    private readonly IGrantApplicationAppService _grantApplicationAppService;
-    private readonly IAuthorizationService _authorizationService;
-
-    public DetailsActionBar(
-        IGrantApplicationAppService grantApplicationAppService,
-        IAuthorizationService authorizationService)
-    {
-        _grantApplicationAppService = grantApplicationAppService;
-        _authorizationService = authorizationService;
-    }
-
     public async Task<IViewComponentResult> InvokeAsync(Guid applicationId)
     {
         SelectedApplicationId = applicationId;
 
-        var application = await _grantApplicationAppService.GetAsync(applicationId);
-        var canUpdateExternalStatusVisibility = await _authorizationService.IsGrantedAsync(UnitySelector.Review.AssessmentResults.Update.Default);
+        var application = await grantApplicationAppService.GetBasicAsync(SelectedApplicationId);
+        var canUpdateExternalStatusVisibility = await authorizationService.IsGrantedAsync(UnitySelector.Review.AssessmentResults.Update.Default);
 
         return View(new DetailsActionBarViewModel
         {
-            ApplicationId = applicationId,
+            ApplicationId = SelectedApplicationId,
             ExternalStatusVisibility = application.ExternalStatusVisibility,
             CanUpdateExternalStatusVisibility = canUpdateExternalStatusVisibility
         });

From 0dbd0bc1d25ef520617e82a15121d825b689f5d1 Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 6 Jul 2026 10:35:03 -0700
Subject: [PATCH 57/61] [AB#33555] Update Applicant Portal Submission Provider

---
 .../DataProviders/SubmissionInfoDataProvider.cs             | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/ApplicantProfile/DataProviders/SubmissionInfoDataProvider.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/ApplicantProfile/DataProviders/SubmissionInfoDataProvider.cs
index cce72070be..d56d98fa28 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Application/ApplicantProfile/DataProviders/SubmissionInfoDataProvider.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Application/ApplicantProfile/DataProviders/SubmissionInfoDataProvider.cs
@@ -1,9 +1,9 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Unity.GrantManager.ApplicantProfile.ProfileData;
 using Unity.GrantManager.Applications;
 using Unity.GrantManager.Integrations;
@@ -67,7 +67,7 @@ join status in statusesQuery on application.ApplicationStatusId equals status.Id
                         submission.Submission,
                         application.ReferenceNo,
                         FormName = form.ApplicationFormName ?? string.Empty,
-                        Status = application.SubStatus == "NOTIFIED"
+                        Status = application.ExternalStatusVisibility
                             ? status.NotifiedStatus ?? status.ExternalStatus
                             : status.ExternalStatus
                     }).ToListAsync();

From 5b9ec3e786fef281a77fdc10cea0c21d10baf37b Mon Sep 17 00:00:00 2001
From: Patrick <135162612+plavoie-BC@users.noreply.github.com>
Date: Mon, 6 Jul 2026 11:33:05 -0700
Subject: [PATCH 58/61] [AB#33555] Fix Submission Info Unit Test

---
 .../Applicants/SubmissionInfoDataProviderTests.cs             | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/Applicants/SubmissionInfoDataProviderTests.cs b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/Applicants/SubmissionInfoDataProviderTests.cs
index cad26be11b..effd117a15 100644
--- a/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/Applicants/SubmissionInfoDataProviderTests.cs
+++ b/applications/Unity.GrantManager/test/Unity.GrantManager.Application.Tests/Applicants/SubmissionInfoDataProviderTests.cs
@@ -217,7 +217,7 @@ public async Task GetDataAsync_ShouldUseNotifiedStatus_WhenSubStatusIsNotified()
                 [CreateApplication(applicationId, statusId, a =>
                 {
                     a.ApplicationFormId = formId;
-                    a.SubStatus = "NOTIFIED";
+                    a.ExternalStatusVisibility = true;
                 })],
                 [CreateForm(formId, "Form")],
                 [CreateStatus(statusId, "Under Review", "Approved")]);
@@ -245,7 +245,7 @@ public async Task GetDataAsync_ShouldUseExternalStatus_WhenSubStatusIsNotNotifie
                 [CreateApplication(applicationId, statusId, a =>
                 {
                     a.ApplicationFormId = formId;
-                    a.SubStatus = "COMPLETE";
+                    a.ExternalStatusVisibility = false;
                 })],
                 [CreateForm(formId, "Form")],
                 [CreateStatus(statusId, "Under Review", "Approved")]);

From 84d53ac5f4e3d402a835399ec9a8946f14589437 Mon Sep 17 00:00:00 2001
From: aurelio-aot <aurelio.pascual.jr@gmail.com>
Date: Mon, 6 Jul 2026 12:17:43 -0700
Subject: [PATCH 59/61] AB#33604: Add ApproxNumberOfEmployees in Applications
 List

---
 .../Localization/GrantManager/en.json              |  3 ++-
 .../Pages/Applicants/Index.js                      |  2 +-
 .../Pages/GrantApplications/Index.js               | 14 ++++++++++++++
 .../ApplicantOrganizationInfoViewModel.cs          |  2 +-
 4 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
index 392682daea..4c9a3f7a4f 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Localization/GrantManager/en.json
@@ -359,6 +359,7 @@
     "Summary:Application.OrganizationName": "Registered Organization Name",
     "Summary:Application.OrganizationNumber": "Registered Organization Number",
     "Summary:Application.BusinessNumber": "Business Number",
+    "Summary:Application.ApproxNumberOfEmployees": "Approx. Number of Employees",
     "Summary:Application.NonRegOrgName": "Non-Registered Organization Name",
     "Summary:Application.City": "City",
     "Summary:Application.Community": "Community",
@@ -430,7 +431,7 @@
     "ApplicantInfoView:ApplicantInfo.OrgBookStatus": "Org book status ",
     "ApplicantInfoView:ApplicantInfo.OrganizationType": "Organization Type",
     "ApplicantInfoView:ApplicantInfo.OrganizationSize": "Organization Size",
-    "ApplicantInfoView:ApplicantInfo.ApproxNumberOfEmployees": "Organization Size (Approximate Number of Employees)",
+    "ApplicantInfoView:ApplicantInfo.ApproxNumberOfEmployees": "Approx. Number of Employees",
     "ApplicantInfoView:ApplicantInfo.UnityApplicant": "Applicant Id",
     "ApplicantInfoView:ApplicantInfo.FiscalMonth": "Fiscal Year End Month",
     "ApplicantInfoView:ApplicantInfo.FiscalDay": "Fiscal Year End Day",
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
index c79744f926..041ac4eaff 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/Applicants/Index.js
@@ -260,7 +260,7 @@ $(function () {
 
     function getApproxNumberOfEmployeesColumn(columnIndex) {
         return {
-            title: 'Organization Size (Approximate Number of Employees)',
+            title: 'Approx. Number of Employees',
             data: 'approxNumberOfEmployees',
             name: 'approxNumberOfEmployees',
             className: 'data-table-header',
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
index fda92e5ea5..1e24a3cf75 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Pages/GrantApplications/Index.js
@@ -601,6 +601,7 @@ $(function () {
             getOrganizationTypeColumn(columnIndex++),
             getOrganizationNameColumn(columnIndex++),
             getBusinessNumberColumn(columnIndex++),
+            getApproxNumberOfEmployeesColumn(columnIndex++),
             getDueDiligenceStatusColumn(columnIndex++),
             getDeclineRationaleColumn(columnIndex++),
             getContactFullNameColumn(columnIndex++),
@@ -1256,6 +1257,19 @@ $(function () {
         }
     }
 
+    function getApproxNumberOfEmployeesColumn(columnIndex) {
+        return {
+            title: l('Summary:Application.ApproxNumberOfEmployees'),
+            name: 'approxNumberOfEmployees',
+            data: 'applicant.approxNumberOfEmployees',
+            className: 'data-table-header',
+            render: function (data) {
+                return data ?? '';
+            },
+            index: columnIndex
+        }
+    }
+
     function getNonRegisteredOrganizationNameColumn(columnIndex) {
         return {
             title: l('Summary:Application.NonRegOrgName'),
diff --git a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantOrganizationInfo/ApplicantOrganizationInfoViewModel.cs b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantOrganizationInfo/ApplicantOrganizationInfoViewModel.cs
index 236dff6da8..f9370f9b3b 100644
--- a/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantOrganizationInfo/ApplicantOrganizationInfoViewModel.cs
+++ b/applications/Unity.GrantManager/src/Unity.GrantManager.Web/Views/Shared/Components/ApplicantOrganizationInfo/ApplicantOrganizationInfoViewModel.cs
@@ -42,7 +42,7 @@ public class ApplicantOrganizationInfoViewModel
         [Display(Name = "Organization Type")]
         public string OrganizationType { get; set; } = string.Empty;
 
-        [Display(Name = "Organization Size (Approximate Number of Employees)")]
+        [Display(Name = "Approx. Number of Employees")]
         public string ApproxNumberOfEmployees { get; set; } = string.Empty;
         
         [Display(Name = "Non-Registered Organization Name")]

From 097335d20b0140e0c6e5dcd8f9b81e5f16555be1 Mon Sep 17 00:00:00 2001
From: aurelio-aot <aurelio.pascual.jr@gmail.com>
Date: Mon, 6 Jul 2026 13:11:20 -0700
Subject: [PATCH 60/61] AB#33228: Change Status When Cancelling Payment
 Requests

---
 .../Domain/Services/PaymentsManager.cs                     | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
index 1c2a57b101..ddefff28db 100644
--- a/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
+++ b/applications/Unity.GrantManager/modules/Unity.Payments/src/Unity.Payments.Application/Domain/Services/PaymentsManager.cs
@@ -209,6 +209,7 @@ public async Task UpdatePaymentStatusAsync(Guid paymentRequestId, PaymentApprova
         public virtual async Task<PaymentRequest> CancelPaymentAsync(Guid paymentRequestId)
         {
             var paymentRequest = await paymentRequestRepository.GetAsync(paymentRequestId, true);
+            var isHistoricalPayment = paymentRequest.Status == PaymentRequestStatus.HistoricalPayment;
             var statusChange = paymentRequest.Status;
 
             var workflow = new PaymentsWorkflow<PaymentRequestStatus, PaymentApprovalAction>(
@@ -222,6 +223,12 @@ public virtual async Task<PaymentRequest> CancelPaymentAsync(Guid paymentRequest
                 currentUser.GetId(),
                 $"{currentUser.Name} {currentUser.SurName}".Trim());
 
+            if (isHistoricalPayment)
+            {
+                paymentRequest.SetInvoiceStatus(CasPaymentRequestStatus.Cancelled);
+                paymentRequest.SetPaymentStatus(CasPaymentRequestStatus.NotPaid);
+            }
+
             return await paymentRequestRepository.UpdateAsync(paymentRequest);
         }
     }

From 737eb5f83370b7473e0955eebb49c8db342a4656 Mon Sep 17 00:00:00 2001
From: Armin Hasanpour <armin.hasanpour@gov.bc.ca>
Date: Mon, 6 Jul 2026 18:19:46 -0700
Subject: [PATCH 61/61] AB#33573 - fixed Notifications layout issue

---
 .../Pages/Notifications/Index.cshtml          |  4 ---
 .../Pages/Notifications/Index.css             | 30 -------------------
 2 files changed, 34 deletions(-)
 delete mode 100644 applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.css

diff --git a/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.cshtml b/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.cshtml
index 86f77e3eaf..4f20953652 100644
--- a/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.cshtml
+++ b/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.cshtml
@@ -10,10 +10,6 @@
     </abp-script-bundle>
 }
 
-@section styles {
-    <abp-style src="/Pages/Notifications/Index.css" />
-}
-
 <div class="container-fluid px-2">
     <div class="action-bar p-2 search-action-bar d-flex align-items-center">
         <div class="search-action-bar_search-wrapper flex-grow-1">
diff --git a/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.css b/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.css
deleted file mode 100644
index 6a1faf3a05..0000000000
--- a/applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Web/Pages/Notifications/Index.css
+++ /dev/null
@@ -1,30 +0,0 @@
-/* The shared initializeDataTable helper enables scrollX, and layout.css forces
-   a permanent vertical scrollbar on the scroll body. Together DataTables bakes
-   ~25px of vertical-scrollbar reservation into the computed column widths, so
-   the inner table ends up wider than its container and renders a phantom
-   horizontal scrollbar even when there is free space.
-
-   `width: 100%` alone does nothing here because the table is table-layout: auto,
-   where the columns' content widths win over the width hint. Switching the
-   inner head/body tables to table-layout: fixed makes width: 100% authoritative,
-   so the table matches the container exactly; over-long values (full email
-   addresses) wrap inside their column instead of forcing a horizontal scroll.
-   Restoring overflow-y: auto lets the vertical scrollbar appear only when rows
-   actually overflow, removing the reserved gutter when they fit.
-
-   Scoped to this table so the intentionally wide, horizontally scrolling tables
-   elsewhere are unaffected. */
-#NotificationListTable_wrapper .dt-scroll-head .dt-scroll-headInner {
-    width: 100% !important;
-}
-
-#NotificationListTable_wrapper .dt-scroll-body {
-    overflow-y: auto !important;
-}
-
-#NotificationListTable_wrapper .dt-scroll-head .dt-scroll-headInner table,
-#NotificationListTable_wrapper .dt-scroll-body table,
-#NotificationListTable {
-    table-layout: fixed !important;
-    width: 100% !important;
-}