Dev

applications/Unity.GrantManager/modules/Unity.Flex/src/Unity.Flex.Application/Worksheets/Collectors/BCAddressCollector.cs

@@ -4,7 +4,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using Unity.Flex.Worksheets.Values;
-using Unity.GrantManager.Integration.Geocoder;
+using Unity.GrantManager.Integrations.Geocoder;
 
 namespace Unity.Flex.Worksheets.Collectors
 {

applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Application/EmailNotificaions/EmailNotificationService.cs

@@ -1,6 +1,4 @@
 using Microsoft.AspNetCore.Authorization;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
@@ -23,49 +21,31 @@
 using Volo.Abp.Domain.Entities;
 using Volo.Abp.Features;
 using Volo.Abp.SettingManagement;
+using Microsoft.AspNetCore.Http;
 using Volo.Abp.Users;
+using Unity.GrantManager.Notifications;
 
 namespace Unity.Notifications.EmailNotifications;
 
-
 [Dependency(ReplaceServices = false)]
 [ExposeServices(typeof(EmailNotificationService), typeof(IEmailNotificationService))]
-public class EmailNotificationService : ApplicationService, IEmailNotificationService
-{
-    private readonly IChesClientService _chesClientService;
-    private readonly IConfiguration _configuration;
-    private readonly EmailQueueService _emailQueueService;
-    private readonly IEmailLogsRepository _emailLogsRepository;
-    private readonly IExternalUserLookupServiceProvider _externalUserLookupServiceProvider;
-    private readonly ISettingManager _settingManager;
-    private readonly IFeatureChecker _featureChecker;
-    private readonly IHttpContextAccessor _httpContextAccessor;
-
-    public EmailNotificationService(
+#pragma warning disable S107 // Methods should not have too many parameters
+public class EmailNotificationService(
+        INotificationsAppService notificationAppService,
         IEmailLogsRepository emailLogsRepository,
-        IConfiguration configuration,
         IChesClientService chesClientService,
         EmailQueueService emailQueueService,
         IExternalUserLookupServiceProvider externalUserLookupServiceProvider,
         ISettingManager settingManager,
         IFeatureChecker featureChecker,
-        IHttpContextAccessor httpContextAccessor
-        )
-    {
-        _emailLogsRepository = emailLogsRepository;
-        _configuration = configuration;
-        _chesClientService = chesClientService;
-        _emailQueueService = emailQueueService;
-        _externalUserLookupServiceProvider = externalUserLookupServiceProvider;
-        _settingManager = settingManager;
-        _featureChecker = featureChecker;
-        _httpContextAccessor = httpContextAccessor;
-    }
+        IHttpContextAccessor httpContextAccessor) : ApplicationService, IEmailNotificationService
+#pragma warning restore S107 // Methods should not have too many parameters        
+{
 
     public async Task DeleteEmail(Guid id)
     {
-        await _emailLogsRepository.DeleteAsync(id);
-    }
+        await emailLogsRepository.DeleteAsync(id);
+    }    
 
     public async Task<int> GetEmailsChesWithNoResponseCountAsync()
     {
@@ -77,7 +57,7 @@ public async Task<int> GetEmailsChesWithNoResponseCountAsync()
             (x.Status == EmailStatus.Initialized && x.CreationTime.AddMinutes(10) < dbNow);
 
         // Fetch all email logs and apply the filter using LINQ
-        var allEmailLogs = await _emailLogsRepository.GetListAsync();
+        var allEmailLogs = await emailLogsRepository.GetListAsync();
         var emailLogs = allEmailLogs.Where(filter.Compile()).ToList();
 
         // Ensure we're returning 0 if no logs are found
@@ -90,16 +70,16 @@ public async Task<int> GetEmailsChesWithNoResponseCountAsync()
         {
             return null;
         }
-
-        var emailObject = await GetEmailObjectAsync(emailTo, body, subject, emailFrom, "html", emailTemplateName, emailCC, emailBCC);
-        EmailLog emailLog = await _emailLogsRepository.GetAsync(emailId);
+        
+        var emailObject = await GetEmailObjectAsync(emailTo, body, subject, emailFrom, "html", emailTemplateName);
+        EmailLog emailLog = await emailLogsRepository.GetAsync(emailId);
         emailLog = UpdateMappedEmailLog(emailLog, emailObject);
         emailLog.ApplicationId = applicationId;
         emailLog.Id = emailId;
         emailLog.Status = status ?? EmailStatus.Initialized;
 
         // When being called here the current tenant is in context - verified by looking at the tenant id
-        EmailLog loggedEmail = await _emailLogsRepository.UpdateAsync(emailLog, autoSave: true);
+        EmailLog loggedEmail = await emailLogsRepository.UpdateAsync(emailLog, autoSave: true);
         return loggedEmail;
     }
 
@@ -122,7 +102,7 @@ public async Task<int> GetEmailsChesWithNoResponseCountAsync()
         emailLog.Status = status ?? EmailStatus.Initialized;
 
         // When being called here the current tenant is in context - verified by looking at the tenant id
-        EmailLog loggedEmail = await _emailLogsRepository.InsertAsync(emailLog, autoSave: true);
+        EmailLog loggedEmail = await emailLogsRepository.InsertAsync(emailLog, autoSave: true);
         return loggedEmail;
     }
 
@@ -131,21 +111,19 @@ protected virtual async Task NotifyTeamsChannel(string chesEmailError)
         string? envInfo = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
         string activityTitle = "CHES Email error: " + chesEmailError;
         string activitySubtitle = "Environment: " + envInfo;
-        string teamsChannel = _configuration["Notifications:TeamsNotificationsWebhook"] ?? "";
-        List<Fact> facts = new() { };
-        await TeamsNotificationService.PostToTeamsAsync(teamsChannel, activityTitle, activitySubtitle, facts);
+        await notificationAppService.PostToTeamsAsync(activityTitle, activitySubtitle);
     }
 
     public async Task<HttpResponseMessage> SendCommentNotification(EmailCommentDto input)
     {
         HttpResponseMessage res = new();
         try
         {
-            if (await _featureChecker.IsEnabledAsync("Unity.Notifications"))
+            if (await featureChecker.IsEnabledAsync("Unity.Notifications"))
             {
                 var defaultFromAddress = await SettingProvider.GetOrNullAsync(NotificationsSettings.Mailing.DefaultFromAddress);
                 var scheme = "https";
-                var request = _httpContextAccessor.HttpContext?.Request;
+                var request = httpContextAccessor.HttpContext?.Request;
 
                 if (request == null)
                 {
@@ -211,7 +189,6 @@ public async Task<HttpResponseMessage> SendCommentNotification(EmailCommentDto i
         return res;
     }
 
-
     /// <summary>
     /// Send Email Notfication
     /// </summary>
@@ -238,8 +215,8 @@ public async Task<HttpResponseMessage> SendEmailNotification(string emailTo, str
 
             }
             // Send the email using the CHES client service
-            var emailObject = await GetEmailObjectAsync(emailTo, body, subject, emailFrom, emailBodyType, emailTemplateName, emailCC, emailBCC);
-            var response = await _chesClientService.SendAsync(emailObject);
+            var emailObject = await GetEmailObjectAsync(emailTo, body, subject, emailFrom, emailBodyType, emailTemplateName);
+            var response = await chesClientService.SendAsync(emailObject);
 
             // Assuming SendAsync returns a HttpResponseMessage or equivalent:
             return response;
@@ -259,7 +236,7 @@ public async Task<HttpResponseMessage> SendEmailNotification(string emailTo, str
         EmailLog emailLog = new EmailLog();
         try
         {
-            emailLog = await _emailLogsRepository.GetAsync(id);
+            emailLog = await emailLogsRepository.GetAsync(id);
         }
         catch (EntityNotFoundException ex)
         {
@@ -272,7 +249,7 @@ public async Task<HttpResponseMessage> SendEmailNotification(string emailTo, str
     [Authorize]
     public virtual async Task<List<EmailHistoryDto>> GetHistoryByApplicationId(Guid applicationId)
     {
-        var entityList = await _emailLogsRepository.GetByApplicationIdAsync(applicationId);
+        var entityList = await emailLogsRepository.GetByApplicationIdAsync(applicationId);
         var dtoList = ObjectMapper.Map<List<EmailLog>, List<EmailHistoryDto>>(entityList);
 
         var sentByUserIds = dtoList
@@ -284,7 +261,7 @@ public virtual async Task<List<EmailHistoryDto>> GetHistoryByApplicationId(Guid
 
         foreach (var userId in sentByUserIds)
         {
-            var userInfo = await _externalUserLookupServiceProvider.FindByIdAsync(userId);
+            var userInfo = await externalUserLookupServiceProvider.FindByIdAsync(userId);
             if (userInfo != null)
             {
                 userDictionary[userId] = ObjectMapper.Map<IUserData, EmailHistoryUserDto>(userInfo);
@@ -313,10 +290,18 @@ public async Task SendEmailToQueue(EmailLog emailLog)
         emailNotificationEvent.Id = emailLog.Id;
         emailNotificationEvent.TenantId = emailLog.TenantId;
         emailNotificationEvent.RetryAttempts = emailLog.RetryAttempts;
-        await _emailQueueService.SendToEmailEventQueueAsync(emailNotificationEvent);
+        await emailQueueService.SendToEmailEventQueueAsync(emailNotificationEvent);
     }
 
-    protected virtual async Task<dynamic> GetEmailObjectAsync(string emailTo, string body, string subject, string? emailFrom, string? emailBodyType, string? emailTemplateName, string? emailCC = null, string? emailBCC = null)
+    protected virtual async Task<dynamic> GetEmailObjectAsync(
+                                                string emailTo,
+                                                string body,
+                                                string subject,
+                                                string? emailFrom,
+                                                string? emailBodyType,
+                                                string? emailTemplateName,
+                                                string? emailCC = null,
+                                                string? emailBCC = null)
     {
         var toList = emailTo.ParseEmailList() ?? [];
         var ccList = emailCC.ParseEmailList();
@@ -365,7 +350,7 @@ private async Task UpdateTenantSettings(string settingKey, string valueString)
     {
         if (!valueString.IsNullOrWhiteSpace())
         {
-            await _settingManager.SetForCurrentTenantAsync(settingKey, valueString);
+            await settingManager.SetForCurrentTenantAsync(settingKey, valueString);
         }
     }
 }

applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Application/Events/EmailNotificationHandler.cs

@@ -15,7 +15,6 @@ internal class EmailNotificationHandler(
             IEmailNotificationService emailNotificationService,
             IFeatureChecker featureChecker) : ILocalEventHandler<EmailNotificationEvent>, ITransientDependency
     {
-        private const string GRANT_APPLICATION_UPDATE_SUBJECT = "Grant Application Update";
         private const string FAILED_PAYMENTS_SUBJECT = "CAS Payment Failure Notification";
 
         public async Task HandleEventAsync(EmailNotificationEvent eventData)

applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Application/Integrations/Ches/ChesClientOptions.cs

@@ -2,8 +2,6 @@
 {
     public class ChesClientOptions
     {
-        public string ChesUrl { get; set; } = string.Empty;
-        public string ChesTokenUrl { get; set; } = string.Empty;
         public string ChesClientId { get; set; } = string.Empty;
         public string ChesClientSecret { get; set; } = string.Empty;
     }

applications/Unity.GrantManager/modules/Unity.Notifications/src/Unity.Notifications.Application/Integrations/Ches/ChesClientService.cs

@@ -1,54 +1,58 @@
 using Volo.Abp;
 using System.Threading.Tasks;
-using System.Text.Json;
 using Unity.Modules.Shared.Integrations;
 using Unity.Modules.Shared.Http;
 using Volo.Abp.Application.Services;
 using Microsoft.Extensions.Options;
 using Volo.Abp.DependencyInjection;
 using System.Net.Http;
 using Volo.Abp.Caching;
+using Unity.GrantManager.Integrations;
 
 namespace Unity.Notifications.Integrations.Ches
 {
     [IntegrationService]
     [RemoteService(false, Name = "Ches")]
     [ExposeServices(typeof(ChesClientService), typeof(IChesClientService))]
-    public class ChesClientService : ApplicationService, IChesClientService
+    public class ChesClientService(
+        IDistributedCache<TokenValidationResponse, string> chesTokenCache,
+        IResilientHttpRequest resilientHttpRequest,
+        IEndpointManagementAppService endpointManagementAppService,
+        IHttpClientFactory httpClientFactory,
+        IOptions<ChesClientOptions> chesClientOptions
+    ) : ApplicationService, IChesClientService
     {
-        private readonly IHttpClientFactory _httpClientFactory;
-        private readonly IResilientHttpRequest _resilientRestClient;
-        private readonly IOptions<ChesClientOptions> _chesClientOptions;
-        private readonly IDistributedCache<TokenValidationResponse, string> _chesTokenCache;
-
-        public ChesClientService(
-            IDistributedCache<TokenValidationResponse, string> chesTokenCache,
-            IResilientHttpRequest resilientHttpRequest,
-            IHttpClientFactory httpClientFactory,
-            IOptions<ChesClientOptions> chesClientOptions)
+        public async Task<HttpResponseMessage?> SendAsync(object emailRequest)
         {
-            _resilientRestClient = resilientHttpRequest;
-            _chesClientOptions = chesClientOptions;
-            _httpClientFactory = httpClientFactory;
-            _chesTokenCache = chesTokenCache;
+            string authToken = await GetAuthTokenAsync();
+            string notificationsApiUrl = await endpointManagementAppService.GetUgmUrlByKeyNameAsync(DynamicUrlKeyNames.NOTIFICATION_API_BASE);
+            var resource = $"{notificationsApiUrl}/email";
+
+            // Pass the object directly; ResilientHttpRequest will serialize it to JSON
+            var response = await resilientHttpRequest.HttpAsync(
+                HttpMethod.Post,
+                resource,
+                emailRequest,
+                authToken
+            );
+
+            return response;
         }
 
-        public async Task<HttpResponseMessage?> SendAsync(object emailRequest)
+        private async Task<string> GetAuthTokenAsync()
         {
-            ClientOptions clientOptions = new ClientOptions
+            string notificationsAuthUrl = await endpointManagementAppService.GetUgmUrlByKeyNameAsync(DynamicUrlKeyNames.NOTIFICATION_AUTH);
+
+            ClientOptions clientOptions = new()
             {
-                Url = _chesClientOptions.Value.ChesTokenUrl,
-                ClientId = _chesClientOptions.Value.ChesClientId,
-                ClientSecret = _chesClientOptions.Value.ChesClientSecret,
+                Url = notificationsAuthUrl,
+                ClientId = chesClientOptions.Value.ChesClientId,
+                ClientSecret = chesClientOptions.Value.ChesClientSecret,
                 ApiKey = "ChesApiKey"
             };
 
-            TokenService tokenService = new(_httpClientFactory, _chesTokenCache, Logger);
-            var authToken = await tokenService.GetAuthTokenAsync(clientOptions);
-            var resource = $"{_chesClientOptions.Value.ChesUrl}/email";
-            string jsonString = JsonSerializer.Serialize(emailRequest);
-            var response = await _resilientRestClient.HttpAsyncWithBody(HttpMethod.Post, resource, jsonString, authToken);
-            return response;
+            TokenService tokenService = new(httpClientFactory, chesTokenCache, Logger);
+            return await tokenService.GetAuthTokenAsync(clientOptions);
         }
     }
 }