Changes and fixes

2026-03-18 10:52:00 +01:00
parent 92bd06751d
commit 076f048efe
13 changed files with 87 additions and 65 deletions
@@ -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);
    }
 }
@@ -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,
@@ -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;
        }
@@ -2,5 +2,6 @@
 {
    public record PictureResize(
        int Width,
-        int Height);
+        int Height,
+        string SaveOnRoute);
 }
@@ -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);
@@ -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));
        }
    }
 }
@@ -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,
@@ -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.");
        }
    }
@@ -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(
@@ -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(
@@ -1,6 +1,5 @@
 using Ardalis.Result;
 using MassTransit;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Application.Pictures.Events;
@@ -15,7 +14,7 @@ namespace Musify.Infrastructure.Messaging.Consumers
        {
            try
            {
-                var upload = await database.Uploads.SingleOrDefaultAsync(u => u.Id == consumeContext.Message.UploadId);
+                var upload = await database.Uploads.FindAsync(consumeContext.Message.UploadId);

                if (upload is null)
                {
@@ -31,53 +30,64 @@ namespace Musify.Infrastructure.Messaging.Consumers

                await UpdateState(database, upload, UploadState.Processing, consumeContext.CancellationToken);

-                var file = await storageHandler.GetFileAsync(
+                var fileResult = await storageHandler.GetFileAsync(
                    upload.BucketName,
                    upload.KeyName,
                    consumeContext.CancellationToken);

-                if (file.IsNotFound())
+                if (fileResult.IsNotFound())
                {
                    logger.LogWarning("File not found in storage: BucketName={BucketName}, KeyName={KeyName}", upload.BucketName, upload.KeyName);
-
                    await UpdateState(database, upload, UploadState.Failed, consumeContext.CancellationToken);
-
                    return;
                }

-                using var fileStream = file.Value;
+                using var fileStream = fileResult.Value;

-                var pictureResult = await pictureHandler.ResizePictureAsync(
-                    fileStream,
-                    consumeContext.Message.Width,
-                    consumeContext.Message.Height,
-                    consumeContext.CancellationToken);
-
-                if (!pictureResult.IsSuccess)
+                foreach (var resize in consumeContext.Message.ImageResizes)
                {
-                    string errors = string.Join("; ", pictureResult.Errors);
-                    logger.LogError("Failed to resize picture: {ErrorMessage}", errors);
-                    
-                    await UpdateState(database, upload, UploadState.Failed, consumeContext.CancellationToken);
+                    var newUpload = new Upload
+                    {
+                        BucketName = upload.BucketName,
+                        KeyName = $"{resize.SaveOnRoute}/{upload.Id}.webp",
+                        ContentType = "image/webp",
+                        State = UploadState.Processing,
+                        EntityId = upload.EntityId,
+                        EntityType = upload.EntityType
+                    };

-                    return;
-                }
+                    await database.Uploads.AddAsync(newUpload, consumeContext.CancellationToken);

-                var saveResult = await storageHandler.UploadFileAsync(
-                    pictureResult.Value,
-                    "image/webp",
-                    upload.BucketName,
-                    $"{consumeContext.Message.SaveRoute}/{upload.Id}.webp",
-                    consumeContext.CancellationToken);
+                    await database.SaveChangesAsync(consumeContext.CancellationToken);

-                if (!saveResult.IsSuccess)
-                {
-                    string errors = string.Join("; ", saveResult.Errors);
-                    logger.LogError("Failed to upload resized picture: {ErrorMessage}", errors);
+                    var pictureResult = await pictureHandler.ResizePictureAsync(
+                        fileStream,
+                        resize.Width,
+                        resize.Height,
+                        consumeContext.CancellationToken);

-                    await UpdateState(database, upload, UploadState.Failed, consumeContext.CancellationToken);
+                    if (!pictureResult.IsSuccess)
+                    {
+                        logger.LogError("Failed to resize picture: {ErrorMessage}", string.Join("; ", pictureResult.Errors));
+                        await UpdateState(database, newUpload, UploadState.Failed, consumeContext.CancellationToken);
+                        continue;
+                    }

-                    return;
+                    var saveResult = await storageHandler.UploadFileAsync(
+                        pictureResult.Value,
+                        "image/webp",
+                        upload.BucketName,
+                        $"{resize.SaveOnRoute}/{upload.Id}.webp",
+                        consumeContext.CancellationToken);
+
+                    if (!saveResult.IsSuccess)
+                    {
+                        logger.LogError("Failed to upload resized picture: {ErrorMessage}", string.Join("; ", saveResult.Errors));
+                        await UpdateState(database, newUpload, UploadState.Failed, consumeContext.CancellationToken);
+                        continue;
+                    }
+
+                    await UpdateState(database, newUpload, UploadState.Completed, consumeContext.CancellationToken);
                }

                await UpdateState(database, upload, UploadState.Completed, consumeContext.CancellationToken);
@@ -88,7 +98,7 @@ namespace Musify.Infrastructure.Messaging.Consumers
                throw;
            }
        }
-
+        
        async Task UpdateState(IDatabase database, Upload upload, UploadState uploadState, CancellationToken cancellationToken)
        {
            upload.State = uploadState;
@@ -0,0 +1,9 @@
+namespace Musify.Domain.Entities
+{
+    public enum EntityType
+    {
+        User,
+        Track,
+        PlayList
+    }
+}
@@ -18,6 +18,12 @@ namespace Musify.Domain.Entities
        [Required]
        public required string ContentType { get; set; }

+        [Required]
+        public required EntityType EntityType { get; set; }
+
+        [Required]
+        public required Guid EntityId { get; set; }
+
        [Required]
        public UploadState State { get; set; } = UploadState.Pending;