A lot of changes

Application/Application.csproj

@@ -24,4 +24,8 @@
     <ProjectReference Include="..\Domain\Domain.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Folder Include="Tracks\Queries\" />
+  </ItemGroup>
+
 </Project>

Application/Configuration/ConfigurationDependencyInjection.cs

@@ -10,7 +10,8 @@ namespace Musify.Application.Configuration
         {
             serviceDescriptors
                 .AddValidatedConfiguration<ApplicationStorageConfiguration>(configuration, ApplicationStorageConfiguration.SectionName)
-                .AddValidatedConfiguration<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName);
+                .AddValidatedConfiguration<PlayListConfiguration>(configuration, PlayListConfiguration.SectionName)
+                .AddValidatedConfiguration<TrackConfiguration>(configuration, TrackConfiguration.SectionName);
 
             return serviceDescriptors;
         }

Application/Configuration/PlayListConfiguration.cs

@@ -7,14 +7,17 @@ namespace Musify.Application.Configuration
         public const string SectionName = "PlayListConfiguration";
 
         [Required]
-        public Routes Routes { get; set; } = new Routes();
+        public PlayListRoutes Routes { get; set; } = new PlayListRoutes();
 
         [Required]
-        public PicturesSizes PicturesSizes { get; set; } = new PicturesSizes();
+        public PlayListPicturesSizes PicturesSizes { get; set; } = new PlayListPicturesSizes();
     }
 
-    public class Routes
+    public class PlayListRoutes
     {
+        [Required]
+        public string ParentFolders { get; set; } = "PlayLists";
+
         [Required]
         public string OriginalPictures { get; set; } = "OriginalPictures";
 
@@ -37,7 +40,7 @@ namespace Musify.Application.Configuration
         public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
     }
 
-    public class PicturesSizes
+    public class PlayListPicturesSizes
     {
         [Range(1, 1024)]
         public int SmallPictureWidth { get; set; } = 128;

Application/Configuration/TrackConfiguration.cs

@@ -0,0 +1,63 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Musify.Application.Configuration
+{
+    public class TrackConfiguration
+    {
+        public const string SectionName = "TrackConfiguration";
+
+        [Required]
+        public TrackRoutes Routes { get; set; } = new TrackRoutes();
+
+        [Required]
+        public TrackPicturesSizes PicturesSizes { get; set; } = new TrackPicturesSizes();
+    }
+
+    public class TrackRoutes
+    {
+        [Required]
+        public string ParentFolder { get; set; } = "Tracks";
+
+        [Required]
+        public string OriginalPictures { get; set; } = "OriginalTracks";
+
+        [Required]
+        public string SmallPictures { get; set; } = "SmallTracks";
+
+        [Required]
+        public string MediumPictures { get; set; } = "MediumTracks";
+
+        [Required]
+        public string LargePictures { get; set; } = "LargeTracks";
+
+        [Required]
+        public string PresetSmallPicture { get; set; } = "PresetSmallPicture.webp";
+
+        [Required]
+        public string PresetMediumPicture { get; set; } = "PresetMediumPicture.webp";
+
+        [Required]
+        public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
+    }
+
+    public class TrackPicturesSizes
+    {
+        [Range(1, 1024)]
+        public int SmallPictureWidth { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int SmallPictureHeight { get; set; } = 128;
+
+        [Range(1, 1024)]
+        public int MediumPictureWidth { get; private set; } = 256;
+
+        [Range(1, 1024)]
+        public int MediumPictureHeight { get; private set; } = 256;
+
+        [Range(1, 1024)]
+        public int LargePictureWidth { get; private set; } = 512;
+
+        [Range(1, 1024)]
+        public int LargePictureHeight { get; private set; } = 512;
+    }
+}

Application/Contracts/Infrastructure/IDatabase.cs

@@ -11,6 +11,8 @@ namespace Musify.Application.Contracts.Infrastructure
 
         DbSet<Track> Tracks { get; }
 
+        DbSet<UserHasTrack> UserHasTracks { get; }
+
         DbSet<PlayListHasTrack> PlayListHasTracks { get; }
 
         DbSet<Upload> Uploads { get; }

Application/Events/ProcessTrackEvent.cs

@@ -0,0 +1,4 @@
+namespace Musify.Application.Events
+{
+    public record ProcessTrackEvent();
+}

Application/Events/RemoveFileEvent.cs

@@ -1,6 +1,4 @@
-using Musify.Application.Contracts.Application;
-
-namespace Musify.Application.Events
+namespace Musify.Application.Events
 {
     public record RemoveFileEvent(
         string BucketName,

Application/Events/UpdateTrackPictureEvent.cs

@@ -0,0 +1,16 @@
+namespace Musify.Application.Events
+{
+    public record UpdateTrackPictureEvent(
+        Guid TrackId,
+        string BucketName,
+        string OriginalPictureKeyName,
+        string SmallPictureKeyName,
+        int SmallPictureWidth,
+        int SmallPictureHeight,
+        string MediumPictureKeyName,
+        int MediumPictureWidth,
+        int MediumPictureHeight,
+        string LargePictureKeyName,
+        int LargePictureWidth,
+        int LargePictureHeight);
+}

Application/PlayLists/Commands/CreatePlayList/CreatePlayListCommandHandler.cs

@@ -10,9 +10,8 @@ using Musify.Domain.Entities;
 
 namespace Musify.Application.PlayLists.Commands.CreatePlayList
 {
-    public class CreatePlayListCommandHandler(IEventBus eventBus, IDatabase database, IStorageHandler storageHandler,
-        ILogger<CreatePlayListCommandHandler> logger, ApplicationStorageConfiguration storageConfiguration,
-        PlayListConfiguration playListConfiguration, IPictureHandler pictureHandler)
+    public class CreatePlayListCommandHandler(IEventBus eventBus, IDatabase database, IStorageHandler storageHandler, IPictureHandler pictureHandler,
+        ILogger<CreatePlayListCommandHandler> logger, ApplicationStorageConfiguration storageConfiguration, PlayListConfiguration playListConfiguration)
         : IRequestHandler<CreatePlayListCommand, Task<Result<PlayListResponse>> >
     {
         public async Task<Result<PlayListResponse>> Handle(CreatePlayListCommand request, CancellationToken cancellationToken)
@@ -55,8 +54,6 @@ namespace Musify.Application.PlayLists.Commands.CreatePlayList
                         playList.Id, string.Join("; ", uploadResult.Errors));
                     return Result.Error($"Failed to upload picture for PlayList with Id {playList.Id} to storage.");
                 }
-
-                playList.OriginalPictureKeyName = pictureName;
                 logger.LogInformation("Playlist image uploaded successfully for PlayList with Id={PlayListId}.", playList.Id);
 
                 var smallPictureKeyName = Path.Combine(

Application/PlayLists/Commands/DeletePlayList/DeletePlayListCommandHandler.cs

@@ -27,36 +27,28 @@ namespace Musify.Application.PlayLists.Commands.DeletePlayList
                 return Result.Unauthorized();
             }
 
-            if (!string.IsNullOrWhiteSpace(playList.OriginalPictureKeyName))
+            var keysToRemove = new List<string>();
+
+            if (playList.SmallPictureKeyName != playListConfiguration.Routes.PresetSmallPicture)
             {
-                var keysToRemove = new List<string>
-                {
-                    Path.Join(playListConfiguration.Routes.OriginalPictures, playList.OriginalPictureKeyName)
-                };
+                keysToRemove.Add(playList.SmallPictureKeyName);
+            }
+            if (playList.MediumPictureKeyName != playListConfiguration.Routes.PresetMediumPicture)
+            {
+                keysToRemove.Add(playList.MediumPictureKeyName);
+            }
+            if (playList.LargePictureKeyName != playListConfiguration.Routes.PresetLargePicture)
+            {
+                keysToRemove.Add(playList.LargePictureKeyName);
+            }
 
-                if (playList.SmallPictureKeyName != playListConfiguration.Routes.PresetSmallPicture)
-                {
-                    keysToRemove.Add(playList.SmallPictureKeyName);
-                }
+            foreach (var key in keysToRemove)
+            {
+                var publishResult = await TryPublishRemoveFileEventAsync(playList.Id, key, cancellationToken);
 
-                if (playList.MediumPictureKeyName != playListConfiguration.Routes.PresetMediumPicture)
+                if (!publishResult.IsSuccess)
                 {
-                    keysToRemove.Add(playList.MediumPictureKeyName);
-                }
-
-                if (playList.LargePictureKeyName != playListConfiguration.Routes.PresetLargePicture)
-                {
-                    keysToRemove.Add(playList.LargePictureKeyName);
-                }
-
-                foreach (var key in keysToRemove)
-                {
-                    var publishResult = await TryPublishRemoveFileEventAsync(playList.Id, key, cancellationToken);
-
-                    if (!publishResult.IsSuccess)
-                    {
-                        return publishResult;
-                    }
+                    return publishResult;
                 }
             }
 

Application/PlayLists/Commands/UpdatePlayList/UpdatePlayListCommandHandler.cs

@@ -47,68 +47,46 @@ namespace Musify.Application.PlayLists.Commands.UpdatePlayList
                 return Result.Success(PlayListResponse.FromEntity(playList));
             }
 
-            if (!string.IsNullOrWhiteSpace(playList.OriginalPictureKeyName))
+            if (playList.SmallPictureKeyName != playListConfiguration.Routes.PresetSmallPicture)
             {
-                var originalImageStorageKey = Path.Join(playListConfiguration.Routes.OriginalPictures, playList.OriginalPictureKeyName);
-
                 try
                 {
                     await eventBus.PublishAsync(new RemoveFileEvent(
-                       storageConfiguration.BucketName,
-                       originalImageStorageKey), cancellationToken);
+                        storageConfiguration.BucketName,
+                        playList.SmallPictureKeyName), cancellationToken);
                 }
                 catch (Exception exception)
                 {
-                    logger.LogError(exception, "Failed to publish remove file event for original picture of PlayList id={PlayListId}.", playList.Id);
+                    logger.LogError(exception, "Failed to publish remove file event for small picture of PlayList id={PlayListId}.", playList.Id);
                     return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
                 }
-
-                logger.LogInformation("Published event to remove old picture with key name {KeyName} from bucket {BucketName}",
-                    originalImageStorageKey, storageConfiguration.BucketName);
-
-                if (playList.SmallPictureKeyName != playListConfiguration.Routes.PresetSmallPicture)
+            }
+            if (playList.MediumPictureKeyName != playListConfiguration.Routes.PresetMediumPicture)
+            {
+                try
                 {
-                    try
-                    {
-                        await eventBus.PublishAsync(new RemoveFileEvent(
-                            storageConfiguration.BucketName,
-                            playList.SmallPictureKeyName), cancellationToken);
-                    }
-                    catch (Exception exception)
-                    {
-                        logger.LogError(exception, "Failed to publish remove file event for small picture of PlayList id={PlayListId}.", playList.Id);
-                        return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
-                    }
+                    await eventBus.PublishAsync(new RemoveFileEvent(
+                        storageConfiguration.BucketName,
+                        playList.MediumPictureKeyName), cancellationToken);
                 }
-
-                if (playList.MediumPictureKeyName != playListConfiguration.Routes.PresetMediumPicture)
+                catch (Exception exception)
                 {
-                    try
-                    {
-                        await eventBus.PublishAsync(new RemoveFileEvent(
-                            storageConfiguration.BucketName,
-                            playList.MediumPictureKeyName), cancellationToken);
-                    }
-                    catch (Exception exception)
-                    {
-                        logger.LogError(exception, "Failed to publish remove file event for medium picture of PlayList id={PlayListId}.", playList.Id);
-                        return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
-                    }
+                    logger.LogError(exception, "Failed to publish remove file event for medium picture of PlayList id={PlayListId}.", playList.Id);
+                    return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
                 }
-
-                if (playList.LargePictureKeyName != playListConfiguration.Routes.PresetLargePicture)
+            }
+            if (playList.LargePictureKeyName != playListConfiguration.Routes.PresetLargePicture)
+            {
+                try
                 {
-                    try
-                    {
-                        await eventBus.PublishAsync(new RemoveFileEvent(
-                            storageConfiguration.BucketName,
-                            playList.LargePictureKeyName), cancellationToken);
-                    }
-                    catch (Exception exception)
-                    {
-                        logger.LogError(exception, "Failed to publish remove file event for large picture of PlayList id={PlayListId}.", playList.Id);
-                        return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
-                    }
+                    await eventBus.PublishAsync(new RemoveFileEvent(
+                        storageConfiguration.BucketName,
+                        playList.LargePictureKeyName), cancellationToken);
+                }
+                catch (Exception exception)
+                {
+                    logger.LogError(exception, "Failed to publish remove file event for large picture of PlayList id={PlayListId}.", playList.Id);
+                    return Result.Error($"Failed to publish remove file event for PlayList with id {playList.Id}.");
                 }
             }
 
@@ -130,8 +108,6 @@ namespace Musify.Application.PlayLists.Commands.UpdatePlayList
                 return Result.Error($"Failed to upload picture for PlayList with Id {playList.Id} to storage.");
             }
 
-            playList.OriginalPictureKeyName = pictureName;
-
             var smallPictureKeyName = Path.Combine(
                 playListConfiguration.Routes.SmallPictures,
                 $"{playList.Id}.{pictureHandler.FileExtension}");

Application/Tracks/Commands/CreateTrack/CreateTrackCommand.cs

@@ -0,0 +1,14 @@
+using Ardalis.Result;
+using DispatchR.Abstractions.Send;
+using Musify.Application.Contracts.Application;
+using Musify.Application.Tracks.Contracts;
+
+namespace Musify.Application.Tracks.Commands.CreateTrack
+{
+    public record CreateTrackCommand(
+        Guid UserId,
+        string Title,
+        IFileData Picture,
+        IFileData Audio)
+        : IRequest<CreateTrackCommand, Task<Result<TrackResponse> >>;
+}

Application/Tracks/Commands/CreateTrack/CreateTrackCommandHandler.cs

@@ -0,0 +1,87 @@
+using Ardalis.Result;
+using DispatchR.Abstractions.Send;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Configuration;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Application.Events;
+using Musify.Application.Tracks.Contracts;
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Tracks.Commands.CreateTrack
+{
+    public class CreateTrackCommandHandler(IDatabase database, IPictureHandler pictureHandler, IEventBus eventBus, IStorageHandler storageHandler,
+        ILogger<CreateTrackCommandHandler> logger, ApplicationStorageConfiguration storageConfiguration, TrackConfiguration trackConfiguration)
+        : IRequestHandler<CreateTrackCommand, Task<Result<TrackResponse> >>
+    {
+        public async Task<Result<TrackResponse>> Handle(CreateTrackCommand request, CancellationToken cancellationToken)
+        {
+            var userExists = await database.Users.FindAsync(request.UserId, cancellationToken);
+
+            if (userExists is null)
+            {
+                logger.LogWarning("User with id {UserId} not found", request.UserId);
+                return Result.NotFound($"User with id {request.UserId} not found");
+            }
+
+            var originalPictureKeyName = $"{Guid.NewGuid() }.{request.Picture.FileType}";
+            var track = new Track
+            {
+                Title = request.Title,
+                NormalizedTitle = request.Title.Trim().ToUpperInvariant(),
+                SmallPictureKeyName = trackConfiguration.Routes.PresetSmallPicture,
+                MediumPictureKeyName = trackConfiguration.Routes.PresetMediumPicture,
+                LargePictureKeyName = trackConfiguration.Routes.PresetLargePicture,
+            };
+
+            var pictureUploadResult = await storageHandler.UploadFileAsync(
+                request.Picture.FileStream,
+                request.Picture.ContentType,
+                storageConfiguration.BucketName,
+                originalPictureKeyName,
+                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 smallPictureKeyName = Path.Combine(
+                trackConfiguration.Routes.SmallPictures,
+                $"{track.Id}.{pictureHandler.FileExtension}");
+            var mediumPictureKeyName = Path.Combine(
+                trackConfiguration.Routes.MediumPictures,
+                $"{track.Id}.{pictureHandler.FileExtension}");
+            var largePictureKeyName = Path.Combine(
+                trackConfiguration.Routes.LargePictures,
+                $"{track.Id}.{pictureHandler.FileExtension}");
+
+            try
+            {
+                await eventBus.PublishAsync(new UpdatePlayListPictureEvent(
+                    track.Id,
+                    storageConfiguration.BucketName,
+                    originalPictureKeyName,
+                    smallPictureKeyName,
+                    trackConfiguration.PicturesSizes.SmallPictureWidth,
+                    trackConfiguration.PicturesSizes.SmallPictureHeight,
+                    mediumPictureKeyName,
+                    trackConfiguration.PicturesSizes.MediumPictureWidth,
+                    trackConfiguration.PicturesSizes.MediumPictureHeight,
+                    largePictureKeyName,
+                    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);
+                return Result.Error($"Failed to publish resize picture event for Track with id {track.Id}.");
+            }
+
+            await database.Tracks.AddAsync(track, cancellationToken);
+            await database.SaveChangesAsync(cancellationToken);
+
+            return Result.Success();
+        }
+    }
+}

Application/Tracks/Contracts/TrackResponse.cs

@@ -0,0 +1,20 @@
+using Musify.Domain.Entities;
+
+namespace Musify.Application.Tracks.Contracts
+{
+    public record TrackResponse(
+        Guid Id,
+        string Title,
+        DateTime CreatedDate,
+        DateTime UpdatedDate)
+    {
+        public static TrackResponse FromEntity(Track track)
+        {
+            return new TrackResponse(
+                track.Id,
+                track.Title,
+                track.CreatedDate,
+                track.UpdatedDate);
+        }
+    }
+}