Rename variables

Application/Events/ImageSize.cs

@@ -0,0 +1,7 @@
+namespace Musify.Application.Events
+{
+    public record ImageSize(
+        string SavePath,
+        int Width,
+        int Height);
+}

Application/Events/RemoveFileEvent.cs

@@ -1,6 +1,6 @@
 namespace Musify.Application.Events
 {
     public record RemoveFileEvent(
-        string BucketName,
-        string KeyName);
+        string Bucket,
+        string Key);
 }

Application/Events/UpdatePlayListPictureEvent.cs

@@ -2,15 +2,9 @@
 {
     public record UpdatePlayListPictureEvent(
         Guid PlayListId,
-        string SourceBucketName,
-        string SourceKeyName,
-        string SmallPictureRoute,
-        int SmallPictureWidth,
-        int SmallPictureHeight,
-        string MediumPictureRoute,
-        int MediumPictureWidth,
-        int MediumPictureHeight,
-        string LargePictureRoute,
-        int LargePictureWidth,
-        int LargePictureHeight);
+        string Bucket,
+        string SourceKey,
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
 }

Application/Events/UpdateTrackAudioEvent.cs

@@ -2,8 +2,8 @@
 {
     public record UpdateTrackAudioEvent(
         Guid TrackId,
-        string SourceBucketName,
-        string SourceKeyName,
-        string DestinationBucketName,
-        string DestinationFolderKeyName);
+        string SourceBucket,
+        string SourceKey,
+        string DestinationBucket,
+        string DestinationFolderKey);
 }

Application/Events/UpdateTrackPictureEvent.cs

@@ -2,15 +2,9 @@
 {
     public record UpdateTrackPictureEvent(
         Guid TrackId,
-        string SourceBucketName,
-        string SourceKeyName,
-        string SmallPictureRoute,
-        int SmallPictureWidth,
-        int SmallPictureHeight,
-        string MediumPictureRoute,
-        int MediumPictureWidth,
-        int MediumPictureHeight,
-        string LargePictureRoute,
-        int LargePictureWidth,
-        int LargePictureHeight);
+        string Bucket,
+        string SourceKey,
+        ImageSize Small,
+        ImageSize Medium,
+        ImageSize Large);
 }

Application/PlayLists/Handlers/CreatePlayListCommandHandler.cs

@@ -95,21 +95,25 @@ namespace Musify.Application.PlayLists.Handlers
             return uploadFileResult;
         }
 
-        async Task PublishUpdateEvent(string originalPictureKeyName, PlayList playList, CancellationToken cancellationToken)
+        async Task PublishUpdateEvent(string originalPictureKey, PlayList playList, CancellationToken cancellationToken)
         {
             await eventBus.PublishAsync(new UpdatePlayListPictureEvent(
                 playList.Id,
                 storageConfiguration.BucketName,
-                originalPictureKeyName,
-                playListConfiguration.Routes.SmallPicturesPath,
-                playListConfiguration.PicturesSizes.SmallPictureWidth,
-                playListConfiguration.PicturesSizes.SmallPictureHeight,
-                playListConfiguration.Routes.MediumPicturesPath,
-                playListConfiguration.PicturesSizes.MediumPictureWidth,
-                playListConfiguration.PicturesSizes.MediumPictureHeight,
-                playListConfiguration.Routes.LargePicturesPath,
-                playListConfiguration.PicturesSizes.LargePictureWidth,
-                playListConfiguration.PicturesSizes.LargePictureHeight), cancellationToken);
+                originalPictureKey,
+                new ImageSize(
+                    playListConfiguration.Routes.SmallPicturesPath,
+                    playListConfiguration.PicturesSizes.SmallPictureWidth,
+                    playListConfiguration.PicturesSizes.SmallPictureHeight),
+                new ImageSize(
+                    playListConfiguration.Routes.MediumPicturesPath,
+                    playListConfiguration.PicturesSizes.MediumPictureWidth,
+                    playListConfiguration.PicturesSizes.MediumPictureHeight),
+                new ImageSize(
+                    playListConfiguration.Routes.LargePicturesPath,
+                    playListConfiguration.PicturesSizes.LargePictureWidth,
+                    playListConfiguration.PicturesSizes.LargePictureHeight)),
+                cancellationToken);
         }
     }
 }

Application/PlayLists/Handlers/UpdatePlayListCommandHandler.cs

@@ -92,11 +92,11 @@ namespace Musify.Application.PlayLists.Handlers
             database.PlayLists.Update(playList);
             await database.SaveChangesAsync(cancellationToken);
 
-            logger.LogInformation("Updated PlayList with id={PlayListId} and picture key {PictureKeyName}.", playList.Id, newImageStorageKey);
+            logger.LogInformation("Updated PlayList with id={PlayListId} and picture key {PictureKey}.", playList.Id, newImageStorageKey);
             return Result.Success(PlayListResponse.FromEntity(playList));
         }
 
-        async Task<Result> PublishRemoveFileEvent(string keyName, CancellationToken cancellationToken)
+        async Task<Result> PublishRemoveFileEvent(string key, CancellationToken cancellationToken)
         {
             try
             {
@@ -104,14 +104,14 @@ namespace Musify.Application.PlayLists.Handlers
                     storageConfiguration.BucketName,
                     Path.Combine(
                         playListConfiguration.Routes.ParentFolders,
-                        keyName)), cancellationToken);
+                        key)), cancellationToken);
 
                 return Result.NoContent();
             }
             catch (Exception exception)
             {
-                logger.LogError(exception, "Failed to publish remove file event for key {KeyName}.", keyName);
-                return Result.Error($"Failed to publish remove file event for key {keyName}.");
+                logger.LogError(exception, "Failed to publish remove file event for key {Key}.", key);
+                return Result.Error($"Failed to publish remove file event for key {key}.");
             }
         }
 
@@ -127,21 +127,25 @@ namespace Musify.Application.PlayLists.Handlers
             return uploadFileResult;
         }
 
-        async Task PublishUpdateEvent(string originalPictureKeyName, PlayList playList, CancellationToken cancellationToken)
+        async Task PublishUpdateEvent(string originalPictureKey, PlayList playList, CancellationToken cancellationToken)
         {
             await eventBus.PublishAsync(new UpdatePlayListPictureEvent(
                 playList.Id,
                 storageConfiguration.BucketName,
-                originalPictureKeyName,
-                playListConfiguration.Routes.SmallPicturesPath,
-                playListConfiguration.PicturesSizes.SmallPictureWidth,
-                playListConfiguration.PicturesSizes.SmallPictureHeight,
-                playListConfiguration.Routes.MediumPicturesPath,
-                playListConfiguration.PicturesSizes.MediumPictureWidth,
-                playListConfiguration.PicturesSizes.MediumPictureHeight,
-                playListConfiguration.Routes.LargePicturesPath,
-                playListConfiguration.PicturesSizes.LargePictureWidth,
-                playListConfiguration.PicturesSizes.LargePictureHeight), cancellationToken);
+                originalPictureKey,
+                new ImageSize(
+                    playListConfiguration.Routes.SmallPicturesPath,
+                    playListConfiguration.PicturesSizes.SmallPictureWidth,
+                    playListConfiguration.PicturesSizes.SmallPictureHeight),
+                new ImageSize(
+                    playListConfiguration.Routes.MediumPicturesPath,
+                    playListConfiguration.PicturesSizes.MediumPictureWidth,
+                    playListConfiguration.PicturesSizes.MediumPictureHeight),
+                new ImageSize(
+                    playListConfiguration.Routes.LargePicturesPath,
+                    playListConfiguration.PicturesSizes.LargePictureWidth,
+                    playListConfiguration.PicturesSizes.LargePictureHeight)),
+                cancellationToken);
         }
     }
 }

Application/Tracks/Handler/CreateTrackCommandHandler.cs

@@ -38,9 +38,9 @@ namespace Musify.Application.Tracks.Handler
                 LargePictureKeyName = trackConfiguration.Routes.PresetLargePicture,
             };
 
-            var originalPictureKeyName = Path.Combine(trackConfiguration.Routes.OriginalPicturesPath,
+            var originalPictureKey = Path.Combine(trackConfiguration.Routes.OriginalPicturesPath,
                 originalPictureFileName);
-            var pictureUploadResult = await UploadFile(request.Picture, originalPictureKeyName, cancellationToken);
+            var pictureUploadResult = await UploadFile(request.Picture, originalPictureKey, cancellationToken);
             if (!pictureUploadResult.IsSuccess)
             {
                 logger.LogError("Failed to upload picture for track {TrackTitle}", request.Title);
@@ -48,9 +48,9 @@ namespace Musify.Application.Tracks.Handler
             }
 
 
-            var audioKeyName = Path.Combine(trackConfiguration.Routes.OriginalAudiosPath,
+            var audioKey = Path.Combine(trackConfiguration.Routes.OriginalAudiosPath,
                 Guid.NewGuid() + request.Audio.FileType);
-            var audioUploadResult = await UploadFile(request.Audio, audioKeyName, cancellationToken);
+            var audioUploadResult = await UploadFile(request.Audio, audioKey, cancellationToken);
             if (!audioUploadResult.IsSuccess)
             {
                 logger.LogError("Failed to upload audio for track {TrackTitle}", request.Title);
@@ -59,7 +59,7 @@ namespace Musify.Application.Tracks.Handler
 
             try
             {
-                await PublishUpdateEvent(originalPictureKeyName, track, cancellationToken);
+                await PublishUpdateEvent(originalPictureKey, track, cancellationToken);
             }
             catch (Exception exception)
             {
@@ -83,36 +83,39 @@ namespace Musify.Application.Tracks.Handler
             return Result.Success();
         }
 
-        async Task<Result<string>> UploadFile(IFileData fileData, string keyName, CancellationToken cancellationToken)
+        async Task<Result<string>> UploadFile(IFileData fileData, string key, CancellationToken cancellationToken)
         {
             var uploadFile = await storageHandler.UploadFileAsync(
                 fileData.FileStream,
                 fileData.ContentType,
                 storageConfiguration.BucketName,
-                keyName,
+                key,
                 cancellationToken);
 
             return uploadFile;
         }
 
-        async Task PublishUpdateEvent(string originalPictureKeyName, Track track, CancellationToken cancellationToken)
+        async Task PublishUpdateEvent(string originalPictureKey, Track track, CancellationToken cancellationToken)
         {
             await eventBus.PublishAsync(new UpdateTrackPictureEvent(
                 track.Id,
                 storageConfiguration.BucketName,
-                originalPictureKeyName,
-                trackConfiguration.Routes.SmallPicturesPath,
-                trackConfiguration.PicturesSizes.SmallPictureWidth,
-                trackConfiguration.PicturesSizes.SmallPictureHeight,
-                trackConfiguration.Routes.MediumPicturesPath,
-                trackConfiguration.PicturesSizes.MediumPictureWidth,
-                trackConfiguration.PicturesSizes.MediumPictureHeight,
-                trackConfiguration.Routes.LargePicturesPath,
-                trackConfiguration.PicturesSizes.LargePictureWidth,
-                trackConfiguration.PicturesSizes.LargePictureHeight), cancellationToken);
+                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);
         }
 
-        async Task PublishTranscodeEvent(Guid trackId, string audioKeyName, CancellationToken cancellationToken)
+        async Task PublishTranscodeEvent(Guid trackId, string audioKey, CancellationToken cancellationToken)
         {
             var destinationFolderAudio = Path.Combine(trackConfiguration.Routes.ProcessedAudiosPath,
                 Guid.NewGuid().ToString());
@@ -120,7 +123,7 @@ namespace Musify.Application.Tracks.Handler
             await eventBus.PublishAsync(new UpdateTrackAudioEvent(
                 trackId,
                 storageConfiguration.BucketName,
-                audioKeyName,
+                audioKey,
                 storageConfiguration.BucketName,
                 destinationFolderAudio), cancellationToken);
         }