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

2026-09-24 12:04:54 +02:00
parent 4b147d9ee3
commit 75d0c0817e
55 changed files with 667 additions and 1163 deletions
@@ -5,9 +5,10 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Albums.Responses;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.Services;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

@@ -26,9 +27,7 @@ public class CreateAlbumCommandHandler(
    IDatabase database,
    UploadIntentValidator uploadIntentValidator,
    ILogger<CreateAlbumCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    AlbumConfiguration albumConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
+    AlbumConfiguration albumConfiguration)
    : ICommandHandler<CreateAlbumCommand, ErrorOr<AlbumApplicationResponse>>
 {
    public async ValueTask<ErrorOr<AlbumApplicationResponse>> Handle(CreateAlbumCommand request, CancellationToken cancellationToken)
@@ -37,17 +36,14 @@ public class CreateAlbumCommandHandler(
            .AsNoTracking()
            .AnyAsync(user => user.Id == request.UserId, cancellationToken);
        if (!userExists)
-        {
-            logger.LogWarning("User {UserId} not found", request.UserId);
-            return Error.NotFound(description: $"User {request.UserId} not found");
-        }
+            return AppErrors.NotFound("User", request.UserId);

-        var pictureIntent = await uploadIntentValidator.ValidateAndLoadAsync(
-            uploadIntentConfiguration, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, cancellationToken);
-        if (pictureIntent.IsError)
-            return pictureIntent.Errors;
+        var prepared = await PictureSourceChange.PrepareAsync(
+            uploadIntentValidator, request.PictureIntentId, request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration, cancellationToken);
+        if (prepared.IsError)
+            return prepared.Errors;

-        var intent = pictureIntent.Value;
+        var picture = prepared.Value;
        var title = request.Title.Trim();

        var album = new Album
@@ -57,57 +53,20 @@ public class CreateAlbumCommandHandler(
            NormalizedTitle = TextNormalizer.Normalize(title),
            Description = request.Description,
            ReleaseYear = request.ReleaseYear,
-            Pictures = EntityPictures.Pending(intent.ObjectName)
+            Pictures = picture.Pictures
        };

        await database.Albums.AddAsync(album, cancellationToken);

-        var finalPictureKey = albumConfiguration.Routes.BuildOriginalPicturePath(request.UserId, intent.ObjectName);
-        var publishResult = await PublishCreateAlbumEventAsync(album.Id, intent, finalPictureKey, cancellationToken);
-        if (publishResult.IsError)
-            return publishResult.Errors;
+        await eventBus.PublishAsync(
+            new CreateAlbumResourcesEvent(
+                album.Id, picture.Intent.Id, picture.Intent.Bucket, picture.Intent.Key, picture.FinalKey, picture.Sizes),
+            cancellationToken);

-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to save album for user {UserId}", request.UserId);
-            return Error.Failure(description: $"Failed to create album for user {request.UserId}");
-        }
+        await database.SaveChangesAsync(cancellationToken);

        logger.LogInformation("Created album {AlbumId} for user {UserId}", album.Id, request.UserId);

        return AlbumApplicationResponse.FromEntity(album, trackCount: 0);
    }
-
-    private async Task<ErrorOr<Success>> PublishCreateAlbumEventAsync(
-        Guid albumId,
-        UploadIntent pictureIntent,
-        string finalPictureKey,
-        CancellationToken cancellationToken)
-    {
-        try
-        {
-            var sizes = albumConfiguration.PicturesSizes.ToImageSizes(albumConfiguration.Routes);
-            await eventBus.PublishAsync(
-                new CreateAlbumResourcesEvent(
-                    albumId,
-                    pictureIntent.Id,
-                    storageConfiguration.Bucket,
-                    pictureIntent.Key,
-                    finalPictureKey,
-                    sizes.Small,
-                    sizes.Medium,
-                    sizes.Large),
-                cancellationToken);
-            return Result.Success;
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to publish create album event for album {AlbumId}", albumId);
-            return Error.Failure(description: $"Failed to publish create album event for album {albumId}");
-        }
-    }
 }
@@ -1,57 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using MimeMapping;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
-
-namespace Musify.Application.Albums;
-
-public record GetAlbumCoverQuery(Guid AlbumId, string Size)
-    : IQuery<ErrorOr<AlbumCoverLocation>>;
-
-public record AlbumCoverLocation(string Bucket, string Key, string ContentType);
-
-public class GetAlbumCoverQueryHandler(
-    IDatabase database,
-    ApplicationStorageConfiguration storageConfiguration,
-    AlbumConfiguration albumConfiguration)
-    : IQueryHandler<GetAlbumCoverQuery, ErrorOr<AlbumCoverLocation>>
-{
-    public async ValueTask<ErrorOr<AlbumCoverLocation>> Handle(GetAlbumCoverQuery request, CancellationToken cancellationToken)
-    {
-        var owned = await database.Albums.AsNoTracking()
-            .Where(e => e.Id == request.AlbumId && e.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(e => new { OwnerUserId = e.OwnerUserId, e.Pictures })
-            .SingleOrDefaultAsync(cancellationToken);
-
-        if (owned?.Pictures == null)
-            return AppErrors.NotFound("AlbumCover", request.AlbumId);
-
-        var pictures = owned.Pictures;
-        var routes = albumConfiguration.Routes;
-        var size = PictureSizeParser.Parse(request.Size);
-        var name = size switch
-        {
-            PictureSize.Small => pictures.SmallName,
-            PictureSize.Large => pictures.LargeName,
-            _ => pictures.MediumName
-        };
-        var key = string.IsNullOrEmpty(name) ? null : routes.BuildPicturePath(size, name);
-
-        // The resized files only exist once processing has finished; until then serve the original.
-        if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
-        {
-            name = pictures.OriginalName;
-            key = string.IsNullOrEmpty(name) ? null : routes.BuildOriginalPicturePath(owned.OwnerUserId, name);
-        }
-
-        if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(key))
-            return AppErrors.NotFound("AlbumCover", request.AlbumId);
-
-        var contentType = MimeUtility.GetMimeMapping(name);
-        return new AlbumCoverLocation(storageConfiguration.Bucket, key, contentType);
-    }
-}
@@ -1,12 +1,8 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Albums.Responses;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
+using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

 namespace Musify.Application.Albums;
@@ -16,89 +12,13 @@ public record RequestAlbumPictureUploadCommand(
    string FileType,
    string ContentType,
    long? ExpectedSizeBytes = null)
-    : ICommand<ErrorOr<AlbumPictureUploadResponse>>;
+    : ICommand<ErrorOr<PictureUploadResponse>>;

-public class RequestAlbumPictureUploadCommandHandler(
-    IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
-    IStorageService storageService,
-    ILogger<RequestAlbumPictureUploadCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    AlbumConfiguration albumConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
-    : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<AlbumPictureUploadResponse>>
+public class RequestAlbumPictureUploadCommandHandler(UploadIntentIssuer issuer, AlbumConfiguration albumConfiguration)
+    : ICommandHandler<RequestAlbumPictureUploadCommand, ErrorOr<PictureUploadResponse>>
 {
-    public async ValueTask<ErrorOr<AlbumPictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken)
-    {
-        var userExists = await database.Users
-            .AsNoTracking()
-            .AnyAsync(u => u.Id == request.UserId, cancellationToken);
-        if (!userExists)
-        {
-            logger.LogWarning("User {UserId} not found", request.UserId);
-            return Error.NotFound(description: $"User {request.UserId} not found");
-        }
-
-        var effectiveSizeBytes = request.ExpectedSizeBytes
-            ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
-
-        var objectName = $"{Guid.NewGuid()}.{request.FileType.TrimStart('.').ToLowerInvariant()}";
-
-        var tempKey = albumConfiguration.Routes.BuildTempPath(
-            uploadIntentConfiguration.TempRootPrefix, request.UserId, objectName);
-
-        try
-        {
-            var uploadUrl = await storageService.GetUploadUrlAsync(
-                storageConfiguration.Bucket,
-                tempKey,
-                request.ContentType,
-                TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-                cancellationToken);
-
-            await using var transaction = await database.BeginTransactionAsync(
-                System.Data.IsolationLevel.Serializable, cancellationToken);
-
-            var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
-                uploadIntentConfiguration,
-                request.UserId, effectiveSizeBytes, 1, cancellationToken);
-            if (quotaCheck.IsError)
-            {
-                logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
-                return quotaCheck.Errors;
-            }
-
-            var intent = new UploadIntent
-            {
-                UserId = request.UserId,
-                Bucket = storageConfiguration.Bucket,
-                Key = tempKey,
-                ObjectName = objectName,
-                ContentType = request.ContentType,
-                ExpectedSizeBytes = effectiveSizeBytes,
-                Purpose = UploadIntentPurpose.AlbumPicture,
-                ExpiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds),
-            };
-
-            await database.UploadIntents.AddAsync(intent, cancellationToken);
-            await database.SaveChangesAsync(cancellationToken);
-            await transaction.CommitAsync(cancellationToken);
-
-            logger.LogInformation("Issued upload intent {IntentId} for user {UserId} (AlbumPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
-
-            return new AlbumPictureUploadResponse(
-                intent.Id,
-                storageConfiguration.Bucket,
-                tempKey,
-                objectName,
-                request.ContentType,
-                uploadIntentConfiguration.UploadUrlExpiresInSeconds,
-                uploadUrl);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to generate album picture upload URL for user {UserId}", request.UserId);
-            return Error.Failure(description: "Failed to generate upload URL");
-        }
-    }
+    public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestAlbumPictureUploadCommand request, CancellationToken cancellationToken) =>
+        await issuer.IssuePictureAsync(
+            request.UserId, UploadIntentPurpose.AlbumPicture, albumConfiguration,
+            request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
 }
@@ -1,10 +0,0 @@
-namespace Musify.Application.Albums.Responses;
-
-public record AlbumPictureUploadResponse(
-    Guid IntentId,
-    string Bucket,
-    string Key,
-    string PictureName,
-    string ContentType,
-    int ExpiresInSeconds,
-    string UploadUrl);
@@ -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);
    }
 }