Notify recipients upon multipart transfer finalization

Author: Jack-Edwards

Crypter.Core/Features/Transfer/Commands/FinalizeMultipartFileTransferCommand.cs

@@ -41,6 +41,7 @@
 using MediatR;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Storage;
+using Guid = System.Guid;
 using Unit = EasyMonads.Unit;
 
 namespace Crypter.Core.Features.Transfer.Commands;
@@ -81,6 +82,9 @@ from additionalData in ValidateRequestAsync(request)
                 from finalizeResult in FinalizeAsync(request, additionalData).ToLeftEitherAsync(Unit.Default)
                 let successfulMultipartFinalizeEvent = new SuccessfulMultipartFileTransferFinalizationEvent(
                     additionalData.InitializedTransferEntity.Id,
+                    additionalData.InitializedTransferEntity.RecipientId.HasValue
+                        ? Maybe<Guid>.None
+                        : additionalData.InitializedTransferEntity.RecipientId.Value,
                     utcNow)
                 from sideEffects in Either<FinalizeMultipartFileTransferError, Unit>.FromRightAsync(
                     UnitPublisher.Publish(_publisher, successfulMultipartFinalizeEvent))

Crypter.Core/Features/Transfer/Common.cs

@@ -6,9 +6,11 @@
 using Crypter.Common.Enums;
 using Crypter.Core.Features.Metrics.Queries;
 using Crypter.Core.LinqExpressions;
+using Crypter.Core.Services;
 using Crypter.Core.Settings;
 using Crypter.DataAccess;
 using EasyMonads;
+using Hangfire;
 using Microsoft.EntityFrameworkCore;
 
 namespace Crypter.Core.Features.Transfer;
@@ -89,6 +91,30 @@ internal static TransferUserType DetermineUploadTransferUserType(Maybe<Guid> sen
         return TransferUserType.Anonymous;
     }
 
+    internal static async Task<Unit> QueueTransferNotificationAsync(
+        DataContext dataContext,
+        IBackgroundJobClient backgroundJobClient,
+        IHangfireBackgroundService hangfireBackgroundService,
+        Guid itemId,
+        TransferItemType itemType,
+        Guid recipientId)
+    {
+        bool userExpectsNotification = await dataContext.Users
+            .Where(x => x.Id == recipientId)
+            .Where(x => x.NotificationSetting!.EnableTransferNotifications
+                        && x.EmailVerified
+                        && x.NotificationSetting.EmailNotifications)
+            .AnyAsync();
+
+        if (userExpectsNotification)
+        {
+            backgroundJobClient.Enqueue(() =>
+                hangfireBackgroundService.SendTransferNotificationAsync(itemId, itemType));
+        }
+
+        return Unit.Default;
+    }
+    
     /// <summary>
     /// Query for a transfer recipient's user id.
     /// </summary>

Crypter.Core/Features/Transfer/Events/SuccessfulMultipartFileTransferFinalizationEvent.cs

@@ -29,33 +29,45 @@
 using System.Threading.Tasks;
 using Crypter.Common.Enums;
 using Crypter.Core.Services;
+using Crypter.DataAccess;
+using EasyMonads;
 using Hangfire;
 using MediatR;
 
 namespace Crypter.Core.Features.Transfer.Events;
 
-public sealed record SuccessfulMultipartFileTransferFinalizationEvent(Guid ItemId, DateTimeOffset Timestamp)
+public sealed record SuccessfulMultipartFileTransferFinalizationEvent(Guid ItemId, Maybe<Guid> RecipientId, DateTimeOffset Timestamp)
     : INotification;
 
 internal sealed class SuccessfulMultipartFileTransferFinalizationEventHandler
     : INotificationHandler<SuccessfulMultipartFileTransferFinalizationEvent>
 {
     private readonly IBackgroundJobClient _backgroundJobClient;
+    private readonly DataContext _dataContext;
     private readonly IHangfireBackgroundService _hangfireBackgroundService;
 
     public SuccessfulMultipartFileTransferFinalizationEventHandler(
         IBackgroundJobClient backgroundJobClient,
+        DataContext dataContext,
         IHangfireBackgroundService hangfireBackgroundService)
     {
         _backgroundJobClient = backgroundJobClient;
+        _dataContext = dataContext;
         _hangfireBackgroundService = hangfireBackgroundService;
     }
 
-    public Task Handle(SuccessfulMultipartFileTransferFinalizationEvent notification, CancellationToken cancellationToken)
+    public async Task Handle(SuccessfulMultipartFileTransferFinalizationEvent notification, CancellationToken cancellationToken)
     {
+        await notification.RecipientId.IfSomeAsync(async recipientId =>
+            await Common.QueueTransferNotificationAsync(
+                _dataContext,
+                _backgroundJobClient,
+                _hangfireBackgroundService,
+                notification.ItemId,
+                TransferItemType.File,
+                recipientId));
+        
         _backgroundJobClient.Enqueue(() =>
             _hangfireBackgroundService.LogSuccessfulMultipartTransferFinalizationAsync(notification.ItemId, TransferItemType.File, notification.Timestamp));
-        
-        return Task.CompletedTask;
     }
 }

Crypter.Core/Features/Transfer/Events/SuccessfulTransferUploadEvent.cs

@@ -60,7 +60,13 @@ public SuccessfulTransferUploadEventHandler(
     public async Task Handle(SuccessfulTransferUploadEvent notification, CancellationToken cancellationToken)
     {
         await notification.RecipientId.IfSomeAsync(async recipientId =>
-            await QueueTransferNotificationAsync(notification.ItemId, notification.ItemType, recipientId));
+            await Common.QueueTransferNotificationAsync(
+                _dataContext,
+                _backgroundJobClient,
+                _hangfireBackgroundService,
+                notification.ItemId,
+                notification.ItemType,
+                recipientId));
 
         _backgroundJobClient.Schedule(() =>
             _hangfireBackgroundService.DeleteTransferAsync(notification.ItemId, notification.ItemType, notification.UserType, true),
@@ -75,25 +81,4 @@ await notification.RecipientId.IfSomeAsync(async recipientId =>
         _backgroundJobClient.Enqueue(() =>
             _hangfireBackgroundService.LogSuccessfulTransferUploadAsync(notification.ItemId, notification.ItemType, notification.Size, senderId, recipientUsername, notification.Timestamp));
     }
-    
-    private async Task<Unit> QueueTransferNotificationAsync(
-        Guid itemId,
-        TransferItemType itemType,
-        Guid recipientId)
-    {
-        bool userExpectsNotification = await _dataContext.Users
-            .Where(x => x.Id == recipientId)
-            .Where(x => x.NotificationSetting!.EnableTransferNotifications
-                        && x.EmailVerified
-                        && x.NotificationSetting.EmailNotifications)
-            .AnyAsync();
-
-        if (userExpectsNotification)
-        {
-            _backgroundJobClient.Enqueue(() =>
-                _hangfireBackgroundService.SendTransferNotificationAsync(itemId, itemType));
-        }
-
-        return Unit.Default;
-    }
 }