Split Features to create space for more projects

LiteCharms.Features.TechShop/Notifications/Events/Handlers/ProcessEmailNotificationsEventHandler.cs

@@ -0,0 +1,113 @@
+using LiteCharms.Features.Email;
+using LiteCharms.Features.TechShop.Notifications.Models;
+using LiteCharms.Features.TechShop.Postgres;
+
+namespace LiteCharms.Features.TechShop.Notifications.Events.Handlers;
+
+public class ProcessEmailNotificationsEventHandler(IDbContextFactory<ShopDbContext> contextFactory, ILogger<ProcessEmailNotificationsEvent> logger, 
+    EmailService emailService) : INotificationHandler<ProcessEmailNotificationsEvent>
+{
+    private bool dropBatch = false;
+
+    public async ValueTask Handle(ProcessEmailNotificationsEvent message, CancellationToken cancellationToken)
+    {
+        try
+        {
+            using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (emailService.Status != EmailStatuses.Connected)
+                await emailService.ConnectAsync(cancellationToken);
+
+            var notifications = await context.Notifications
+                .OrderByDescending(o => o.CreatedAt)
+                .ThenBy(o => o.Priority)
+                .Where(n => n.Platform == NotificationPlatforms.Email && 
+                    n.Direction == NotificationDirection.Outgoing && n.Processed == false)
+                .Take(message.MaxRecords)
+                .ToListAsync(cancellationToken);
+
+            foreach (var notification in notifications)
+            {
+                if (dropBatch) break;
+
+                var sendResult = await SendEmailAsync(notification,emailService, cancellationToken);
+
+                if(sendResult.IsFailed)
+                {
+                    var errors = new List<string>(1000);
+
+                    errors.AddRange(sendResult.Errors.Select(e => e.Message));
+
+                    if (sendResult.Reasons?.Count > 0)
+                        errors.AddRange(sendResult.Reasons.Select(e => e.Message));
+
+                    notification.HasError = true;                    
+                    notification.Errors = [.. errors];
+                }
+
+                notification.Processed = true;
+                notification.UpdatedAt = DateTime.UtcNow;
+            }
+
+            await context.SaveChangesAsync(cancellationToken);            
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, ex.Message);
+        }
+        finally
+        {
+            await emailService.DisconnectAsync(cancellationToken);
+        }
+    }
+
+    private async Task<Result> SendEmailAsync(Notification notification, EmailService service, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            using Email.Models.Message message = CreateMessage(notification);
+
+            var sendResult = await service.SendEmailAsync(message, cancellationToken);
+
+            if (sendResult.IsFailed)
+            {
+                if (emailService.Status != EmailStatuses.Success && emailService.Status != EmailStatuses.Connected) dropBatch = true;
+
+                return Result.Fail(sendResult.Errors);
+            }
+
+            return sendResult.IsFailed
+                ? Result.Fail(sendResult.Errors)
+                : Result.Ok();
+        }
+        catch (Exception ex)
+        {
+            return Result.Fail(new Error(ex.Message).CausedBy(ex));
+        }
+    }
+
+    private static Email.Models.Message CreateMessage(Notification notification) =>
+        new()
+        {
+            Sender = new Email.Models.Party
+            {
+                Name = notification.SenderName,
+                Address = notification.SenderAddress
+            },
+            Recipient = new Email.Models.Party
+            {
+                Name = notification.RecipientName,
+                Address = notification.RecipientAddress
+            },
+            Subject = notification.Subject,
+            Body = new Email.Models.Body
+            {
+                Properties = new Email.Models.BodyProperties
+                {
+                    HasAttachments = false,
+                    IsHtml = notification.IsHtml
+                },
+                Message = notification.Message
+            }
+        };
+}

LiteCharms.Features.TechShop/Notifications/Events/Handlers/SendShopEmailEnquiryEventHandler.cs

@@ -0,0 +1,25 @@
+using static LiteCharms.Features.Extensions.Email;
+
+namespace LiteCharms.Features.TechShop.Notifications.Events.Handlers;
+
+public class SendShopEmailEnquiryEventHandler(NotificationService notificationService) : 
+    INotificationHandler<SendShopEmailEnquiryEvent>
+{
+    public async ValueTask Handle(SendShopEmailEnquiryEvent notification, CancellationToken cancellationToken) =>
+        await notificationService.CreateNotificationAsync(new Models.CreateNotification
+        {
+            CorrelationId = notification.CorrelationId,
+            CorrelationIdType = CorrelationIdTypes.None,
+            Direction = NotificationDirection.Outgoing,
+            IsHtml = false,
+            IsInternal = true,
+            Message = notification.Message,
+            Platform = NotificationPlatforms.Email,
+            Priority = notification.Priority,
+            Subject = notification.Subject!,
+            Sender = notification.SenderName!,
+            SenderAddress = notification.SenderAddress!,
+            Recipient = ShopEmailFromName,
+            RecipientAddress = ShopEmailFromAddress
+        }, cancellationToken);
+}

LiteCharms.Features.TechShop/Notifications/Events/ProcessEmailNotificationsEvent.cs

@@ -0,0 +1,16 @@
+using LiteCharms.Features.Abstractions;
+
+namespace LiteCharms.Features.TechShop.Notifications.Events;
+
+public class ProcessEmailNotificationsEvent : EventBase, IEvent
+{
+    public string Name { get; set; } = nameof(ProcessEmailNotificationsEvent);
+
+    public int MaxRecords { get; set; }
+
+    public ProcessEmailNotificationsEvent() { MaxRecords = 1000; }
+
+    private ProcessEmailNotificationsEvent(int maxRecords = 1000) => MaxRecords = maxRecords;
+
+    public static ProcessEmailNotificationsEvent Create(int maxRecords = 1000) => new(maxRecords);
+}

LiteCharms.Features.TechShop/Notifications/Events/SendShopEmailEnquiryEvent.cs

@@ -0,0 +1,39 @@
+using LiteCharms.Features.Abstractions;
+
+namespace LiteCharms.Features.TechShop.Notifications.Events;
+
+public class SendShopEmailEnquiryEvent : EventBase, IEvent
+{
+    public string Name { get; set; } = nameof(SendShopEmailEnquiryEvent);
+
+    public string? SenderName { get; set; }
+
+    public string? SenderAddress { get; set; }
+
+    public string? Subject { get; set; }
+
+    public string? Message { get; set; }
+
+    public Priorities Priority { get; set; }
+
+    public SendShopEmailEnquiryEvent() { }
+
+    private SendShopEmailEnquiryEvent(string senderName, string senderAddress, string subject, string message, Priorities priority = Priorities.Medium)
+    {
+        SenderName = senderName;
+        SenderAddress = senderAddress;
+        Subject = subject;
+        Message = message;
+        Priority = priority;
+    }
+
+    public static SendShopEmailEnquiryEvent Create(string senderName, string senderAddress, string subject, string message, Priorities priority = Priorities.Medium)
+    {
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(senderName, nameof(senderName));
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(senderAddress, nameof(senderAddress));
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(subject, nameof(subject));
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(message, nameof(message));
+
+        return new(senderName, senderAddress, subject, message, priority);
+    }
+}