Deduplicate picture flows: shared upload issuer, cover query and picture source change

backend/Core/Musify.Application/Albums/UpdateAlbum.cs

@@ -6,9 +6,9 @@ using Musify.Application.Albums.Responses;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.Services;
 using Musify.Application.Shared;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Albums;
@@ -27,27 +27,16 @@ public class UpdateAlbumCommandHandler(
     IDatabase database,
     UploadIntentValidator uploadIntentValidator,
     ILogger<UpdateAlbumCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    AlbumConfiguration albumConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
+    AlbumConfiguration albumConfiguration)
     : ICommandHandler<UpdateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
 {
     public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(UpdateAlbumCommand request, CancellationToken cancellationToken)
     {
-        var album = await database.Albums
-            .SingleOrDefaultAsync(a => a.Id == request.AlbumId, cancellationToken);
-        if (album == null)
-        {
-            logger.LogInformation("Album {AlbumId} not found", request.AlbumId);
-            return Error.NotFound();
-        }
-
-        if (album.OwnerUserId != request.UserId)
-        {
-            logger.LogWarning("Album {AlbumId} does not belong to user {UserId}", request.AlbumId, request.UserId);
-            return AppErrors.Forbidden("Album", request.AlbumId);
-        }
+        var found = await database.Albums.FindOwnedAsync(request.AlbumId, request.UserId, cancellationToken);
+        if (found.IsError)
+            return found.Errors;
 
+        var album = found.Value;
         var title = request.Title.Trim();
 
         album.Title = title;
@@ -55,75 +44,30 @@ public class UpdateAlbumCommandHandler(
         album.Description = request.Description;
         album.ReleaseYear = request.ReleaseYear;
 
-        if (request.NewPictureIntentId.HasValue)
+        if (request.NewPictureIntentId is { } intentId)
         {
-            var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration,
-                request.NewPictureIntentId.Value, request.UserId, UploadIntentPurpose.AlbumPicture, cancellationToken);
-            if (validation.IsError)
-                return validation.Errors;
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
 
-            var pictureIntent = validation.Value;
-            album.Pictures = EntityPictures.Pending(pictureIntent.ObjectName);
-            var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
+            var picture = prepared.Value;
+            album.Pictures = picture.Pictures;
 
-            var publishResult = await PublishUpdateAlbumPictureSourceEventAsync(
-                album.Id, pictureIntent, finalPictureKey, cancellationToken);
-            if (publishResult.IsError)
-                return publishResult.Errors;
-        }
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to update album {AlbumId}", request.AlbumId);
-            return Error.Failure(description: $"Failed to update album {request.AlbumId}");
-        }
-
-        var albumTracks = database.AlbumHasTracks
-            .AsNoTracking()
-            .Where(albumTrack => albumTrack.AlbumId == album.Id);
-
-        var trackCount = await albumTracks.CountAsync(cancellationToken);
-        var coverTrackIds = await albumTracks
-            .OrderBy(albumTrack => albumTrack.TrackNumber)
-            .Take(AlbumApplicationResponse.CoverTrackCount)
-            .Select(albumTrack => albumTrack.TrackId)
-            .ToListAsync(cancellationToken);
-
-        logger.LogInformation("Updated album {AlbumId}", album.Id);
-        return AlbumApplicationResponse.FromEntity(album, trackCount, coverTrackIds);
-    }
-
-    private async Task<ErrorOr<Success>> PublishUpdateAlbumPictureSourceEventAsync(
-        Guid albumId,
-        UploadIntent pictureIntent,
-        string finalPictureKey,
-        CancellationToken cancellationToken)
-    {
-        try
-        {
-            var sizes = albumConfiguration.PicturesSizes.ToImageSizes(albumConfiguration.Routes);
             await eventBus.PublishAsync(
                 new UpdateAlbumPictureSourceEvent(
-                    albumId,
-                    pictureIntent.Id,
-                    storageConfiguration.Bucket,
-                    pictureIntent.Key,
-                    finalPictureKey,
-                    sizes.Small,
-                    sizes.Medium,
-                    sizes.Large),
+                    album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
                 cancellationToken);
-            return Result.Success;
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to publish update album picture source event for album {AlbumId}", albumId);
-            return Error.Failure(description: $"Failed to publish update album picture source event for album {albumId}");
         }
+
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("Updated album {AlbumId}", album.Id);
+
+        return await database.Albums
+            .AsNoTracking()
+            .Where(a => a.Id == album.Id)
+            .SelectResponse()
+            .SingleAsync(cancellationToken);
     }
 }