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
@@ -4,10 +4,11 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
+using Musify.Application.Shared;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

@@ -26,106 +27,52 @@ public class CreatePlayListCommandHandler(
    IDatabase database,
    UploadIntentValidator uploadIntentValidator,
    ILogger<CreatePlayListCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    PlayListConfiguration playListConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
+    PlayListConfiguration playListConfiguration)
    : ICommandHandler<CreatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
-    private sealed record ResolvedPlayListPictures(EntityPictures? Pictures, UploadIntent? Intent);
-
    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
    {
        var userExists = await database.Users
            .AsNoTracking()
            .AnyAsync(u => u.Id == request.UserId, cancellationToken);
        if (!userExists)
+            return AppErrors.NotFound("User", request.UserId);
+
+        PreparedPicture? picture = null;
+        if (request.PictureIntentId is { } intentId)
        {
-            logger.LogWarning("User {UserId} not found", request.UserId);
-            return Error.NotFound(description: $"User {request.UserId} not found");
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;
+
+            picture = prepared.Value;
        }

-        var picturesResult = await ResolvePicturesAsync(request, cancellationToken);
-        if (picturesResult.IsError)
-            return picturesResult.Errors;
-
-        var resolvedPictures = picturesResult.Value;
-
+        var name = request.Name.Trim();
        var playList = new PlayList
        {
            OwnerUserId = request.UserId,
-            Name = request.Name.Trim(),
-            NormalizedName = TextNormalizer.Normalize(request.Name),
+            Name = name,
+            NormalizedName = TextNormalizer.Normalize(name),
            Description = string.IsNullOrWhiteSpace(request.Description) ? null : request.Description.Trim(),
-            Pictures = resolvedPictures.Pictures,
+            Pictures = picture?.Pictures,
            Visibility = request.Visibility
        };
        await database.PlayLists.AddAsync(playList, cancellationToken);

-        if (resolvedPictures.Intent != null)
+        if (picture != null)
        {
-            var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, resolvedPictures.Pictures!.OriginalName);
-            var publishResult = await PublishCreatePlayListEventAsync(playList.Id, resolvedPictures.Intent, finalPictureKey, cancellationToken);
-            if (publishResult.IsError)
-                return publishResult.Errors;
-        }
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to save playlist for user {UserId}", request.UserId);
-            return Error.Failure(description: $"Failed to create playlist for user {request.UserId}");
-        }
-
-        logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
-        return PlayListApplicationResponse.FromEntity(playList);
-    }
-
-    private async ValueTask<ErrorOr<ResolvedPlayListPictures>> ResolvePicturesAsync(
-        CreatePlayListCommand request, CancellationToken cancellationToken)
-    {
-        if (!request.PictureIntentId.HasValue)
-        {
-            return new ResolvedPlayListPictures(null, null);
-        }
-
-        var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-            uploadIntentConfiguration, request.PictureIntentId.Value, request.UserId, UploadIntentPurpose.PlayListPicture, cancellationToken);
-
-        if (validation.IsError)
-            return validation.Errors;
-
-        return new ResolvedPlayListPictures(EntityPictures.Pending(validation.Value.ObjectName), validation.Value);
-    }
-
-    private async Task<ErrorOr<Success>> PublishCreatePlayListEventAsync(
-        Guid playListId,
-        UploadIntent pictureIntent,
-        string finalPictureKey,
-        CancellationToken cancellationToken)
-    {
-        try
-        {
-            var sizes = playListConfiguration.PicturesSizes.ToImageSizes(playListConfiguration.Routes);
            await eventBus.PublishAsync(
                new CreatePlayListResourcesEvent(
-                    playListId,
-                    pictureIntent.Id,
-                    storageConfiguration.Bucket,
-                    pictureIntent.Key,
-                    finalPictureKey,
-                    sizes.Small,
-                    sizes.Medium,
-                    sizes.Large),
+                    playList.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 create playlist event for playlist {PlayListId}", playListId);
-            return Error.Failure(description: $"Failed to publish create playlist event for playlist {playListId}");
        }
+
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("Created playlist {PlayListId} for user {UserId}", playList.Id, request.UserId);
+
+        return PlayListApplicationResponse.FromEntity(playList);
    }
 }
@@ -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.PlayLists;
-
-public record GetPlayListCoverQuery(Guid PlayListId, string Size)
-    : IQuery<ErrorOr<PlayListCoverLocation>>;
-
-public record PlayListCoverLocation(string Bucket, string Key, string ContentType);
-
-public class GetPlayListCoverQueryHandler(
-    IDatabase database,
-    ApplicationStorageConfiguration storageConfiguration,
-    PlayListConfiguration playListConfiguration)
-    : IQueryHandler<GetPlayListCoverQuery, ErrorOr<PlayListCoverLocation>>
-{
-    public async ValueTask<ErrorOr<PlayListCoverLocation>> Handle(GetPlayListCoverQuery request, CancellationToken cancellationToken)
-    {
-        var owned = await database.PlayLists.AsNoTracking()
-            .Where(e => e.Id == request.PlayListId && e.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(e => new { OwnerUserId = e.OwnerUserId, e.Pictures })
-            .SingleOrDefaultAsync(cancellationToken);
-
-        if (owned?.Pictures == null)
-            return AppErrors.NotFound("PlayListCover", request.PlayListId);
-
-        var pictures = owned.Pictures;
-        var routes = playListConfiguration.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("PlayListCover", request.PlayListId);
-
-        var contentType = MimeUtility.GetMimeMapping(name);
-        return new PlayListCoverLocation(storageConfiguration.Bucket, key, contentType);
-    }
-}
@@ -1,12 +1,8 @@
 using ErrorOr;
 using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.PlayLists.Responses;
+using Musify.Application.Pictures.Responses;
 using Musify.Application.Services;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

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

-public class RequestPlayListPictureUploadCommandHandler(
-    IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
-    IStorageService storageService,
-    ILogger<RequestPlayListPictureUploadCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    PlayListConfiguration playListConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
-    : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PlayListPictureUploadResponse>>
+public class RequestPlayListPictureUploadCommandHandler(UploadIntentIssuer issuer, PlayListConfiguration playListConfiguration)
+    : ICommandHandler<RequestPlayListPictureUploadCommand, ErrorOr<PictureUploadResponse>>
 {
-    public async ValueTask<ErrorOr<PlayListPictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand 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 = playListConfiguration.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.PlayListPicture,
-                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} (PlayListPicture, temp key: {Key})", intent.Id, request.UserId, tempKey);
-
-            return new PlayListPictureUploadResponse(
-                intent.Id,
-                storageConfiguration.Bucket,
-                tempKey,
-                objectName,
-                request.ContentType,
-                uploadIntentConfiguration.UploadUrlExpiresInSeconds,
-                uploadUrl);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to generate playlist picture upload URL for user {UserId}", request.UserId);
-            return Error.Failure(description: "Failed to generate upload URL");
-        }
-    }
+    public async ValueTask<ErrorOr<PictureUploadResponse>> Handle(RequestPlayListPictureUploadCommand request, CancellationToken cancellationToken) =>
+        await issuer.IssuePictureAsync(
+            request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration,
+            request.FileType, request.ContentType, request.ExpectedSizeBytes, cancellationToken);
 }
@@ -1,10 +0,0 @@
-namespace Musify.Application.PlayLists.Responses;
-
-public record PlayListPictureUploadResponse(
-    Guid IntentId,
-    string Bucket,
-    string Key,
-    string PictureName,
-    string ContentType,
-    int ExpiresInSeconds,
-    string UploadUrl);
@@ -5,10 +5,10 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
+using Musify.Application.Pictures;
 using Musify.Application.PlayLists.Responses;
 using Musify.Application.Services;
 using Musify.Application.Shared;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

 namespace Musify.Application.PlayLists;
@@ -27,108 +27,54 @@ public class UpdatePlayListCommandHandler(
    IDatabase database,
    UploadIntentValidator uploadIntentValidator,
    ILogger<UpdatePlayListCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    PlayListConfiguration playListConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
+    PlayListConfiguration playListConfiguration)
    : ICommandHandler<UpdatePlayListCommand, ErrorOr<PlayListApplicationResponse>>
 {
    public async ValueTask<ErrorOr<PlayListApplicationResponse>> Handle(UpdatePlayListCommand request, CancellationToken cancellationToken)
    {
-        var playListEntity = await database.PlayLists.SingleOrDefaultAsync(pl => pl.Id == request.PlayListId, cancellationToken);
-        if (playListEntity == null)
-        {
-            logger.LogInformation("Playlist {PlayListId} not found", request.PlayListId);
-            return Error.NotFound();
-        }
+        var found = await database.PlayLists.FindOwnedAsync(request.PlayListId, request.UserId, cancellationToken);
+        if (found.IsError)
+            return found.Errors;

-        if (playListEntity.OwnerUserId != request.UserId)
-        {
-            logger.LogWarning("User {UserId} is not the owner of playlist {PlayListId}", request.UserId, request.PlayListId);
-            return AppErrors.Forbidden("PlayList", request.PlayListId);
-        }
+        var playList = found.Value;

        if (!string.IsNullOrWhiteSpace(request.NewName))
        {
-            playListEntity.Name = request.NewName.Trim();
-            playListEntity.NormalizedName = TextNormalizer.Normalize(request.NewName);
+            playList.Name = request.NewName.Trim();
+            playList.NormalizedName = TextNormalizer.Normalize(request.NewName);
        }

+        // null means "unchanged"; a blank description clears it.
        if (request.NewDescription != null)
+            playList.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
+
+        if (request.NewVisibility is { } visibility)
+            playList.Visibility = visibility;
+
+        if (request.NewPictureIntentId is { } intentId)
        {
-            playListEntity.Description = string.IsNullOrWhiteSpace(request.NewDescription) ? null : request.NewDescription.Trim();
-        }
+            var prepared = await PictureSourceChange.PrepareAsync(
+                uploadIntentValidator, intentId, request.UserId, UploadIntentPurpose.PlayListPicture, playListConfiguration, cancellationToken);
+            if (prepared.IsError)
+                return prepared.Errors;

-        if (request.NewVisibility.HasValue)
-        {
-            playListEntity.Visibility = request.NewVisibility.Value;
-        }
+            var picture = prepared.Value;
+            playList.Pictures = picture.Pictures;

-        if (request.NewPictureIntentId.HasValue)
-        {
-            var validation = await uploadIntentValidator.ValidateAndLoadAsync(
-                uploadIntentConfiguration,
-                request.NewPictureIntentId.Value, request.UserId, UploadIntentPurpose.PlayListPicture, cancellationToken);
-            if (validation.IsError)
-                return validation.Errors;
-
-            var pictureIntent = validation.Value;
-            playListEntity.Pictures = EntityPictures.Pending(pictureIntent.ObjectName);
-            var finalPictureKey = playListConfiguration.Routes.BuildOriginalPicturePath(request.UserId, pictureIntent.ObjectName);
-
-            var publishResult = await PublishUpdatePlayListPictureSourceEventAsync(
-                playListEntity.Id, pictureIntent, finalPictureKey, cancellationToken);
-            if (publishResult.IsError)
-                return publishResult.Errors;
-        }
-
-        try
-        {
-            await database.SaveChangesAsync(cancellationToken);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to update playlist {PlayListId}", playListEntity.Id);
-            return Error.Failure(description: $"Failed to update playlist {playListEntity.Id}");
-        }
-
-        var coverTrackIds = await database.PlayListHasTracks
-            .AsNoTracking()
-            .Where(plt => plt.PlayListId == playListEntity.Id)
-            .OrderBy(plt => plt.Position)
-            .Take(PlayListApplicationResponse.CoverTrackCount)
-            .Select(plt => plt.TrackId)
-            .ToListAsync(cancellationToken);
-
-        logger.LogInformation("Updated playlist {PlayListId}", playListEntity.Id);
-        return PlayListApplicationResponse.FromEntity(playListEntity, coverTrackIds);
-    }
-
-    private async Task<ErrorOr<Success>> PublishUpdatePlayListPictureSourceEventAsync(
-        Guid playListId,
-        UploadIntent pictureIntent,
-        string finalPictureKey,
-        CancellationToken cancellationToken)
-    {
-        try
-        {
-            var sizes = playListConfiguration.PicturesSizes.ToImageSizes(playListConfiguration.Routes);
            await eventBus.PublishAsync(
                new UpdatePlayListPictureSourceEvent(
-                    playListId,
-                    pictureIntent.Id,
-                    storageConfiguration.Bucket,
-                    pictureIntent.Key,
-                    finalPictureKey,
-                    sizes.Small,
-                    sizes.Medium,
-                    sizes.Large),
+                    playList.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 playlist picture source event for playlist {PlayListId}", playListId);
-            return Error.Failure(description: $"Failed to publish update playlist picture source event for playlist {playListId}");
        }
+
+        await database.SaveChangesAsync(cancellationToken);
+
+        logger.LogInformation("Updated playlist {PlayListId}", playList.Id);
+
+        return await database.PlayLists
+            .AsNoTracking()
+            .Where(p => p.Id == playList.Id)
+            .SelectResponse()
+            .SingleAsync(cancellationToken);
    }
 }