Changes and fixes

Application/Contracts/Application/IPictureService.cs

@@ -1,11 +1,12 @@
 using Ardalis.Result;
 using Musify.Application.Pictures.Contracts;
+using Musify.Domain.Entities;
 
 namespace Musify.Application.Contracts.Application
 {
     public interface IPictureService
     {
-        Task<Result<Guid>> ResizePictureAsync(string keyName, string contentType, Stream pictureStream, PictureResize[] pictureResizes,
-            CancellationToken cancellationToken);
+        Task<Result<Guid>> ResizePictureAsync(EntityType entityType, Guid EntityId, string keyName, string contentType, Stream pictureStream,
+                    PictureResize[] pictureResizes, CancellationToken cancellationToken);
     }
 }

Application/Pictures/Commands/ResizePicture/ResizeCommand.cs

@@ -1,10 +1,13 @@
 using Ardalis.Result;
 using DispatchR.Abstractions.Send;
 using Musify.Application.Pictures.Contracts;
+using Musify.Domain.Entities;
 
 namespace Musify.Application.Pictures.Commands.ResizePicture
 {
     public record ResizeCommand(
+        EntityType EntityType,
+        Guid EntityId,
         string KeyName,
         string ContentType,
         Stream PictureStream,

Application/Pictures/Commands/ResizePicture/ResizeCommandHandler.cs

@@ -9,7 +9,8 @@ namespace Musify.Application.Pictures.Commands.ResizePicture
     {
         public async Task<Result<Guid>> Handle(ResizeCommand request, CancellationToken cancellationToken)
         {
-            var result = await pictureService.ResizePictureAsync(request.KeyName, request.ContentType, request.PictureStream, request.PictureResizes, cancellationToken);
+            var result = await pictureService.ResizePictureAsync(request.EntityType, request.EntityId, request.KeyName, request.ContentType,
+                request.PictureStream, request.PictureResizes, cancellationToken);
 
             return result;
         }

Application/Pictures/Contracts/PictureResize.cs

@@ -2,5 +2,6 @@
 {
     public record PictureResize(
         int Width,
-        int Height);
+        int Height,
+        string SaveOnRoute);
 }

Application/Pictures/PictureService.cs

@@ -15,8 +15,8 @@ namespace Musify.Application.Pictures
         ILogger<ResizeCommandHandler> logger, StorageConfiguration storageConfiguration)
         : IPictureService
     {
-        public async Task<Result<Guid>> ResizePictureAsync(string keyName, string contentType, Stream pictureStream, PictureResize[] pictureResizes,
-            CancellationToken cancellationToken)
+        public async Task<Result<Guid>> ResizePictureAsync(EntityType entityType, Guid EntityId, string keyName, string contentType, Stream pictureStream,
+            PictureResize[] pictureResizes, CancellationToken cancellationToken)
         {
             var pictureId = Guid.NewGuid();
 
@@ -26,6 +26,8 @@ namespace Musify.Application.Pictures
                 KeyName = $"{storageConfiguration.Routes.Uploads}/{pictureId}",
                 ContentType = contentType,
                 BucketName = storageConfiguration.BucketName,
+                EntityType = entityType,
+                EntityId = EntityId,
             };
 
             await database.Uploads.AddAsync(upload, cancellationToken);

Application/PlayLists/Commands/CreatePlayList/CreatePlayListCommandHandler.cs

@@ -43,19 +43,24 @@ namespace Musify.Application.PlayLists.Commands.CreatePlayList
             logger.LogInformation("PlayList with Id={PlayListId} created successfully for UserId={UserId}.", playList.Id, request.UserId);
 
             await pictureService.ResizePictureAsync(
+                EntityType.PlayList,
+                playList.Id,
                 playList.Id.ToString(),
                 request.PictureContentType,
                 request.PictureStream,
                 [ 
-                    new PictureResize(playListConfiguration.SmallPictureWidth, playListConfiguration.SmallPictureHeight),
-                    new PictureResize(playListConfiguration.MediumPictureWidth, playListConfiguration.MediumPictureHeight),
-                    new PictureResize(playListConfiguration.LargePictureWidth, playListConfiguration.LargePictureHeight)
+                    new PictureResize(playListConfiguration.SmallPictureWidth,
+                        playListConfiguration.SmallPictureHeight, playListConfiguration.Routes.SmallPictures),
+                    new PictureResize(playListConfiguration.MediumPictureWidth,
+                        playListConfiguration.MediumPictureHeight, playListConfiguration.Routes.MediumPictures),
+                    new PictureResize(playListConfiguration.LargePictureWidth,
+                        playListConfiguration.LargePictureHeight, playListConfiguration.Routes.LargePictures)
                 ],
                 cancellationToken);
 
             logger.LogInformation("Picture for PlayList with Id={PlayListId} ", playList.Id);
 
-            return Result.Created(PlayListResponse.Map(playList));
+            return Result.Created(PlayListResponse.FromEntity(playList));
         }
     }
 }

Application/PlayLists/Contracts/PlayListResponse.cs

@@ -12,7 +12,7 @@ namespace Musify.Application.PlayLists.Contracts
         DateTime CreatedAt,
         DateTime UpdatedAt)
     {
-        public static PlayListResponse Map(PlayList playList)
+        public static PlayListResponse FromEntity(PlayList playList)
         {
             return new PlayListResponse(
                 playList.Id,

Application/PlayLists/Queries/GetPlayListById/GetPlayListByIdQueryHandler.cs

@@ -16,13 +16,7 @@ namespace Musify.Application.PlayLists.Queries.GetPlayListById
                 .SingleOrDefaultAsync(p => p.Id == request.Id, cancellationToken);
 
             return playList is not null
-                ? Result.Success(new PlayListResponse(
-                    playList.Id,
-                    playList.Name,
-                    playList.Description,
-                    playList.ImageName,
-                    playList.CreatedDate,
-                    playList.UpdatedDate))
+                ? Result.Success(PlayListResponse.FromEntity(playList))
                 : Result.NotFound("Playlist not found.");
         }
     }

Application/PlayLists/Queries/GetPlayLists/GetPlayListsQueryHandler.cs

@@ -3,6 +3,7 @@ using DispatchR.Abstractions.Send;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Application.PlayLists.Contracts;
+using Musify.Domain.Entities;
 using X.PagedList.EF;
 
 namespace Musify.Application.PlayLists.Queries.GetPlayLists
@@ -20,13 +21,7 @@ namespace Musify.Application.PlayLists.Queries.GetPlayLists
             var pagedPlayLists = await database.PlayLists
                 .AsNoTracking()
                 .OrderBy(p => p.Id)
-                .Select(p => new PlayListResponse(
-                    p.Id,
-                    p.Name,
-                    p.Description,
-                    p.ImageName,
-                    p.CreatedDate,
-                    p.UpdatedDate))
+                .Select(p => PlayListResponse.FromEntity(p))
                 .ToPagedListAsync(pageNumber, pageSize, totalCount, cancellationToken);
 
             var response = new PaginatedPlayListResponse(

Application/PlayLists/Queries/GetPlayListsByUserId/GetPlayListsByUserIdQueryHandler.cs

@@ -3,6 +3,7 @@ using DispatchR.Abstractions.Send;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Application.PlayLists.Contracts;
+using Musify.Domain.Entities;
 using X.PagedList.EF;
 
 namespace Musify.Application.PlayLists.Queries.GetPlayListsByUserId
@@ -27,13 +28,7 @@ namespace Musify.Application.PlayLists.Queries.GetPlayListsByUserId
 
             var pagedPlayLists = await playListsQuery
                 .OrderBy(p => p.CreatedDate)
-                .Select(p => new PlayListResponse(
-                    p.Id,
-                    p.Name,
-                    p.Description,
-                    p.ImageName,
-                    p.CreatedDate,
-                    p.UpdatedDate))
+                .Select(p => PlayListResponse.FromEntity(p))
                 .ToPagedListAsync(pageNumber, pageSize, totalCount, cancellationToken);
 
             var response = new PaginatedPlayListResponse(