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
@@ -27,9 +27,7 @@ public class CreateTrackCommandHandler(
    IEventBus eventBus,
    UploadIntentValidator uploadIntentValidator,
    ILogger<CreateTrackCommandHandler> logger,
-    ApplicationStorageConfiguration storageConfiguration,
-    TrackConfiguration trackConfiguration,
-    UploadIntentConfiguration uploadIntentConfiguration)
+    TrackConfiguration trackConfiguration)
    : ICommandHandler<CreateTrackCommand, ErrorOr<TrackApplicationResponse>>
 {
    public async ValueTask<ErrorOr<TrackApplicationResponse>> Handle(CreateTrackCommand request, CancellationToken cancellationToken)
@@ -63,13 +61,11 @@ public class CreateTrackCommandHandler(
            return Error.Validation(description: "Picture and audio must use different upload intents.");

        var pictureValidation = await uploadIntentValidator.ValidateAndLoadAsync(
-            uploadIntentConfiguration,
            request.PictureIntentId, request.UserId, UploadIntentPurpose.TrackPicture, cancellationToken);
        if (pictureValidation.IsError)
            return pictureValidation.Errors;

        var audioValidation = await uploadIntentValidator.ValidateAndLoadAsync(
-            uploadIntentConfiguration,
            request.AudioIntentId, request.UserId, UploadIntentPurpose.TrackAudio, cancellationToken);
        if (audioValidation.IsError)
            return audioValidation.Errors;
@@ -115,40 +111,22 @@ public class CreateTrackCommandHandler(
            TrackId = trackEntity.Id
        }, cancellationToken);

-        try
-        {
-            var sizes = trackConfiguration.PicturesSizes.ToImageSizes(trackConfiguration.Routes);
-            await eventBus.PublishAsync(
-                new CreateTrackResourcesEvent(
-                    trackEntity.Id,
-                    pictureIntent.Id,
-                    audioIntent.Id,
-                    storageConfiguration.Bucket,
-                    pictureIntent.Key,
-                    finalPictureKey,
-                    audioIntent.Key,
-                    finalAudioKey,
-                    audioProcessedFolderKey,
-                    sizes.Small,
-                    sizes.Medium,
-                    sizes.Large),
-                cancellationToken);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to publish create track event for track {TrackId}", trackEntity.Id);
-            return Error.Failure(description: $"Failed to create track for {request.Title}");
-        }
+        var sizes = trackConfiguration.PicturesSizes.ToImageSizes(trackConfiguration.Routes);
+        await eventBus.PublishAsync(
+            new CreateTrackResourcesEvent(
+                trackEntity.Id,
+                pictureIntent.Id,
+                audioIntent.Id,
+                pictureIntent.Bucket,
+                pictureIntent.Key,
+                finalPictureKey,
+                audioIntent.Key,
+                finalAudioKey,
+                audioProcessedFolderKey,
+                sizes),
+            cancellationToken);

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

        return TrackApplicationResponse.FromEntity(trackEntity, listensCount: 0);
    }
@@ -1,50 +0,0 @@
-using ErrorOr;
-using Mediator;
-using Microsoft.EntityFrameworkCore;
-using Musify.Application.Configuration;
-using Musify.Application.Contracts;
-using Musify.Application.Shared;
-using Musify.Domain.ValueObjects;
-using MimeMapping;
-
-namespace Musify.Application.Tracks;
-
-public record GetTrackCoverQuery(Guid TrackId, string Size)
-    : IQuery<ErrorOr<TrackCoverLocation>>;
-
-public record TrackCoverLocation(string Bucket, string Key, string ContentType);
-
-public class GetTrackCoverQueryHandler(
-    IDatabase database,
-    ApplicationStorageConfiguration storageConfiguration,
-    TrackConfiguration trackConfiguration)
-    : IQueryHandler<GetTrackCoverQuery, ErrorOr<TrackCoverLocation>>
-{
-    public async ValueTask<ErrorOr<TrackCoverLocation>> Handle(GetTrackCoverQuery request, CancellationToken cancellationToken)
-    {
-        var track = await database.Tracks.AsNoTracking()
-            .Where(t => t.Id == request.TrackId && t.LifeCycleStatus == LifeCycleStatus.Active)
-            .Select(t => new { t.Pictures.SmallName, t.Pictures.MediumName, t.Pictures.LargeName })
-            .SingleOrDefaultAsync(cancellationToken);
-
-        if (track == null)
-            return AppErrors.NotFound("TrackCover", request.TrackId);
-
-        var routes = trackConfiguration.Routes;
-        var size = PictureSizeParser.Parse(request.Size);
-        var name = size switch
-        {
-            PictureSize.Small => track.SmallName,
-            PictureSize.Large => track.LargeName,
-            _ => track.MediumName
-        };
-        var key = string.IsNullOrEmpty(name) ? null : routes.BuildPicturePath(size, name);
-
-        if (string.IsNullOrEmpty(name) || key == null)
-            return AppErrors.NotFound("TrackCover", request.TrackId);
-
-        var contentType = MimeUtility.GetMimeMapping(name);
-
-        return new TrackCoverLocation(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.Services;
 using Musify.Application.Tracks.Responses;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

 namespace Musify.Application.Tracks;
@@ -22,10 +18,7 @@ public record RequestTrackUploadUrlsCommand(
    : ICommand<ErrorOr<TrackUploadUrlsResponse>>;

 public class RequestTrackUploadUrlsCommandHandler(
-    IDatabase database,
-    UploadIntentValidator uploadIntentValidator,
-    IStorageService storageService,
-    ILogger<RequestTrackUploadUrlsCommandHandler> logger,
+    UploadIntentIssuer issuer,
    ApplicationStorageConfiguration storageConfiguration,
    TrackConfiguration trackConfiguration,
    UploadIntentConfiguration uploadIntentConfiguration)
@@ -33,110 +26,32 @@ public class RequestTrackUploadUrlsCommandHandler(
 {
    public async ValueTask<ErrorOr<TrackUploadUrlsResponse>> Handle(RequestTrackUploadUrlsCommand 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 routes = trackConfiguration.Routes;
+        var issued = await issuer.IssueAsync(
+            request.UserId,
+            [
+                new UploadRequest(UploadIntentPurpose.TrackPicture, routes, request.PictureFileType, request.PictureContentType, request.ExpectedPictureSizeBytes),
+                new UploadRequest(UploadIntentPurpose.TrackAudio, routes, request.AudioFileType, request.AudioContentType, request.ExpectedAudioSizeBytes)
+            ],
+            cancellationToken);
+        if (issued.IsError)
+            return issued.Errors;

-        var effectivePictureSize = request.ExpectedPictureSizeBytes
-            ?? uploadIntentConfiguration.DefaultExpectedPictureSizeBytes;
-        var effectiveAudioSize = request.ExpectedAudioSizeBytes
-            ?? uploadIntentConfiguration.DefaultExpectedAudioSizeBytes;
+        var picture = issued.Value[0];
+        var audio = issued.Value[1];

-        var pictureObjectName = $"{Guid.NewGuid()}.{request.PictureFileType.TrimStart('.').ToLowerInvariant()}";
-        var audioObjectName = $"{Guid.NewGuid()}.{request.AudioFileType.TrimStart('.').ToLowerInvariant()}";
-
-        var tempPictureKey = trackConfiguration.Routes.BuildTempPath(
-            uploadIntentConfiguration.TempRootPrefix, request.UserId, pictureObjectName);
-        var tempAudioKey = trackConfiguration.Routes.BuildTempPath(
-            uploadIntentConfiguration.TempRootPrefix, request.UserId, audioObjectName);
-
-        try
-        {
-            var expiresIn = TimeSpan.FromSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds);
-
-            var pictureUploadUrl = await storageService.GetUploadUrlAsync(
-                storageConfiguration.Bucket,
-                tempPictureKey,
-                request.PictureContentType,
-                expiresIn,
-                cancellationToken);
-
-            var audioUploadUrl = await storageService.GetUploadUrlAsync(
-                storageConfiguration.Bucket,
-                tempAudioKey,
-                request.AudioContentType,
-                expiresIn,
-                cancellationToken);
-
-            var expiresAt = DateTime.UtcNow.AddSeconds(uploadIntentConfiguration.UploadUrlExpiresInSeconds);
-
-            await using var transaction = await database.BeginTransactionAsync(
-                System.Data.IsolationLevel.Serializable, cancellationToken);
-
-            var quotaCheck = await uploadIntentValidator.CheckQuotaAsync(
-                uploadIntentConfiguration,
-                request.UserId, effectivePictureSize + effectiveAudioSize, 2, cancellationToken);
-            if (quotaCheck.IsError)
-            {
-                logger.LogWarning("User {UserId} failed upload intent quota check", request.UserId);
-                return quotaCheck.Errors;
-            }
-
-            var pictureIntent = new UploadIntent
-            {
-                UserId = request.UserId,
-                Bucket = storageConfiguration.Bucket,
-                Key = tempPictureKey,
-                ObjectName = pictureObjectName,
-                ContentType = request.PictureContentType,
-                ExpectedSizeBytes = effectivePictureSize,
-                Purpose = UploadIntentPurpose.TrackPicture,
-                ExpiresAt = expiresAt,
-            };
-
-            var audioIntent = new UploadIntent
-            {
-                UserId = request.UserId,
-                Bucket = storageConfiguration.Bucket,
-                Key = tempAudioKey,
-                ObjectName = audioObjectName,
-                ContentType = request.AudioContentType,
-                ExpectedSizeBytes = effectiveAudioSize,
-                Purpose = UploadIntentPurpose.TrackAudio,
-                ExpiresAt = expiresAt,
-            };
-
-            await database.UploadIntents.AddAsync(pictureIntent, cancellationToken);
-            await database.UploadIntents.AddAsync(audioIntent, cancellationToken);
-            await database.SaveChangesAsync(cancellationToken);
-            await transaction.CommitAsync(cancellationToken);
-
-            logger.LogInformation("Issued upload intents {PictureIntentId}/{AudioIntentId} for user {UserId} (TrackPicture/TrackAudio)",
-                pictureIntent.Id, audioIntent.Id, request.UserId);
-
-            return new TrackUploadUrlsResponse(
-                pictureIntent.Id,
-                audioIntent.Id,
-                storageConfiguration.Bucket,
-                tempPictureKey,
-                pictureObjectName,
-                request.PictureContentType,
-                pictureUploadUrl,
-                tempAudioKey,
-                audioObjectName,
-                request.AudioContentType,
-                audioUploadUrl,
-                uploadIntentConfiguration.UploadUrlExpiresInSeconds);
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to generate track upload URLs for user {UserId}", request.UserId);
-            return Error.Failure(description: "Failed to generate upload URLs");
-        }
+        return new TrackUploadUrlsResponse(
+            picture.IntentId,
+            audio.IntentId,
+            storageConfiguration.Bucket,
+            picture.Key,
+            picture.ObjectName,
+            picture.ContentType,
+            picture.UploadUrl,
+            audio.Key,
+            audio.ObjectName,
+            audio.ContentType,
+            audio.UploadUrl,
+            uploadIntentConfiguration.UploadUrlExpiresInSeconds);
    }
 }