Changes but failing

2026-03-23 03:13:08 +01:00
parent 27ec670e3a
commit 4ec4b50c40
16 changed files with 362 additions and 160 deletions
@@ -0,0 +1,8 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record ResizePictureLocalArguments(
+        string SourceFilePath,
+        string DestinationFilePath,
+        int Width,
+        int Height);
+}
@@ -1,41 +1,76 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
+using Musify.Domain.Entities;
+using Musify.Infrastructure.Configuration;
 using Musify.Infrastructure.Messaging.Activities.Arguments;
-using Musify.Infrastructure.Messaging.Activities.Logs;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class DownloadFileFromBucketActivity(IStorageHandler storageHandler, ILogger<DownloadFileFromBucketActivity> logger)
+    public class DownloadFileFromBucketActivity(
+        IStorageHandler storageHandler,
+        ILogger<DownloadFileFromBucketActivity> logger,
+        IProcessTrackingStore processTrackingStore,
+        AudioTranscoderConfiguration audioTranscoderConfiguration)
        : IExecuteActivity<DownloadFileFromBucketArguments>
    {
        public const string ExecuteEndpointName = "Download-File-From-Bucket";

        public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
        {
-            var getFile = await storageHandler.GetFileAsync(
-                executeContext.Arguments.BucketName,
-                executeContext.Arguments.KeyName,
+            var processId = await processTrackingStore.GetOrCreateProcessAsync(
+                "RoutingSlip",
+                executeContext.CorrelationId ?? executeContext.TrackingNumber,
+                executeContext.ConversationId,
+                executeContext.MessageId,
                executeContext.CancellationToken);

-            if (!getFile.IsSuccess)
+            var stepId = await processTrackingStore.StartStepAsync(
+                processId,
+                nameof(DownloadFileFromBucketActivity),
+                ProcessStepComponentType.Activity,
+                0,
+                executeContext.CancellationToken);
+
+            try
            {
-                var error = string.Join("; ", getFile.Errors);
-                logger.LogError("Failed to download file from bucket. Bucket: {BucketName}, Key: {KeyName}",
+                var getFile = await storageHandler.GetFileAsync(
                    executeContext.Arguments.BucketName,
-                    executeContext.Arguments.KeyName);
-                throw new Exception(error);
+                    executeContext.Arguments.KeyName,
+                    executeContext.CancellationToken);
+
+                if (!getFile.IsSuccess)
+                {
+                    var errorMessage = string.Join("; ", getFile.Errors);
+                    logger.LogError("Failed to download file from bucket. Bucket: {BucketName}, Key: {KeyName}, Errors: {Errors}",
+                        executeContext.Arguments.BucketName,
+                        executeContext.Arguments.KeyName,
+                        errorMessage);
+                    throw new Exception(errorMessage);
+                }
+
+                using var fileStream = getFile.Value;
+                if (fileStream.CanSeek)
+                    fileStream.Position = 0;
+
+                var destinationPath = Path.Combine(
+                    audioTranscoderConfiguration.Routes.WorkingDirectory,
+                    Path.GetFileName(executeContext.Arguments.KeyName));
+
+                Directory.CreateDirectory(Path.GetDirectoryName(destinationPath)!);
+
+                using var destinationStream = File.Create(destinationPath);
+                await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
+
+                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Error downloading file from bucket");
+                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
+                throw;
            }
-
-            using var fileStream = getFile.Value;
-            if (fileStream.CanSeek)
-                fileStream.Position = 0;
-
-            var fileName = Path.GetFileName(executeContext.Arguments.KeyName);
-            using var destinationStream = File.Create($"D:\\tempsFilesDev\\{fileName}");
-            await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
-
-            return executeContext.Completed();
        }
    }
 }
@@ -39,9 +39,8 @@ namespace Musify.Infrastructure.Messaging.Activities

                if (!removeFile.IsSuccess)
                {
-                    string errorMessage = string.Join(";", removeFile.Errors);
-                    logger.LogWarning(
-                        "Failed to remove file {KeyName} from bucket {BucketName}: {ErrorMessage}",
+                    var errorMessage = string.Join("; ", removeFile.Errors);
+                    logger.LogWarning("Failed to remove file {KeyName} from bucket {BucketName}. Errors: {Errors}",
                        executeContext.Arguments.KeyName,
                        executeContext.Arguments.BucketName,
                        errorMessage);
@@ -52,6 +51,9 @@ namespace Musify.Infrastructure.Messaging.Activities
            }
            catch (Exception exception)
            {
+                logger.LogError(exception, "Error removing file {KeyName} from bucket {BucketName}",
+                    executeContext.Arguments.KeyName,
+                    executeContext.Arguments.BucketName);
                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
                throw;
            }
@@ -1,4 +1,5 @@
 using MassTransit;
+using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Domain.Entities;
 using Musify.Infrastructure.Messaging.Activities.Arguments;
@@ -6,14 +7,14 @@ using Musify.Infrastructure.Messaging.Activities.Arguments;
 namespace Musify.Infrastructure.Messaging.Activities
 {
    public class ResizePictureActivity(
-        IStorageHandler storageHandler,
        IPictureHandler pictureHandler,
+        ILogger<ResizePictureActivity> logger,
        IProcessTrackingStore processTrackingStore)
-        : IExecuteActivity<ResizePictureArgument>
+        : IExecuteActivity<ResizePictureLocalArguments>
    {
        public const string ExecuteEndpointName = "Resize-Picture";

-        public async Task<ExecutionResult> Execute(ExecuteContext<ResizePictureArgument> executeContext)
+        public async Task<ExecutionResult> Execute(ExecuteContext<ResizePictureLocalArguments> executeContext)
        {
            var processId = await processTrackingStore.GetOrCreateProcessAsync(
                "RoutingSlip",
@@ -31,47 +32,54 @@ namespace Musify.Infrastructure.Messaging.Activities

            try
            {
-                var file = await storageHandler.GetFileAsync(
-                    executeContext.Arguments.OriginalBucketName,
-                    executeContext.Arguments.OriginalKeyName,
-                    executeContext.CancellationToken);
-
-                if (!file.IsSuccess)
+                if (!File.Exists(executeContext.Arguments.SourceFilePath))
                {
-                    string errorMessages = string.Join(", ", file.Errors);
-                    throw new Exception(errorMessages);
+                    logger.LogError("Source file not found at {SourceFilePath}",
+                        executeContext.Arguments.SourceFilePath);
+                    throw new FileNotFoundException($"Source file not found: {executeContext.Arguments.SourceFilePath}");
                }

+                await using var fileStream = File.OpenRead(executeContext.Arguments.SourceFilePath);
+
                var resizedPicture = await pictureHandler.ResizePictureAsync(
-                    file.Value,
+                    fileStream,
                    executeContext.Arguments.Width,
                    executeContext.Arguments.Height,
                    executeContext.CancellationToken);

                if (!resizedPicture.IsSuccess)
                {
-                    string errorMessage = string.Join(", ", resizedPicture.Errors);
+                    var errorMessage = string.Join("; ", resizedPicture.Errors);
+                    logger.LogError("Failed to resize picture {SourceFilePath} to {Width}x{Height}. Errors: {Errors}",
+                        executeContext.Arguments.SourceFilePath,
+                        executeContext.Arguments.Width,
+                        executeContext.Arguments.Height,
+                        errorMessage);
                    throw new Exception(errorMessage);
                }

-                var uploadFile = await storageHandler.UploadFileAsync(
-                    resizedPicture.Value,
-                    pictureHandler.ContentType,
-                    executeContext.Arguments.DestinationBucketName,
-                    executeContext.Arguments.DestinationKeyName,
-                    executeContext.CancellationToken);
-
-                if (!uploadFile.IsSuccess)
+                var destinationDirectory = Path.GetDirectoryName(executeContext.Arguments.DestinationFilePath);
+                if (!string.IsNullOrEmpty(destinationDirectory))
                {
-                    var errorMessage = string.Join(", ", uploadFile.Errors);
-                    throw new Exception(errorMessage);
+                    Directory.CreateDirectory(destinationDirectory);
                }

+                await using var destinationStream = File.Create(executeContext.Arguments.DestinationFilePath);
+                await resizedPicture.Value.CopyToAsync(destinationStream, executeContext.CancellationToken);
+
+                logger.LogInformation("Picture resized successfully from {SourceFilePath} to {DestinationFilePath} ( {Width}x{Height} )",
+                    executeContext.Arguments.SourceFilePath,
+                    executeContext.Arguments.DestinationFilePath,
+                    executeContext.Arguments.Width,
+                    executeContext.Arguments.Height);
+
                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
                return executeContext.Completed();
            }
            catch (Exception exception)
            {
+                logger.LogError(exception, "Error resizing picture {SourceFilePath}",
+                    executeContext.Arguments.SourceFilePath);
                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
                throw;
            }
@@ -1,13 +1,16 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
+using Musify.Domain.Entities;
 using Musify.Infrastructure.Configuration;
 using Musify.Infrastructure.Messaging.Activities.Arguments;
-using Musify.Infrastructure.Messaging.Activities.Logs;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class TranscodeDashAudioActivity(IAudioTranscoder audioTranscoder, ILogger<TranscodeDashAudioActivity> logger,
+    public class TranscodeDashAudioActivity(
+        IAudioTranscoder audioTranscoder,
+        ILogger<TranscodeDashAudioActivity> logger,
+        IProcessTrackingStore processTrackingStore,
        AudioTranscoderConfiguration audioTranscoderConfiguration)
        : IExecuteActivity<TranscodeDashAudioArguments>
    {
@@ -15,12 +18,26 @@ namespace Musify.Infrastructure.Messaging.Activities

        public async Task<ExecutionResult> Execute(ExecuteContext<TranscodeDashAudioArguments> executeContext)
        {
-            var workingDirectory = Path.Combine(
-                audioTranscoderConfiguration.Routes.WorkingDirectory,
-                executeContext.Arguments.DestinationFolderName);
+            var processId = await processTrackingStore.GetOrCreateProcessAsync(
+                "RoutingSlip",
+                executeContext.CorrelationId ?? executeContext.TrackingNumber,
+                executeContext.ConversationId,
+                executeContext.MessageId,
+                executeContext.CancellationToken);
+
+            var stepId = await processTrackingStore.StartStepAsync(
+                processId,
+                nameof(TranscodeDashAudioActivity),
+                ProcessStepComponentType.Activity,
+                0,
+                executeContext.CancellationToken);

            try
            {
+                var workingDirectory = Path.Combine(
+                    audioTranscoderConfiguration.Routes.WorkingDirectory,
+                    executeContext.Arguments.DestinationFolderName);
+
                await using var fileStream = File.OpenRead(executeContext.Arguments.SourceFilePath);

                var result = await audioTranscoder.TranscodeToDashAsync(
@@ -31,17 +48,20 @@ namespace Musify.Infrastructure.Messaging.Activities

                if (!result.IsSuccess)
                {
-                    var errors = string.Join(";  ", result.Errors); 
-                    logger.LogError("transcoding failed for file {SourceFilePath}. Error: {ErrorMessage}",
-                        executeContext.Arguments.SourceFilePath, errors);
-                    throw new Exception(errors);
+                    var errorMessage = string.Join("; ", result.Errors);
+                    logger.LogError("Transcoding failed for file {SourceFilePath}. Errors: {ErrorMessage}",
+                        executeContext.Arguments.SourceFilePath, errorMessage);
+                    throw new Exception(errorMessage);
                }

+                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
                return executeContext.Completed();
            }
            catch (Exception exception)
            {
-                logger.LogError(exception, "Error during transcoding activity.");
+                logger.LogError(exception, "Error during transcoding activity for file {SourceFilePath}",
+                    executeContext.Arguments.SourceFilePath);
+                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
                throw;
            }
        }
@@ -1,31 +1,65 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
+using Musify.Domain.Entities;
 using Musify.Infrastructure.Messaging.Activities.Arguments;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class TransferFilesToBucket(IStorageHandler storageHandler, ILogger<TransferFilesToBucket> logger)
+    public class TransferFilesToBucket(
+        IStorageHandler storageHandler,
+        ILogger<TransferFilesToBucket> logger,
+        IProcessTrackingStore processTrackingStore)
        : IExecuteActivity<TransferFilesToBucketArguments>
    {
        public const string ExecuteEndpointName = "Transfer-Files-To-Bucket";

        public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
        {
-            var transferFilesResult = await storageHandler.TransferFilesAsync(
-                executeContext.Arguments.FolderPath,
-                executeContext.Arguments.DestinationBucketName,
-                executeContext.Arguments.DestinationKeyName,
+            var processId = await processTrackingStore.GetOrCreateProcessAsync(
+                "RoutingSlip",
+                executeContext.CorrelationId ?? executeContext.TrackingNumber,
+                executeContext.ConversationId,
+                executeContext.MessageId,
                executeContext.CancellationToken);

-            if (!transferFilesResult.IsSuccess)
-            {
-                var errors = string.Join("; ", transferFilesResult.Errors);
-                logger.LogError($"An error occurred while transferring files to bucket: {errors}");
-                throw new Exception(errors);
-            }
+            var stepId = await processTrackingStore.StartStepAsync(
+                processId,
+                nameof(TransferFilesToBucket),
+                ProcessStepComponentType.Activity,
+                0,
+                executeContext.CancellationToken);

-            return executeContext.Completed();
+            try
+            {
+                var transferFilesResult = await storageHandler.TransferFilesAsync(
+                    executeContext.Arguments.FolderPath,
+                    executeContext.Arguments.DestinationBucketName,
+                    executeContext.Arguments.DestinationKeyName,
+                    executeContext.CancellationToken);
+
+                if (!transferFilesResult.IsSuccess)
+                {
+                    var errorMessage = string.Join("; ", transferFilesResult.Errors);
+                    logger.LogError("Failed to transfer files from {FolderPath} to bucket {DestinationBucketName}, key {DestinationKeyName}. Errors: {Errors}",
+                        executeContext.Arguments.FolderPath,
+                        executeContext.Arguments.DestinationBucketName,
+                        executeContext.Arguments.DestinationKeyName,
+                        errorMessage);
+                    throw new Exception(errorMessage);
+                }
+
+                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Error transferring files from {FolderPath} to bucket {DestinationBucketName}",
+                    executeContext.Arguments.FolderPath,
+                    executeContext.Arguments.DestinationBucketName);
+                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
+                throw;
+            }
        }
    }
 }
@@ -1,11 +1,15 @@
 using MassTransit;
+using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Domain.Entities;
 using Musify.Infrastructure.Messaging.Activities.Arguments;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class UpdatePlayListPictureActivity(IDatabase database, IProcessTrackingStore processTrackingStore)
+    public class UpdatePlayListPictureActivity(
+        IDatabase database,
+        ILogger<UpdatePlayListPictureActivity> logger,
+        IProcessTrackingStore processTrackingStore)
        : IExecuteActivity<UpdatePlayListPictureArguments>
    {
        public const string ExecuteEndpointName = "Update-PlayList-Picture";
@@ -28,10 +32,16 @@ namespace Musify.Infrastructure.Messaging.Activities

            try
            {
-                var playList = await database.PlayLists.FindAsync(executeContext.Arguments.PlayListId, executeContext.CancellationToken);
+                var playList = await database.PlayLists.FindAsync(
+                    new object[] { executeContext.Arguments.PlayListId },
+                    cancellationToken: executeContext.CancellationToken);

                if (playList is null)
-                    throw new Exception($"PlayList with id {executeContext.Arguments.PlayListId} not found.");
+                {
+                    logger.LogError("PlayList with id {PlayListId} not found",
+                        executeContext.Arguments.PlayListId);
+                    throw new InvalidOperationException($"PlayList with id {executeContext.Arguments.PlayListId} not found");
+                }

                playList.SmallPictureKeyName = executeContext.Arguments.SmallPictureKeyName;
                playList.MediumPictureKeyName = executeContext.Arguments.MediumPictureKeyName;
@@ -40,11 +50,16 @@ namespace Musify.Infrastructure.Messaging.Activities
                database.PlayLists.Update(playList);
                await database.SaveChangesAsync(executeContext.CancellationToken);

+                logger.LogInformation("Updated PlayList {PlayListId} pictures",
+                    executeContext.Arguments.PlayListId);
+
                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
                return executeContext.Completed();
            }
            catch (Exception exception)
            {
+                logger.LogError(exception, "Error updating PlayList {PlayListId} pictures",
+                    executeContext.Arguments.PlayListId);
                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
                throw;
            }
@@ -1,11 +1,15 @@
 using MassTransit;
+using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts.Infrastructure;
 using Musify.Domain.Entities;
 using Musify.Infrastructure.Messaging.Activities.Arguments;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class UpdateTrackPictureActivity(IDatabase database, IProcessTrackingStore processTrackingStore)
+    public class UpdateTrackPictureActivity(
+        IDatabase database,
+        ILogger<UpdateTrackPictureActivity> logger,
+        IProcessTrackingStore processTrackingStore)
        : IExecuteActivity<UpdateTrackPictureArguments>
    {
        public const string ExecuteEndpointName = "Update-Track-Picture";
@@ -28,10 +32,16 @@ namespace Musify.Infrastructure.Messaging.Activities

            try
            {
-                var track = await database.Tracks.FindAsync(executeContext.Arguments.TrackId, executeContext.CancellationToken);
+                var track = await database.Tracks.FindAsync(
+                    new object[] { executeContext.Arguments.TrackId },
+                    cancellationToken: executeContext.CancellationToken);

                if (track is null)
-                    throw new Exception($"Track with id {executeContext.Arguments.TrackId} not found.");
+                {
+                    logger.LogError("Track with id {TrackId} not found",
+                        executeContext.Arguments.TrackId);
+                    throw new InvalidOperationException($"Track with id {executeContext.Arguments.TrackId} not found");
+                }

                track.SmallPictureKeyName = executeContext.Arguments.SmallPictureKeyName;
                track.MediumPictureKeyName = executeContext.Arguments.MediumPictureKeyName;
@@ -40,11 +50,16 @@ namespace Musify.Infrastructure.Messaging.Activities
                database.Tracks.Update(track);
                await database.SaveChangesAsync(executeContext.CancellationToken);

+                logger.LogInformation("Updated Track {TrackId} pictures",
+                    executeContext.Arguments.TrackId);
+
                await processTrackingStore.CompleteStepAsync(processId, stepId, executeContext.CancellationToken);
                return executeContext.Completed();
            }
            catch (Exception exception)
            {
+                logger.LogError(exception, "Error updating Track {TrackId} pictures",
+                    executeContext.Arguments.TrackId);
                await processTrackingStore.FailStepAsync(processId, stepId, exception.Message, executeContext.CancellationToken);
                throw;
            }