Update routes and changes on queries

Application/Configuration/TrackConfiguration.cs

@@ -65,6 +65,18 @@ namespace Musify.Application.Configuration
         public string OriginalAudiosPath => Path.Combine(ParentFolder, OriginalAudiosFolder);
 
         public string ProcessedAudiosPath => Path.Combine(ParentFolder, ProcessedAudioFolder);
+
+        public string BuildOriginalPicturePath(string pictureName) => Path.Combine(OriginalPicturesPath, pictureName);
+
+        public string BuildSmallPicturePath(string pictureName) => Path.Combine(SmallPicturesPath, pictureName);
+
+        public string BuildMediumPicturePath(string pictureName) => Path.Combine(MediumPicturesPath, pictureName);
+
+        public string BuildLargePicturePath(string pictureName) => Path.Combine(LargePicturesPath, pictureName);
+
+        public string BuildOriginalAudioPath(string audioName) => Path.Combine(OriginalAudiosPath, audioName);
+
+        public string BuildProcessedAudioPath(string audioName) => Path.Combine(ProcessedAudiosPath, audioName);
     }
 
     public class TrackPicturesSizes

Application/PlayLists/Handlers/GetPlayListByIdQueryHandler.cs

@@ -14,11 +14,10 @@ namespace Musify.Application.PlayLists.Handlers
         {
             var playList = await database.PlayLists
                 .AsNoTracking()
+                .Select(p => PlayListResponse.FromEntity(p))
                 .SingleOrDefaultAsync(p => p.Id == request.Id, cancellationToken);
 
-            return playList is not null
+            return playList ?? Result<PlayListResponse>.NotFound();
-                ? Result.Success(PlayListResponse.FromEntity(playList))
-                : Result.NotFound("Playlist not found");
         }
     }
 }

Application/Tracks/Handler/CreateTrackCommandHandler.cs

@@ -1,5 +1,6 @@
 using Ardalis.Result;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts.Infrastructure;
@@ -16,8 +17,9 @@ namespace Musify.Application.Tracks.Handler
     {
         public async ValueTask<Result<TrackResponse>> Handle(CreateTrackCommand request, CancellationToken cancellationToken)
         {
-            var userExists = await database.Users.FindAsync(request.UserId, cancellationToken);
+            var userExists = await database.Users.AsNoTracking()
-            if (userExists is null)
+                .AnyAsync(u => u.Id == request.UserId, cancellationToken);
+            if (!userExists)
             {
                 logger.LogWarning("User {UserId} not found", request.UserId);
                 return Result.NotFound($"User {request.UserId} not found");
@@ -29,8 +31,8 @@ namespace Musify.Application.Tracks.Handler
                 trackConfiguration.Routes.PresetMediumPicture,
                 trackConfiguration.Routes.PresetLargePicture);
 
-            var fullPictureKey = Path.Combine(trackConfiguration.Routes.OriginalPicturesPath, trackEntity.OriginalPictureName);
+            var fullPictureKey = trackConfiguration.Routes.BuildOriginalPicturePath(trackEntity.OriginalPictureName);
-            var fullAudioKey = Path.Combine(trackConfiguration.Routes.OriginalAudiosPath, trackEntity.OriginalAudioName);
+            var fullAudioKey = trackConfiguration.Routes.BuildOriginalAudioPath(trackEntity.OriginalAudioName);
 
             await UploadFilesAsync(request, fullPictureKey, fullAudioKey, cancellationToken);
 
@@ -58,8 +60,9 @@ namespace Musify.Application.Tracks.Handler
                     pictureKey,
                     cancellationToken);
             }
-            catch
+            catch (Exception exception)
             {
+                logger.LogError(exception, "Failed to upload picture for track {Title}", request.Title);
                 return Result.Error($"Failed to upload picture for {request.Title}");
             }
 
@@ -72,8 +75,9 @@ namespace Musify.Application.Tracks.Handler
                     audioKey,
                     cancellationToken);
             }
-            catch
+            catch (Exception exception)
             {
+                logger.LogError(exception, "Failed to upload audio for track {Title}", request.Title);
                 await RollbackFilesAsync(pictureKey, audioKey, cancellationToken);
                 return Result.Error($"Failed to upload audio for {request.Title}");
             }
@@ -94,7 +98,7 @@ namespace Musify.Application.Tracks.Handler
                 await eventBus.PublishAsync(new UpdateTrackPictureEvent(
                     track.Id,
                     storageConfiguration.Bucket,
-                    Path.Combine(trackConfiguration.Routes.OriginalPicturesPath, track.OriginalPictureName),
+                    trackConfiguration.Routes.BuildOriginalPicturePath(track.OriginalPictureName),
                     new ImageSize(
                         trackConfiguration.Routes.SmallPicturesPath,
                         trackConfiguration.PicturesSizes.SmallPictureWidth,
@@ -116,15 +120,14 @@ namespace Musify.Application.Tracks.Handler
 
         async Task PublishTranscodeEvent(Track track, CancellationToken cancellationToken)
         {
-            var destinationFolderAudio = Path.Combine(trackConfiguration.Routes.ProcessedAudiosPath,
+            var destinationFolderAudio = trackConfiguration.Routes.BuildProcessedAudioPath(Guid.NewGuid().ToString());
-                Guid.NewGuid().ToString());
 
             try
             {
                 await eventBus.PublishAsync(new UpdateTrackAudioEvent(
                     track.Id,
                     storageConfiguration.Bucket,
-                    Path.Combine(trackConfiguration.Routes.OriginalAudiosPath, track.OriginalAudioName),
+                    trackConfiguration.Routes.BuildOriginalAudioPath(track.OriginalAudioName),
                     storageConfiguration.Bucket,
                     destinationFolderAudio), cancellationToken);
             }

Application/Tracks/Handler/DeleteTrackCommandHandler.cs

@@ -1,5 +1,6 @@
 using Ardalis.Result;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts.Infrastructure;
@@ -14,7 +15,7 @@ namespace Musify.Application.Tracks.Handler
     {
         public async ValueTask<Result> Handle(DeleteTrackCommand request, CancellationToken cancellationToken)
         {
-            var track = await database.Tracks.FindAsync(request.TrackId, cancellationToken);
+            var track = await database.Tracks.SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
             if (track is null)
             {
                 logger.LogInformation("Track {TrackId} not found", request.TrackId);
@@ -35,33 +36,40 @@ namespace Musify.Application.Tracks.Handler
 
         async Task RemovePictures(Track track, CancellationToken cancellationToken)
         {
-            await RemoveFile(Path.Combine(trackConfiguration.Routes.OriginalPicturesPath, track.OriginalPictureName),
+            await RemoveFile(trackConfiguration.Routes.BuildOriginalPicturePath(track.OriginalPictureName),
                 cancellationToken);
 
             if (track.SmallPictureName != trackConfiguration.Routes.PresetSmallPicture)
-                await RemoveFile(Path.Combine(trackConfiguration.Routes.SmallPicturesPath, track.SmallPictureName),
+                await RemoveFile(trackConfiguration.Routes.BuildSmallPicturePath(track.SmallPictureName),
                     cancellationToken);
             if (track.MediumPictureName != trackConfiguration.Routes.PresetMediumPicture)
-                await RemoveFile(Path.Combine(trackConfiguration.Routes.MediumPicturesPath, track.MediumPictureName),
+                await RemoveFile(trackConfiguration.Routes.BuildMediumPicturePath(track.MediumPictureName),
                     cancellationToken);
             if (track.LargePictureName != trackConfiguration.Routes.PresetLargePicture)
-                await RemoveFile(Path.Combine(trackConfiguration.Routes.LargePicturesPath, track.LargePictureName),
+                await RemoveFile(trackConfiguration.Routes.BuildLargePicturePath(track.LargePictureName),
                     cancellationToken);
 
         }
 
         async Task RemoveAudios(Track track, CancellationToken cancellationToken)
         {
-            await RemoveFile(Path.Combine(trackConfiguration.Routes.OriginalAudiosPath, track.OriginalAudioName),
+            await RemoveFile(trackConfiguration.Routes.BuildOriginalAudioPath(track.OriginalAudioName),
                 cancellationToken);
-            await RemoveFile(Path.Combine(trackConfiguration.Routes.ProcessedAudiosPath, track.AudioFolderName),
+            await RemoveFile(trackConfiguration.Routes.BuildProcessedAudioPath(track.AudioFolderName),
                 cancellationToken);
         }
 
         async Task RemoveFile(string path, CancellationToken cancellationToken)
         {
-            await storageHandler.RemoveFileAsync(storageConfiguration.Bucket, path, cancellationToken);
+            try
-            logger.LogDebug("Removed file {Path} from storage", path);
+            {
+                await storageHandler.RemoveFileAsync(storageConfiguration.Bucket, path, cancellationToken);
+                logger.LogDebug("Removed file {Path} from storage", path);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to remove file {Path} from storage", path);
+            }
         }
     }
 }

Application/Tracks/Handler/GetTrackByIdQueryHandler.cs

@@ -1,5 +1,6 @@
 using Ardalis.Result;
 using Mediator;
+using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Application.Tracks.Queries;
 using Musify.Application.Tracks.Responses;
@@ -11,11 +12,11 @@ namespace Musify.Application.Tracks.Handler
     {
         public async ValueTask<Result<TrackResponse>> Handle(GetTrackByIdQuery request, CancellationToken cancellationToken)
         {
-            var track = await database.Tracks.FindAsync(request.TrackId);
+            var track = await database.Tracks.AsNoTracking()
+                .Select(t => TrackResponse.FromEntity(t))
+                .SingleOrDefaultAsync(t => t.Id == request.TrackId, cancellationToken);
 
-            return track is null
+            return track ?? Result<TrackResponse>.NotFound();
-                ? Result.NotFound()
-                : Result.Success(TrackResponse.FromEntity(track));
         }
     }
 }