Rewrite handlers

2026-03-28 20:47:54 +01:00
parent 7709fe737f
commit 4e3302c144
12 changed files with 441 additions and 285 deletions
@@ -2,6 +2,7 @@
 using DispatchR.Abstractions.Send;
 using Musify.Application.Contracts.Application;
 using Musify.Application.Tracks.Responses;
+using Musify.Domain.Entities;

 namespace Musify.Application.Tracks.Commands
 {
@@ -10,5 +11,20 @@ namespace Musify.Application.Tracks.Commands
        string Title,
        IFileData Picture,
        IFileData Audio)
-        : IRequest<CreateTrackCommand, Task<Result<TrackResponse> >>;
+        : IRequest<CreateTrackCommand, Task<Result<TrackResponse> >>
+    {
+        public static Track ToEntity(CreateTrackCommand command, string smallPictureName, string mediumPictureName, string largePictureName)
+        {
+            return new Track
+            {
+                Title = command.Title,
+                NormalizedTitle = command.Title.ToUpperInvariant(),
+                OriginalPictureName = Guid.NewGuid() + command.Picture.FileType,
+                OriginalAudioName = Guid.NewGuid() + command.Audio.FileType,
+                SmallPictureName = smallPictureName,
+                MediumPictureName = mediumPictureName,
+                LargePictureName = largePictureName
+            };
+        }
+    }
 }
@@ -0,0 +1,10 @@
+using Ardalis.Result;
+using DispatchR.Abstractions.Send;
+
+namespace Musify.Application.Tracks.Commands
+{
+    public record DeleteTrackCommand(
+        Guid UserId,
+        Guid TrackId)
+        : IRequest<DeleteTrackCommand, Task<Result>>;
+}
@@ -2,7 +2,6 @@
 using DispatchR.Abstractions.Send;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
-using Musify.Application.Contracts.Application;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Application.Events;
 using Musify.Application.Tracks.Commands;
@@ -21,111 +20,118 @@ namespace Musify.Application.Tracks.Handler

            if (userExists is null)
            {
-                logger.LogWarning("User with id={UserId} not found", request.UserId);
-                return Result.NotFound($"User with id {request.UserId} not found");
+                logger.LogWarning("User with id={UserId} not found.", request.UserId);
+                return Result.NotFound($"User with id {request.UserId} not found.");
            }

-            var originalPictureFileName = Guid.NewGuid() + request.Picture.FileType;
-            var originalAudioFileName = Guid.NewGuid() + request.Audio.FileType;
-            var track = new Track
-            {
-                Title = request.Title,
-                NormalizedTitle = request.Title.Trim().ToUpperInvariant(),
-                OriginalPictureName = originalPictureFileName,
-                OriginalAudioName = originalAudioFileName,
-                SmallPictureName = trackConfiguration.Routes.PresetMediumPicture,
-                MediumPictureName = trackConfiguration.Routes.PresetMediumPicture,
-                LargePictureName = trackConfiguration.Routes.PresetLargePicture,
-            };
+            var trackEntity = CreateTrackCommand.ToEntity(
+                request,
+                trackConfiguration.Routes.PresetSmallPicture,
+                trackConfiguration.Routes.PresetMediumPicture,
+                trackConfiguration.Routes.PresetLargePicture);

-            var originalPictureKey = Path.Combine(trackConfiguration.Routes.OriginalPicturesPath,
-                originalPictureFileName);
-            var pictureUploadResult = await UploadFile(request.Picture, originalPictureKey, cancellationToken);
-            if (!pictureUploadResult.IsSuccess)
-            {
-                logger.LogError("Failed to upload picture for track={TrackTitle}", request.Title);
-                return Result.Error($"Failed to upload picture for track {request.Title}");
-            }
+            var fullPictureKey = Path.Combine(trackConfiguration.Routes.OriginalPicturesPath, trackEntity.OriginalPictureName);
+            var fullAudioKey = Path.Combine(trackConfiguration.Routes.OriginalAudiosPath, trackEntity.OriginalAudioName);

+            await UploadFilesAsync(request, fullPictureKey, fullAudioKey, cancellationToken);

-            var audioKey = Path.Combine(trackConfiguration.Routes.OriginalAudiosPath,
-                Guid.NewGuid() + request.Audio.FileType);
-            var audioUploadResult = await UploadFile(request.Audio, audioKey, cancellationToken);
-            if (!audioUploadResult.IsSuccess)
-            {
-                logger.LogError("Failed to upload audio for track={TrackTitle}", request.Title);
-                return Result.Error($"Failed to upload audio for track {request.Title}");
-            }
+            await PublishUpdateEvent(trackEntity, cancellationToken);
+            await PublishTranscodeEvent(trackEntity, cancellationToken);

-            try
-            {
-                await PublishUpdateEvent(originalPictureKey, track, cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish resize picture event for Track with id={TrackId}.", track.Id);
-                return Result.Error($"Failed to publish resize picture event for Track with id {track.Id}.");
-            }
-
-            try
-            {
-                await PublishTranscodeEvent(track.Id, audioUploadResult, cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to publish transcode audio event for Track with id={TrackId}.", track.Id);
-                return Result.Error($"An error occurred while processing the audio for Track with id {track.Id}.");
-            }
-
-            await database.Tracks.AddAsync(track, cancellationToken);
+            await database.Tracks.AddAsync(trackEntity, cancellationToken);
            await database.SaveChangesAsync(cancellationToken);

            return Result.Success();
        }

-        async Task<Result<string>> UploadFile(IFileData fileData, string key, CancellationToken cancellationToken)
+        async Task<Result> UploadFilesAsync(
+            CreateTrackCommand request,
+            string pictureKey,
+            string audioKey,
+            CancellationToken cancellationToken)
        {
-            var uploadFile = await storageHandler.UploadFileAsync(
-                fileData.FileStream,
-                fileData.ContentType,
+            var pictureUpload = await storageHandler.UploadFileAsync(
+                request.Picture.FileStream,
+                request.Picture.ContentType,
                storageConfiguration.BucketName,
-                key,
+                pictureKey,
                cancellationToken);

-            return uploadFile;
-        }
+            if (!pictureUpload.IsSuccess)
+            {
+                var errors = string.Join(", ", pictureUpload.Errors);
+                return Result.Error($"Failed to upload picture for track {request.Title}. Errors: {errors}.");
+            }

-        async Task PublishUpdateEvent(string originalPictureKey, Track track, CancellationToken cancellationToken)
-        {
-            await eventBus.PublishAsync(new UpdateTrackPictureEvent(
-                track.Id,
+            var audioUpload = await storageHandler.UploadFileAsync(
+                request.Audio.FileStream,
+                request.Audio.ContentType,
                storageConfiguration.BucketName,
-                originalPictureKey,
-                new ImageSize(
-                    trackConfiguration.Routes.PresetSmallPicture,
-                    trackConfiguration.PicturesSizes.SmallPictureWidth,
-                    trackConfiguration.PicturesSizes.SmallPictureHeight),
-                new ImageSize(
-                    trackConfiguration.Routes.PresetMediumPicture,
-                    trackConfiguration.PicturesSizes.MediumPictureWidth,
-                    trackConfiguration.PicturesSizes.MediumPictureHeight),
-                new ImageSize(
-                    trackConfiguration.Routes.PresetLargePicture,
-                    trackConfiguration.PicturesSizes.LargePictureWidth,
-                    trackConfiguration.PicturesSizes.LargePictureHeight)), cancellationToken);
+                audioKey,
+                cancellationToken);
+
+            if (!audioUpload.IsSuccess)
+            {
+                await RollbackFilesAsync(pictureKey, audioKey, cancellationToken);
+                var errors = string.Join(", ", audioUpload.Errors);
+                return Result.Error($"Failed to upload audio for track {request.Title}. Errors: {errors}.");
+            }
+
+            return Result.Success();
        }

-        async Task PublishTranscodeEvent(Guid trackId, string audioKey, CancellationToken cancellationToken)
+        async Task RollbackFilesAsync(string pictureKey, string audioKey, CancellationToken cancellationToken)
+        {
+            await storageHandler.RemoveFileAsync(storageConfiguration.BucketName, pictureKey, cancellationToken);
+            await storageHandler.RemoveFileAsync(storageConfiguration.BucketName, audioKey, cancellationToken);
+            logger.LogInformation("Rolled back uploaded files={PictureKey}, {AudioKey}.", pictureKey, audioKey);
+        }
+
+        async Task PublishUpdateEvent(Track track, CancellationToken cancellationToken)
+        {
+            try
+            {
+                await eventBus.PublishAsync(new UpdateTrackPictureEvent(
+                    track.Id,
+                    storageConfiguration.BucketName,
+                    track.OriginalPictureName,
+                    new ImageSize(
+                        trackConfiguration.Routes.PresetSmallPicture,
+                        trackConfiguration.PicturesSizes.SmallPictureWidth,
+                        trackConfiguration.PicturesSizes.SmallPictureHeight),
+                    new ImageSize(
+                        trackConfiguration.Routes.PresetMediumPicture,
+                        trackConfiguration.PicturesSizes.MediumPictureWidth,
+                        trackConfiguration.PicturesSizes.MediumPictureHeight),
+                    new ImageSize(
+                        trackConfiguration.Routes.PresetLargePicture,
+                        trackConfiguration.PicturesSizes.LargePictureWidth,
+                        trackConfiguration.PicturesSizes.LargePictureHeight)), cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to publish resize picture event for Track with id={TrackId}.", track.Id);
+            }
+        }
+
+        async Task PublishTranscodeEvent(Track track, CancellationToken cancellationToken)
        {
            var destinationFolderAudio = Path.Combine(trackConfiguration.Routes.ProcessedAudiosPath,
                Guid.NewGuid().ToString());

-            await eventBus.PublishAsync(new UpdateTrackAudioEvent(
-                trackId,
-                storageConfiguration.BucketName,
-                audioKey,
-                storageConfiguration.BucketName,
-                destinationFolderAudio), cancellationToken);
+            try
+            {
+                await eventBus.PublishAsync(new UpdateTrackAudioEvent(
+                    track.Id,
+                    storageConfiguration.BucketName,
+                    track.OriginalAudioName,
+                    storageConfiguration.BucketName,
+                    destinationFolderAudio), cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to publish transcode audio event for Track with id={TrackId}.", track.Id);
+            }
        }
    }
-}
+}
@@ -0,0 +1,69 @@
+using Ardalis.Result;
+using DispatchR.Abstractions.Send;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Application.Tracks.Commands;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Tracks.Handler
+{
+    public class DeleteTrackCommandHandler(IDatabase database, IStorageHandler storageHandler, ILogger<DeleteTrackCommandHandler> logger,
+        TrackConfiguration trackConfiguration, ApplicationStorageConfiguration storageConfiguration)
+        : IRequestHandler<DeleteTrackCommand, Task<Result>>
+    {
+        public async Task<Result> Handle(DeleteTrackCommand request, CancellationToken cancellationToken)
+        {
+            var track = await database.Tracks.FindAsync(request.TrackId, cancellationToken);
+
+            if (track is null)
+            {
+                logger.LogInformation("Track with id={TrackId} not found.", request.TrackId);
+                return Result.NotFound();
+            }
+
+            if (track.Id != request.UserId)
+            {
+                logger.LogInformation("User with id={UserId} is not the owner of track with id={TrackId}.", request.UserId, request.TrackId);
+                return Result.Unauthorized();
+            }
+
+            await RemovePictures(track, cancellationToken);
+            await RemoveAudios(track, cancellationToken);
+
+            return Result.NoContent();
+        }
+
+        async Task RemovePictures(Track track, CancellationToken cancellationToken)
+        {
+            await RemoveFile(Path.Combine(trackConfiguration.Routes.OriginalPicturesPath, track.OriginalPictureName),
+                cancellationToken);
+
+            if (track.SmallPictureName != trackConfiguration.Routes.PresetSmallPicture)
+                await RemoveFile(Path.Combine(trackConfiguration.Routes.SmallPicturesPath, track.SmallPictureName),
+                    cancellationToken);
+            if (track.MediumPictureName != trackConfiguration.Routes.PresetMediumPicture)
+                await RemoveFile(Path.Combine(trackConfiguration.Routes.MediumPicturesPath, track.MediumPictureName),
+                    cancellationToken);
+            if (track.LargePictureName != trackConfiguration.Routes.PresetLargePicture)
+                await RemoveFile(Path.Combine(trackConfiguration.Routes.LargePicturesPath, track.LargePictureName),
+                    cancellationToken);
+
+        }
+
+        async Task RemoveAudios(Track track, CancellationToken cancellationToken)
+        {
+            await RemoveFile(Path.Combine(trackConfiguration.Routes.OriginalAudiosPath, track.OriginalAudioName),
+                cancellationToken);
+
+            await RemoveFile(Path.Combine(trackConfiguration.Routes.ProcessedAudiosPath, track.AudioFolderName),
+                cancellationToken);
+        }
+
+        async Task RemoveFile(string path, CancellationToken cancellationToken)
+        {
+            await storageHandler.RemoveFileAsync(storageConfiguration.BucketName, path, cancellationToken);
+            logger.LogDebug("File with path={Path} removed from storage.", path);
+        }
+    }
+}