Dev

.gitignore

@@ -28,6 +28,7 @@ bld/
 # Visual Studio cache/options directory
 .vs/
 .vscode/
+*.lscache
 # Uncomment if you have tasks that create the project's static files in wwwroot
 **/wwwroot/lib/
 

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application.Contracts/AI/Operations/IAIGenerationPrerequisiteValidator.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Unity.AI.Operations;
+
+public interface IAIGenerationPrerequisiteValidator
+{
+    Task EnsureAttachmentSummaryAvailableAsync(Guid applicationId);
+
+    Task EnsureApplicationAnalysisAvailableAsync(Guid applicationId);
+
+    Task EnsureApplicationScoringAvailableAsync(Guid applicationId);
+}

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Operations/AIGenerationPrerequisiteValidator.cs

@@ -0,0 +1,57 @@
+using Microsoft.Extensions.Localization;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Unity.Flex.Domain.Scoresheets;
+using Unity.AI.Localization;
+using Unity.GrantManager.Applications;
+using Volo.Abp;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Linq;
+
+namespace Unity.AI.Operations;
+
+public class AIGenerationPrerequisiteValidator(
+    IApplicationRepository applicationRepository,
+    IApplicationFormRepository applicationFormRepository,
+    IApplicationFormSubmissionRepository applicationFormSubmissionRepository,
+    IApplicationChefsFileAttachmentRepository applicationChefsFileAttachmentRepository,
+    IScoresheetRepository scoresheetRepository,
+    IAsyncQueryableExecuter asyncExecuter,
+    IStringLocalizer<AIResource> localizer) : IAIGenerationPrerequisiteValidator, ITransientDependency
+{
+    public async Task EnsureAttachmentSummaryAvailableAsync(Guid applicationId)
+    {
+        var attachmentQuery = await applicationChefsFileAttachmentRepository.GetQueryableAsync();
+        var hasAttachments = await asyncExecuter.AnyAsync(attachmentQuery.Where(a => a.ApplicationId == applicationId));
+        if (!hasAttachments)
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.NoAttachmentsAvailable]);
+        }
+    }
+
+    public async Task EnsureApplicationAnalysisAvailableAsync(Guid applicationId)
+    {
+        var submission = await applicationFormSubmissionRepository.GetByApplicationAsync(applicationId);
+        if (submission == null || string.IsNullOrWhiteSpace(submission.Submission))
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.ApplicationAnalysisRequiresSubmission]);
+        }
+    }
+
+    public async Task EnsureApplicationScoringAvailableAsync(Guid applicationId)
+    {
+        var application = await applicationRepository.GetAsync(applicationId);
+        var applicationForm = await applicationFormRepository.GetAsync(application.ApplicationFormId);
+        if (applicationForm.ScoresheetId == null)
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.ScoringRequiresScoresheet]);
+        }
+
+        var scoresheet = await scoresheetRepository.GetWithChildrenAsync(applicationForm.ScoresheetId.Value);
+        if (scoresheet == null || !scoresheet.Sections.Any() || !scoresheet.Sections.SelectMany(s => s.Fields).Any())
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.ScoringRequiresScoresheetFields]);
+        }
+    }
+}

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Operations/ApplicationAnalysisService.cs

@@ -1,12 +1,8 @@
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json.Linq;
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
-using Unity.AI.Models;
 using Unity.AI.Prompts;
 using Unity.AI.Requests;
 using Unity.AI.Runtime;
@@ -21,35 +17,23 @@ public class ApplicationAnalysisService(
         IApplicationFormVersionRepository applicationFormVersionRepository,
         IApplicationChefsFileAttachmentRepository applicationChefsFileAttachmentRepository,
         IAIService aiService,
+        IAIGenerationPrerequisiteValidator aiGenerationPrerequisiteValidator,
         ILogger<ApplicationAnalysisService> logger) : IApplicationAnalysisService, ITransientDependency
     {
-        private const string ComponentsKey = "components";
-        private static readonly HashSet<string> ExcludedSchemaKeys = new(StringComparer.OrdinalIgnoreCase)
-        {
-            "applicantAgent"
-        };
-
         public async Task<string> RegenerateAndSaveAsync(Guid applicationId, string? promptVersion = null, CancellationToken cancellationToken = default)
         {
+            await aiGenerationPrerequisiteValidator.EnsureApplicationAnalysisAvailableAsync(applicationId);
+
             var application = await applicationRepository.GetAsync(applicationId);
             var formSubmission = await applicationFormSubmissionRepository.GetByApplicationAsync(applicationId);
             var attachments = await applicationChefsFileAttachmentRepository.GetListAsync(a => a.ApplicationId == applicationId);
             var formSchema = await GetFormSchemaAsync(formSubmission?.ApplicationFormVersionId);
 
-            var attachmentSummaries = attachments
-                .Where(a => !string.IsNullOrWhiteSpace(a.AISummary))
-                .Select(a => new AIAttachmentItem
-                {
-                    Name = string.IsNullOrWhiteSpace(a.FileName) ? "attachment" : a.FileName.Trim(),
-                    Summary = a.AISummary!.Trim()
-                })
-                .ToList();
-
-            object formFieldConfiguration = new { message = "Form configuration not available." };
-            if (formSubmission?.ApplicationFormVersionId != null)
-            {
-                formFieldConfiguration = await ExtractFormFieldConfigurationAsync(formSubmission.ApplicationFormVersionId.Value);
-            }
+            var attachmentSummaries = PromptDataPayloadBuilder.BuildAttachmentSummaries(attachments);
+            var formFieldConfiguration = await PromptDataPayloadBuilder.BuildFormFieldConfigurationAsync(
+                applicationFormVersionRepository,
+                formSubmission?.ApplicationFormVersionId,
+                logger);
 
             var analysis = await aiService.GenerateApplicationAnalysisAsync(new ApplicationAnalysisRequest
             {
@@ -84,115 +68,5 @@ public async Task<string> RegenerateAndSaveAsync(Guid applicationId, string? pro
             }
         }
 
-        private async Task<object> ExtractFormFieldConfigurationAsync(Guid formVersionId)
-        {
-            try
-            {
-                var formVersion = await applicationFormVersionRepository.GetAsync(formVersionId);
-                if (formVersion == null || string.IsNullOrEmpty(formVersion.FormSchema))
-                {
-                    return new { message = "Form configuration not available." };
-                }
-
-                var schema = JObject.Parse(formVersion.FormSchema);
-                var components = schema[ComponentsKey] as JArray;
-                if (components == null || components.Count == 0)
-                {
-                    return new { message = "No form fields configured." };
-                }
-
-                var requiredFields = new List<string>();
-                var optionalFields = new List<string>();
-                ExtractFieldRequirements(components, requiredFields, optionalFields, string.Empty);
-
-                return new
-                {
-                    required_fields = requiredFields,
-                    optional_fields = optionalFields
-                };
-            }
-            catch (Exception ex)
-            {
-                logger.LogError(ex, "Error extracting form field configuration for form version {FormVersionId}", formVersionId);
-                return new { message = "Form configuration could not be extracted." };
-            }
-        }
-
-        private static void ExtractFieldRequirements(JArray components, List<string> requiredFields, List<string> optionalFields, string currentPath)
-        {
-            foreach (var component in components.OfType<JObject>())
-            {
-                var key = component["key"]?.ToString();
-                var label = component["label"]?.ToString();
-                var type = component["type"]?.ToString();
-                var skipTypes = new HashSet<string> { "button", "simplebuttonadvanced", "html", "htmlelement", "content", "simpleseparator" };
-
-                if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(type) || skipTypes.Contains(type) || ExcludedSchemaKeys.Contains(key))
-                {
-                    ProcessNestedFieldRequirements(component, type, requiredFields, optionalFields, currentPath);
-                    continue;
-                }
-
-                var displayName = !string.IsNullOrEmpty(label) ? $"{label} ({key})" : key;
-                var fullPath = string.IsNullOrEmpty(currentPath) ? displayName : $"{currentPath} > {displayName}";
-                var validate = component["validate"] as JObject;
-                var isRequired = validate?["required"]?.Value<bool>() ?? false;
-
-                if (component["input"]?.Value<bool>() == true)
-                {
-                    if (isRequired) requiredFields.Add(fullPath);
-                    else optionalFields.Add(fullPath);
-                }
-
-                ProcessNestedFieldRequirements(component, type, requiredFields, optionalFields, fullPath);
-            }
-        }
-
-        private static void ProcessNestedFieldRequirements(JObject component, string? type, List<string> requiredFields, List<string> optionalFields, string currentPath)
-        {
-            switch (type)
-            {
-                case "panel":
-                case "simplepanel":
-                case "fieldset":
-                case "well":
-                case "container":
-                case "datagrid":
-                case "table":
-                    if (component[ComponentsKey] is JArray nestedComponents)
-                    {
-                        ExtractFieldRequirements(nestedComponents, requiredFields, optionalFields, currentPath);
-                    }
-                    break;
-                case "columns":
-                case "simplecols2":
-                case "simplecols3":
-                case "simplecols4":
-                    if (component["columns"] is JArray columns)
-                    {
-                        foreach (var column in columns.OfType<JObject>())
-                        {
-                            if (column[ComponentsKey] is JArray columnComponents)
-                            {
-                                ExtractFieldRequirements(columnComponents, requiredFields, optionalFields, currentPath);
-                            }
-                        }
-                    }
-                    break;
-                case "tabs":
-                case "simpletabs":
-                    if (component[ComponentsKey] is JArray tabs)
-                    {
-                        foreach (var tab in tabs.OfType<JObject>())
-                        {
-                            if (tab[ComponentsKey] is JArray tabComponents)
-                            {
-                                ExtractFieldRequirements(tabComponents, requiredFields, optionalFields, currentPath);
-                            }
-                        }
-                    }
-                    break;
-            }
-        }
     }
 }

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Operations/ApplicationScoringService.cs

@@ -10,8 +10,11 @@
 using Unity.AI.Prompts;
 using Unity.AI.Requests;
 using Unity.AI.Runtime;
+using Unity.AI.Localization;
 using Unity.GrantManager.Applications;
+using Volo.Abp;
 using Volo.Abp.DependencyInjection;
+using Microsoft.Extensions.Localization;
 
 namespace Unity.AI.Operations
 {
@@ -24,32 +27,28 @@ public class ApplicationScoringService(
         IScoresheetRepository scoresheetRepository,
         IAIService aiService,
         AIExecutionModeResolver executionModeResolver,
-        ILogger<ApplicationScoringService> logger) : IApplicationScoringService, ITransientDependency
+        ILogger<ApplicationScoringService> logger,
+        IStringLocalizer<AIResource> localizer) : IApplicationScoringService, ITransientDependency
     {
         public async Task<string> RegenerateAndSaveAsync(Guid applicationId, string? promptVersion = null, CancellationToken cancellationToken = default)
         {
             var application = await applicationRepository.GetAsync(applicationId);
             var applicationForm = await applicationFormRepository.GetAsync(application.ApplicationFormId);
             if (applicationForm.ScoresheetId == null)
             {
-                return "{}";
+                throw new UserFriendlyException(localizer[AILocalizationKeys.ScoringRequiresScoresheet]);
             }
 
             var scoresheet = await scoresheetRepository.GetWithChildrenAsync(applicationForm.ScoresheetId.Value);
-            if (scoresheet == null)
+            if (scoresheet == null || !scoresheet.Sections.Any() || !scoresheet.Sections.SelectMany(s => s.Fields).Any())
             {
-                return "{}";
+                throw new UserFriendlyException(localizer[AILocalizationKeys.ScoringRequiresScoresheetFields]);
             }
 
             var attachments = await applicationChefsFileAttachmentRepository.GetListAsync(a => a.ApplicationId == applicationId);
-            var attachmentSummaries = attachments
-                .Where(a => !string.IsNullOrEmpty(a.AISummary))
-                .Select(a => new AIAttachmentItem
-                {
-                    Name = string.IsNullOrWhiteSpace(a.FileName) ? "attachment" : a.FileName.Trim(),
-                    Summary = a.AISummary!.Trim()
-                })
-                .ToList();
+            var attachmentSummaries = PromptDataPayloadBuilder.BuildAttachmentSummaries(
+                attachments,
+                excludeWhitespaceOnlySummaries: false);
 
             var formSubmission = await applicationFormSubmissionRepository.GetByApplicationAsync(applicationId);
             var formSchema = await GetFormSchemaAsync(formSubmission?.ApplicationFormVersionId);

applications/Unity.GrantManager/modules/Unity.AI/src/Unity.AI.Application/AI/Operations/AttachmentSummaryService.cs

@@ -1,13 +1,16 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Localization;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Unity.AI.Extraction;
+using Unity.AI.Localization;
 using Unity.AI.Requests;
 using Unity.GrantManager.Applications;
 using Unity.GrantManager.Intakes;
+using Volo.Abp;
 using Volo.Abp.DependencyInjection;
 
 namespace Unity.AI.Operations;
@@ -17,8 +20,10 @@ public class AttachmentSummaryService(
     IChefsFileAttachmentStreamProvider chefsFileAttachmentStreamProvider,
     ITextExtractionService textExtractionService,
     IAIService aiService,
+    IAIGenerationPrerequisiteValidator aiGenerationPrerequisiteValidator,
     AIExecutionModeResolver executionModeResolver,
-    ILogger<AttachmentSummaryService> logger) : IAttachmentSummaryService, ITransientDependency
+    ILogger<AttachmentSummaryService> logger,
+    IStringLocalizer<AIResource> localizer) : IAttachmentSummaryService, ITransientDependency
 {
     private const string SummaryGenerationFailedMessage = "AI summary generation failed.";
 
@@ -47,6 +52,11 @@ public async Task<string> GenerateAndSaveAsync(Guid attachmentId, string? prompt
     public async Task<List<string>> GenerateAndSaveAsync(IEnumerable<Guid> attachmentIds, string? promptVersion = null, CancellationToken cancellationToken = default)
     {
         var ids = attachmentIds as IReadOnlyCollection<Guid> ?? attachmentIds.ToList();
+        if (ids.Count == 0)
+        {
+            throw new UserFriendlyException(localizer[AILocalizationKeys.SelectAttachmentForSummaries]);
+        }
+
         var mode = executionModeResolver.ResolveMode(AIExecutionModeResolver.AttachmentSummaryOperation);
         if (mode != AIExecutionMode.Sequential)
         {
@@ -103,6 +113,8 @@ public async Task<List<string>> GenerateForApplicationAsync(
         IReadOnlyCollection<Guid>? attachmentIds = null,
         CancellationToken cancellationToken = default)
     {
+        await aiGenerationPrerequisiteValidator.EnsureAttachmentSummaryAvailableAsync(applicationId);
+
         var applicationAttachmentIds = (await applicationChefsFileAttachmentRepository.GetListAsync(a => a.ApplicationId == applicationId))
             .Select(a => a.Id)
             .ToList();