Feature/ab#9075 Applicant Profile Add Attachments

applications/Unity.GrantManager/src/Unity.GrantManager.Application.Contracts/Attachments/IAttachmentAppService.cs

@@ -9,6 +9,7 @@ public interface IAttachmentAppService : IApplicationService
 {
     Task<IList<ApplicationAttachmentDto>> GetApplicationAsync(Guid applicationId);
     Task<IList<AssessmentAttachmentDto>> GetAssessmentAsync(Guid assessmentId);
+    Task<IList<UnityAttachmentDto>> GetApplicantAsync(Guid applicantId);
     Task ResyncSubmissionAttachmentsAsync(Guid applicationId);
     Task<IList<UnityAttachmentDto>> GetAttachmentsAsync(AttachmentParametersDto attachmentParametersDto);
     Task<AttachmentMetadataDto> GetAttachmentMetadataAsync(AttachmentType attachmentType, Guid attachmentId);

applications/Unity.GrantManager/src/Unity.GrantManager.Application/Attachments/AttachmentAppService.cs

@@ -21,6 +21,7 @@ public class AttachmentAppService(
     IApplicationAttachmentRepository applicationAttachmentRepository,
     IApplicationChefsFileAttachmentRepository applicationChefsFileAttachmentRepository,
     IAssessmentAttachmentRepository assessmentAttachmentRepository,
+    IApplicantAttachmentRepository applicantAttachmentRepository,
     IIntakeFormSubmissionManager intakeFormSubmissionManager,
     IPersonRepository personUserRepository) : ApplicationService, IAttachmentAppService
 {
@@ -54,6 +55,11 @@ public async Task<IList<AssessmentAttachmentDto>> GetAssessmentAsync(Guid assess
             }).ToList();
     }
 
+    public async Task<IList<UnityAttachmentDto>> GetApplicantAsync(Guid applicantId)
+    {
+        return await GetAttachmentsAsync(new AttachmentParametersDto(AttachmentType.APPLICANT, applicantId));
+    }
+
     public async Task<List<ApplicationChefsFileAttachment>> GetApplicationChefsFileAttachmentsAsync(Guid applicationId)
     {
         return await applicationChefsFileAttachmentRepository.GetListAsync(applicationId);
@@ -79,6 +85,9 @@ public async Task<IList<UnityAttachmentDto>> GetAttachmentsAsync(AttachmentParam
             AttachmentType.ASSESSMENT => await GetAttachmentsInternalAsync(
                 assessmentAttachmentRepository,
                 attachment => attachment.AssessmentId == attachmentParametersDto.AttachedResourceId),
+            AttachmentType.APPLICANT => await GetAttachmentsInternalAsync(
+                applicantAttachmentRepository,
+                attachment => attachment.ApplicantId == attachmentParametersDto.AttachedResourceId),
             _ => throw new ArgumentException("Attachment type is not supported", nameof(attachmentParametersDto)),
         };
     }
@@ -117,6 +126,8 @@ public async Task<AttachmentMetadataDto> GetAttachmentMetadataAsync(AttachmentTy
                 attachmentId, assessmentAttachmentRepository),
             AttachmentType.CHEFS => await GetMetadataInternalAsync(
                 attachmentId, applicationChefsFileAttachmentRepository),
+            AttachmentType.APPLICANT => await GetMetadataInternalAsync(
+                attachmentId, applicantAttachmentRepository),
             _ => throw new ArgumentException("Invalid attachment type", nameof(attachmentType)),
         };
     }
@@ -152,6 +163,10 @@ public async Task<AttachmentMetadataDto> UpdateAttachmentMetadataAsync(UpdateAtt
                 updateAttachment,
                 applicationChefsFileAttachmentRepository,
                 AttachmentType.CHEFS),
+            AttachmentType.APPLICANT => await UpdateMetadataInternalAsync(
+                updateAttachment,
+                applicantAttachmentRepository,
+                AttachmentType.APPLICANT),
             _ => throw new ArgumentException("Invalid attachment type", nameof(updateAttachment)),
         };
     }

applications/Unity.GrantManager/src/Unity.GrantManager.Application/Attachments/S3BlobProvider.cs

@@ -21,14 +21,16 @@ public partial class S3BlobProvider : BlobProviderBase, ITransientDependency
 {
     private readonly IHttpContextAccessor _httpContextAccessor;
     private readonly IApplicationAttachmentRepository _applicationAttachmentRepository;
-    private readonly IAssessmentAttachmentRepository _assessmentAttachmentRepository;    
+    private readonly IAssessmentAttachmentRepository _assessmentAttachmentRepository;
+    private readonly IApplicantAttachmentRepository _applicantAttachmentRepository;
     private readonly AmazonS3Client _amazonS3Client;
 
-    public S3BlobProvider(IHttpContextAccessor httpContextAccessor, IApplicationAttachmentRepository attachmentRepository, IAssessmentAttachmentRepository assessmentAttachmentRepository, IConfiguration configuration)
+    public S3BlobProvider(IHttpContextAccessor httpContextAccessor, IApplicationAttachmentRepository attachmentRepository, IAssessmentAttachmentRepository assessmentAttachmentRepository, IApplicantAttachmentRepository applicantAttachmentRepository, IConfiguration configuration)
     {
         _httpContextAccessor = httpContextAccessor;
         _applicationAttachmentRepository = attachmentRepository;
         _assessmentAttachmentRepository = assessmentAttachmentRepository;
+        _applicantAttachmentRepository = applicantAttachmentRepository;
 
         AmazonS3Config s3config = new()
         {
@@ -89,6 +91,19 @@ public override async Task<bool> DeleteAsync(BlobProviderDeleteArgs args)
                 await _assessmentAttachmentRepository.DeleteAsync(attachment);
             }
         }
+        else if (attachmentType == "Applicant")
+        {
+            if (attachmentTypeId.IsNullOrEmpty())
+            {
+                throw new AbpValidationException("Missing ApplicantId");
+            }
+            IQueryable<ApplicantAttachment> queryableAttachment = _applicantAttachmentRepository.GetQueryableAsync().Result;
+            ApplicantAttachment? attachment = queryableAttachment.FirstOrDefault(a => a.S3ObjectKey.Equals(s3ObjectKey) && a.ApplicantId.Equals(new Guid(attachmentTypeId.ToString())));
+            if (attachment != null)
+            {
+                await _applicantAttachmentRepository.DeleteAsync(attachment);
+            }
+        }
         else
         {
             throw new AbpValidationException("Wrong AttachmentType:"+attachmentType);
@@ -146,30 +161,34 @@ public override async Task SaveAsync(BlobProviderSaveArgs args)
         var httpContext = _httpContextAccessor.HttpContext ?? throw new InvalidOperationException("No active HttpContext.");
         var queryParams = httpContext.Request?.Query ?? throw new InvalidOperationException("No query parameters in the current request.");
         var routeData = _httpContextAccessor.HttpContext.GetRouteData();
-        var assessmentId = routeData.Values["assessmentId"];
 
+        var assessmentId = routeData.Values["assessmentId"];
+        var applicationId = routeData.Values["applicationId"];
+        var applicantId = routeData.Values["applicantId"];
+        queryParams.TryGetValue("userId", out StringValues currentUserId);
         if (assessmentId != null)
         {            
-            queryParams.TryGetValue("userId", out StringValues currentUserId);            
-#pragma warning disable CS8604 // Possible null reference argument.
+
+            #pragma warning disable CS8604 // Possible null reference argument.
             await UploadAssessmentAttachment(args, assessmentId.ToString(), currentUserId.ToString());
-#pragma warning restore CS8604 // Possible null reference argument.
+            #pragma warning restore CS8604 // Possible null reference argument.
+        }
+        else if(applicationId != null)
+        {             
+            #pragma warning disable CS8604 // Possible null reference argument.
+            await UploadApplicationAttachment(args, applicationId.ToString(), currentUserId.ToString());
+            #pragma warning restore CS8604 // Possible null reference argument.
+        }
+        else if (applicantId != null)
+        {
+            #pragma warning disable CS8604 // Possible null reference argument.
+            await UploadApplicantAttachment(args, applicantId.ToString(), currentUserId.ToString());
+            #pragma warning restore CS8604 // Possible null reference argument.
         }
         else
         {
-            var applicationId = routeData.Values["applicationId"];
-            if(applicationId != null)
-            {
-                queryParams.TryGetValue("userId", out StringValues currentUserId);                
-#pragma warning disable CS8604 // Possible null reference argument.
-                await UploadApplicationAttachment(args, applicationId.ToString(), currentUserId.ToString());
-#pragma warning restore CS8604 // Possible null reference argument.
-            }
-            else
-            {
-                throw new AbpValidationException("Missing parameter: applicationId/assessmentId");
-            }
-        }       
+            throw new AbpValidationException("Missing parameter: applicationId/assessmentId/applicantId");
+        }     
     }    
 
     private async Task UploadAssessmentAttachment(BlobProviderSaveArgs args, string assessmentId, string currentUserId)
@@ -246,6 +265,43 @@ await _applicationAttachmentRepository.InsertAsync(
         }
     }
 
+    private async Task UploadApplicantAttachment(BlobProviderSaveArgs args, string applicantId, string currentUserId)
+    {
+        var config = args.Configuration.GetS3BlobProviderConfiguration();
+        var bucket = config.Bucket;
+        var folder = args.Configuration.GetS3BlobProviderConfiguration().ApplicantS3Folder;
+        if (!folder.EndsWith('/'))
+        {
+            folder += "/";
+        }
+        folder += applicantId;
+        var key = folder + "/" + args.BlobName;
+        var escapedKey = folder + "/" + Uri.EscapeDataString(args.BlobName);
+        var mimeType = GetMimeType(args.BlobName);
+        await UploadToS3(args, bucket, escapedKey, mimeType);
+        IQueryable<ApplicantAttachment> queryableAttachment = _applicantAttachmentRepository.GetQueryableAsync().Result;
+        ApplicantAttachment? attachment = queryableAttachment.FirstOrDefault(a => a.S3ObjectKey.Equals(key) && a.ApplicantId.Equals(new Guid(applicantId)));
+        if (attachment == null)
+        {
+            await _applicantAttachmentRepository.InsertAsync(
+                new ApplicantAttachment
+                {
+                    ApplicantId = new Guid(applicantId),
+                    S3ObjectKey = key,
+                    UserId = new Guid(currentUserId),
+                    FileName = args.BlobName,
+                    Time = DateTime.UtcNow,
+                });
+        }
+        else
+        {
+            attachment.UserId = new Guid(currentUserId);
+            attachment.FileName = args.BlobName;
+            attachment.Time = DateTime.UtcNow;
+            await _applicantAttachmentRepository.UpdateAsync(attachment);
+        }
+    }
+
     public async Task UploadToS3(BlobProviderSaveArgs args, string bucket, string key, string mimeType)
     {        
         byte[] fileBytes;

applications/Unity.GrantManager/src/Unity.GrantManager.Application/Attachments/S3BlobProviderConfiguration.cs

@@ -51,5 +51,12 @@ public string AssessmentS3Folder
                 .GetConfiguration<string>("S3BlobProvider.AssessmentS3Folder");
         set => _containerConfiguration
             .SetConfiguration("S3BlobProvider.AssessmentS3Folder", value);
+    }
+    public string ApplicantS3Folder
+    {
+        get => _containerConfiguration
+                .GetConfiguration<string>("S3BlobProvider.ApplicantS3Folder");
+        set => _containerConfiguration
+            .SetConfiguration("S3BlobProvider.ApplicantS3Folder", value);
     }    
 }

applications/Unity.GrantManager/src/Unity.GrantManager.Application/GrantManagerApplicationModule.cs

@@ -120,6 +120,7 @@ public override void ConfigureServices(ServiceConfigurationContext context)
                     provider.SecretAccessKey = configuration["S3:SecretAccessKey"] ?? "";
                     provider.ApplicationS3Folder = configuration["S3:ApplicationS3Folder"] ?? "";
                     provider.AssessmentS3Folder = configuration["S3:AssessmentS3Folder"] ?? "";
+                    provider.ApplicantS3Folder = configuration["S3:ApplicantS3Folder"] ?? "";
                 });
             });
         });

applications/Unity.GrantManager/src/Unity.GrantManager.Domain.Shared/Attachments/AttachmentType.cs

@@ -8,5 +8,6 @@ public enum AttachmentType
     APPLICATION = 0,
     ASSESSMENT = 1,
     CHEFS = 2,
-    EMAIL = 3
+    EMAIL = 3,
+    APPLICANT = 4
 }

applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/ApplicantAttachment.cs

@@ -0,0 +1,12 @@
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using Unity.GrantManager.Attachments;
+
+namespace Unity.GrantManager.Applications;
+
+public class ApplicantAttachment : AbstractS3Attachment
+{
+    [NotMapped]
+    public override AttachmentType AttachmentType => AttachmentType.APPLICANT;
+    public Guid ApplicantId { get; set; }
+}

applications/Unity.GrantManager/src/Unity.GrantManager.Domain/Applications/IApplicantAttachmentRepository.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Repositories;
+
+namespace Unity.GrantManager.Applications
+{
+    public interface IApplicantAttachmentRepository : IRepository<ApplicantAttachment, Guid>
+    {
+        Task<List<ApplicantAttachment>> GetListAsync(
+            int skipCount,
+            int maxResultCount,
+            string sorting,
+            string filter
+        );
+    }
+}

applications/Unity.GrantManager/src/Unity.GrantManager.EntityFrameworkCore/EntityFrameworkCore/GrantTenantDbContext.cs

@@ -39,6 +39,7 @@ public class GrantTenantDbContext : AbpDbContext<GrantTenantDbContext>
         public DbSet<ApplicationTags> ApplicationTags { get; set; }
         public DbSet<ApplicantAgent> ApplicantAgents { get; set; }
         public DbSet<ApplicantComment> ApplicantComments { get; set; }
+        public DbSet<ApplicantAttachment> ApplicantAttachments { get; set; }
         public DbSet<ApplicationAttachment> ApplicationAttachments { get; set; }
         public DbSet<ApplicationFormSubmission> ApplicationFormSubmissions { get; set; }
         public DbSet<AssessmentAttachment> AssessmentAttachments { get; set; }
@@ -217,6 +218,14 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
                    .HasForeignKey(x => x.CommenterId);
             });
 
+            modelBuilder.Entity<ApplicantAttachment>(b =>
+            {
+                b.ToTable(GrantManagerConsts.TenantTablePrefix + "ApplicantAttachments", GrantManagerConsts.DbSchema);
+
+                b.ConfigureByConvention();
+                b.HasOne<Applicant>().WithMany().HasForeignKey(x => x.ApplicantId).IsRequired();
+            });
+
             modelBuilder.Entity<ApplicationAttachment>(b =>
             {
                 b.ToTable(GrantManagerConsts.TenantTablePrefix + "ApplicationAttachments", GrantManagerConsts.DbSchema);