Staged

Infrastructure/Messaging/Activities/Arguments/DownloadFileFromBucketArguments.cs

@@ -0,0 +1,7 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record DownloadFileFromBucketArguments(
+        string BucketName,
+        string KeyName,
+        string DestinationPath);
+}

Infrastructure/Messaging/Activities/Arguments/RemoveFileFromBucketArguments.cs

@@ -1,6 +1,6 @@
 namespace Musify.Infrastructure.Messaging.Activities.Arguments
 {
-    public record RemoveFileArguments(
+    public record RemoveFileFromBucketArguments(
         string BucketName,
         string KeyName);
 }

Infrastructure/Messaging/Activities/Arguments/TranscodeDashAudioArguments.cs

@@ -0,0 +1,4 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record TranscodeDashAudioArguments(string SourceFilePath, string DestinationFolderName);
+}

Infrastructure/Messaging/Activities/Arguments/TransferFilesToBucketArguments.cs

@@ -0,0 +1,7 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record TransferFilesToBucketArguments(
+        string FolderPath,
+        string DestinationBucketName,
+        string DestinationKeyName);
+}

Infrastructure/Messaging/Activities/CopyFilesActivity.cs

@@ -1,39 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts.Infrastructure;
-using Musify.Infrastructure.Messaging.Activities.Arguments;
-
-namespace Musify.Infrastructure.Messaging.Activities
-{
-    public class CopyFilesActivity(IStorageHandler storageHandler, ILogger<CopyFilesActivity> logger)
-        : IExecuteActivity<CopyFileArguments[]>
-    {
-        public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileArguments[]> executeContext)
-        {
-            foreach (var file in executeContext.Arguments)
-            {
-                var copyFileResult = await storageHandler.CopyFileAsync(
-                    file.SourceBucketName,
-                    file.SourceKeyName,
-                    file.DestinationBucketName,
-                    file.SourceKeyName,
-                    executeContext.CancellationToken);
-
-                if (!copyFileResult.IsSuccess)
-                {
-                    string errorMessage = string.Join("; ", copyFileResult.Errors);
-                    logger.LogError(
-                        "Failed to copy file from {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}. Error: {ErrorMessage}",
-                        file.SourceBucketName,
-                        file.SourceKeyName,
-                        file.DestinationBucketName,
-                        file.DestinationKeyName,
-                        errorMessage);
-                    throw new Exception(errorMessage);
-                }
-            }
-
-            return executeContext.Completed();
-        }
-    }
-}

Infrastructure/Messaging/Activities/DownloadFileFromBucketActivity.cs

@@ -0,0 +1,41 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+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)
+        : 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,
+                executeContext.CancellationToken);
+
+            if (!getFile.IsSuccess)
+            {
+                var error = string.Join("; ", getFile.Errors);
+                logger.LogError("Failed to download file from bucket. Bucket: {BucketName}, Key: {KeyName}",
+                    executeContext.Arguments.BucketName,
+                    executeContext.Arguments.KeyName);
+                throw new Exception(error);
+            }
+
+            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();
+        }
+    }
+}

Infrastructure/Messaging/Activities/RemoveFileFromBucketActivity.cs

@@ -6,15 +6,15 @@ using Musify.Infrastructure.Messaging.Activities.Arguments;
 
 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class RemoveFilesActivity(
+    public class RemoveFileFromBucketActivity(
         IStorageHandler storageHandler,
-        ILogger<RemoveFilesActivity> logger,
+        ILogger<RemoveFileFromBucketActivity> logger,
         IProcessTrackingStore processTrackingStore)
-        : IExecuteActivity<RemoveFileArguments>
+        : IExecuteActivity<RemoveFileFromBucketArguments>
     {
         public const string ExecuteEndpointName = "Remove-File";
 
-        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileArguments> executeContext)
+        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileFromBucketArguments> executeContext)
         {
             var processId = await processTrackingStore.GetOrCreateProcessAsync(
                 "RoutingSlip",
@@ -25,7 +25,7 @@ namespace Musify.Infrastructure.Messaging.Activities
 
             var stepId = await processTrackingStore.StartStepAsync(
                 processId,
-                nameof(RemoveFilesActivity),
+                nameof(RemoveFileFromBucketActivity),
                 ProcessStepComponentType.Activity,
                 0,
                 executeContext.CancellationToken);

Infrastructure/Messaging/Activities/TranscodeDashAudioActivity.cs

@@ -0,0 +1,49 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+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,
+        AudioTranscoderConfiguration audioTranscoderConfiguration)
+        : IExecuteActivity<TranscodeDashAudioArguments>
+    {
+        public const string ExecuteEndpointName = "Transcode-Dash-Audio";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<TranscodeDashAudioArguments> executeContext)
+        {
+            var workingDirectory = Path.Combine(
+                audioTranscoderConfiguration.Routes.WorkingDirectory,
+                executeContext.Arguments.DestinationFolderName);
+
+            try
+            {
+                await using var fileStream = File.OpenRead(executeContext.Arguments.SourceFilePath);
+
+                var result = await audioTranscoder.TranscodeToDashAsync(
+                    fileStream,
+                    executeContext.Arguments.DestinationFolderName,
+                    audioTranscoderConfiguration.TranscodingTimeout,
+                    executeContext.CancellationToken);
+
+                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);
+                }
+
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Error during transcoding activity.");
+                throw;
+            }
+        }
+    }
+}

Infrastructure/Messaging/Activities/TransferFilesToBucket.cs

@@ -0,0 +1,31 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Infrastructure.Messaging.Activities.Arguments;
+
+namespace Musify.Infrastructure.Messaging.Activities
+{
+    public class TransferFilesToBucket(IStorageHandler storageHandler, ILogger<TransferFilesToBucket> logger)
+        : 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,
+                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);
+            }
+
+            return executeContext.Completed();
+        }
+    }
+}