Change editor rule

2026-09-24 13:24:43 +02:00
parent 16478678b5
commit 73e37dbecd
401 changed files with 14735 additions and 12995 deletions
@@ -4,45 +4,46 @@ using Musify.Application.Contracts;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;

-namespace Musify.Infrastructure.MassTransit.Activities.Files;
-
-internal class CopyFileInBucketActivity(
-    IStorageService storageService,
-    ILogger<CopyFileInBucketActivity> logger)
-    : IActivity<CopyFileInBucketArguments, CopyFileInBucketLog>
+namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
-    public const string ExecuteEndpointName = "copy-file-in-bucket";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileInBucketArguments> executeContext)
+    internal class CopyFileInBucketActivity(
+        IStorageService storageService,
+        ILogger<CopyFileInBucketActivity> logger)
+        : IActivity<CopyFileInBucketArguments, CopyFileInBucketLog>
    {
-        await storageService.CopyFileAsync(
-            executeContext.Arguments.SourceBucket,
-            executeContext.Arguments.SourceKey,
-            executeContext.Arguments.DestinationBucket,
-            executeContext.Arguments.DestinationKey,
-            executeContext.CancellationToken);
+        public const string ExecuteEndpointName = "copy-file-in-bucket";

-        return executeContext.Completed(new CopyFileInBucketLog(
-            executeContext.Arguments.DestinationBucket,
-            executeContext.Arguments.DestinationKey));
-    }
-
-    public async Task<CompensationResult> Compensate(CompensateContext<CopyFileInBucketLog> compensateContext)
-    {
-        try
+        public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileInBucketArguments> executeContext)
        {
-            await storageService.RemoveFileAsync(
-                compensateContext.Log.DestinationBucket,
-                compensateContext.Log.DestinationKey,
-                compensateContext.CancellationToken);
-            return compensateContext.Compensated();
+            await storageService.CopyFileAsync(
+                executeContext.Arguments.SourceBucket,
+                executeContext.Arguments.SourceKey,
+                executeContext.Arguments.DestinationBucket,
+                executeContext.Arguments.DestinationKey,
+                executeContext.CancellationToken);
+
+            return executeContext.Completed(new CopyFileInBucketLog(
+                executeContext.Arguments.DestinationBucket,
+                executeContext.Arguments.DestinationKey));
        }
-        catch (Exception exception)
+
+        public async Task<CompensationResult> Compensate(CompensateContext<CopyFileInBucketLog> compensateContext)
        {
-            logger.LogError(exception, "Failed to compensate copied file {Bucket}/{Key}",
-                compensateContext.Log.DestinationBucket,
-                compensateContext.Log.DestinationKey);
-            return compensateContext.Failed(exception);
+            try
+            {
+                await storageService.RemoveFileAsync(
+                    compensateContext.Log.DestinationBucket,
+                    compensateContext.Log.DestinationKey,
+                    compensateContext.CancellationToken);
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate copied file {Bucket}/{Key}",
+                    compensateContext.Log.DestinationBucket,
+                    compensateContext.Log.DestinationKey);
+                return compensateContext.Failed(exception);
+            }
        }
    }
 }
@@ -4,52 +4,53 @@ using Musify.Application.Contracts;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;

-namespace Musify.Infrastructure.MassTransit.Activities.Files;
-
-internal class DownloadFileFromBucketActivity(
-    IStorageService storageService,
-    ILogger<DownloadFileFromBucketActivity> logger)
-    : IActivity<DownloadFileFromBucketArguments, DownloadFileFromBucketLog>
+namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
-    public const string ExecuteEndpointName = "download-file-from-bucket";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
+    internal class DownloadFileFromBucketActivity(
+        IStorageService storageService,
+        ILogger<DownloadFileFromBucketActivity> logger)
+        : IActivity<DownloadFileFromBucketArguments, DownloadFileFromBucketLog>
    {
-        var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
-        ArgumentNullException.ThrowIfNull(destinationPath);
+        public const string ExecuteEndpointName = "download-file-from-bucket";

-        using var fileStream = await storageService.GetFileAsync(
-            executeContext.Arguments.Bucket,
-            executeContext.Arguments.Key,
-            executeContext.CancellationToken)
-            ?? throw new FileNotFoundException($"Object {executeContext.Arguments.Bucket}/{executeContext.Arguments.Key} was not found.");
-
-        var destinationDirectory = Path.GetDirectoryName(destinationPath);
-        if (!string.IsNullOrWhiteSpace(destinationDirectory))
-            Directory.CreateDirectory(destinationDirectory);
-
-        if (fileStream.CanSeek)
-            fileStream.Position = 0;
-
-        using var destinationStream = File.Create(destinationPath);
-        await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
-        return executeContext.Completed(new DownloadFileFromBucketLog(
-            executeContext.Arguments.Bucket,
-            executeContext.Arguments.Key,
-            destinationPath));
-    }
-
-    public Task<CompensationResult> Compensate(CompensateContext<DownloadFileFromBucketLog> compensateContext)
-    {
-        try
+        public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
        {
-            File.Delete(compensateContext.Log.DestinationFilePath);
-            return Task.FromResult(compensateContext.Compensated());
+            var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
+            ArgumentNullException.ThrowIfNull(destinationPath);
+
+            using var fileStream = await storageService.GetFileAsync(
+                executeContext.Arguments.Bucket,
+                executeContext.Arguments.Key,
+                executeContext.CancellationToken)
+                ?? throw new FileNotFoundException($"Object {executeContext.Arguments.Bucket}/{executeContext.Arguments.Key} was not found.");
+
+            var destinationDirectory = Path.GetDirectoryName(destinationPath);
+            if (!string.IsNullOrWhiteSpace(destinationDirectory))
+                Directory.CreateDirectory(destinationDirectory);
+
+            if (fileStream.CanSeek)
+                fileStream.Position = 0;
+
+            using var destinationStream = File.Create(destinationPath);
+            await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
+            return executeContext.Completed(new DownloadFileFromBucketLog(
+                executeContext.Arguments.Bucket,
+                executeContext.Arguments.Key,
+                destinationPath));
        }
-        catch (Exception exception)
+
+        public Task<CompensationResult> Compensate(CompensateContext<DownloadFileFromBucketLog> compensateContext)
        {
-            logger.LogError(exception, "Failed to compensate downloaded file {DestinationFilePath}", compensateContext.Log.DestinationFilePath);
-            return Task.FromResult(compensateContext.Failed(exception));
+            try
+            {
+                File.Delete(compensateContext.Log.DestinationFilePath);
+                return Task.FromResult(compensateContext.Compensated());
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate downloaded file {DestinationFilePath}", compensateContext.Log.DestinationFilePath);
+                return Task.FromResult(compensateContext.Failed(exception));
+            }
        }
    }
 }
@@ -5,34 +5,35 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Infrastructure.MassTransit.Arguments;

-namespace Musify.Infrastructure.MassTransit.Activities.Files;
-
-internal class RemoveFileFromBucketActivity(
-    IStorageService storageService,
-    ILogger<RemoveFileFromBucketActivity> logger)
-    : IExecuteActivity<RemoveFileFromBucketArguments>
+namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
-    public const string ExecuteEndpointName = "remove-file-from-bucket";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileFromBucketArguments> executeContext)
+    internal class RemoveFileFromBucketActivity(
+        IStorageService storageService,
+        ILogger<RemoveFileFromBucketActivity> logger)
+        : IExecuteActivity<RemoveFileFromBucketArguments>
    {
-        try
+        public const string ExecuteEndpointName = "remove-file-from-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileFromBucketArguments> executeContext)
        {
-            await storageService.RemoveFileAsync(
-                executeContext.Arguments.Bucket,
-                executeContext.Arguments.Key,
-                executeContext.CancellationToken);
-            return executeContext.Completed();
-        }
-        catch (AmazonS3Exception exception) when (
-            exception.StatusCode == HttpStatusCode.NotFound
-            || string.Equals(exception.ErrorCode, "NoSuchKey", StringComparison.OrdinalIgnoreCase))
-        {
-            logger.LogInformation(
-                "Key {Key} not found in bucket {Bucket}, skipping",
-                executeContext.Arguments.Key,
-                executeContext.Arguments.Bucket);
-            return executeContext.Completed();
+            try
+            {
+                await storageService.RemoveFileAsync(
+                    executeContext.Arguments.Bucket,
+                    executeContext.Arguments.Key,
+                    executeContext.CancellationToken);
+                return executeContext.Completed();
+            }
+            catch (AmazonS3Exception exception) when (
+                exception.StatusCode == HttpStatusCode.NotFound
+                || string.Equals(exception.ErrorCode, "NoSuchKey", StringComparison.OrdinalIgnoreCase))
+            {
+                logger.LogInformation(
+                    "Key {Key} not found in bucket {Bucket}, skipping",
+                    executeContext.Arguments.Key,
+                    executeContext.Arguments.Bucket);
+                return executeContext.Completed();
+            }
        }
    }
 }
@@ -4,51 +4,52 @@ using Musify.Application.Contracts;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;

-namespace Musify.Infrastructure.MassTransit.Activities.Files;
-
-internal class TransferFilesToBucketActivity(
-    IStorageService storageService,
-    ILogger<TransferFilesToBucketActivity> logger)
-    : IActivity<TransferFilesToBucketArguments, TransferFilesToBucketLog>
+namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
-    public const string ExecuteEndpointName = "transfer-files-to-bucket";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
+    internal class TransferFilesToBucketActivity(
+        IStorageService storageService,
+        ILogger<TransferFilesToBucketActivity> logger)
+        : IActivity<TransferFilesToBucketArguments, TransferFilesToBucketLog>
    {
-        var folderPath = executeContext.GetVariable<string>(executeContext.Arguments.SourceDirectoryVariable);
-        ArgumentNullException.ThrowIfNull(folderPath);
-        var destinationKey = executeContext.Arguments.DestinationKey;
-        ArgumentNullException.ThrowIfNull(destinationKey);
+        public const string ExecuteEndpointName = "transfer-files-to-bucket";

-        var uploadedKeys = await storageService.TransferFilesAsync(
-            folderPath,
-            executeContext.Arguments.DestinationBucket,
-            destinationKey,
-            executeContext.CancellationToken);
-
-        return executeContext.Completed(new TransferFilesToBucketLog(
-            executeContext.Arguments.DestinationBucket,
-            uploadedKeys.ToArray()));
-    }
-
-    public async Task<CompensationResult> Compensate(CompensateContext<TransferFilesToBucketLog> compensateContext)
-    {
-        try
+        public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
        {
-            foreach (var uploadedKey in compensateContext.Log.UploadedKeys)
-            {
-                await storageService.RemoveFileAsync(
-                    compensateContext.Log.DestinationBucket,
-                    uploadedKey,
-                    compensateContext.CancellationToken);
-            }
+            var folderPath = executeContext.GetVariable<string>(executeContext.Arguments.SourceDirectoryVariable);
+            ArgumentNullException.ThrowIfNull(folderPath);
+            var destinationKey = executeContext.Arguments.DestinationKey;
+            ArgumentNullException.ThrowIfNull(destinationKey);

-            return compensateContext.Compensated();
+            var uploadedKeys = await storageService.TransferFilesAsync(
+                folderPath,
+                executeContext.Arguments.DestinationBucket,
+                destinationKey,
+                executeContext.CancellationToken);
+
+            return executeContext.Completed(new TransferFilesToBucketLog(
+                executeContext.Arguments.DestinationBucket,
+                uploadedKeys.ToArray()));
        }
-        catch (Exception exception)
+
+        public async Task<CompensationResult> Compensate(CompensateContext<TransferFilesToBucketLog> compensateContext)
        {
-            logger.LogError(exception, "Failed to compensate file transfers to {DestinationBucket}", compensateContext.Log.DestinationBucket);
-            return compensateContext.Failed(exception);
+            try
+            {
+                foreach (var uploadedKey in compensateContext.Log.UploadedKeys)
+                {
+                    await storageService.RemoveFileAsync(
+                        compensateContext.Log.DestinationBucket,
+                        uploadedKey,
+                        compensateContext.CancellationToken);
+                }
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate file transfers to {DestinationBucket}", compensateContext.Log.DestinationBucket);
+                return compensateContext.Failed(exception);
+            }
        }
    }
 }
@@ -4,49 +4,50 @@ using Musify.Application.Contracts;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;

-namespace Musify.Infrastructure.MassTransit.Activities.Files;
-
-internal class UploadFileToBucketActivity(IStorageService storageService,
-    ILogger<UploadFileToBucketActivity> logger)
-    : IActivity<UploadFileToBucketArguments, UploadFileToBucketLog>
+namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
-    public const string ExecuteEndpointName = "upload-file-to-bucket";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<UploadFileToBucketArguments> executeContext)
+    internal class UploadFileToBucketActivity(IStorageService storageService,
+        ILogger<UploadFileToBucketActivity> logger)
+        : IActivity<UploadFileToBucketArguments, UploadFileToBucketLog>
    {
-        var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.FilePathVariable);
-        ArgumentNullException.ThrowIfNull(sourceFilePath);
-        var fileName = Path.GetFileName(sourceFilePath);
-        var destinationKey = string.Join('/', new[] { executeContext.Arguments.DestinationRoute, fileName }
-            .Where(static s => !string.IsNullOrWhiteSpace(s))
-            .Select(static s => s.Trim().Trim('/', '\\')));
+        public const string ExecuteEndpointName = "upload-file-to-bucket";

-        await storageService.UploadFileAsync(
-            sourceFilePath,
-            executeContext.Arguments.DestinationBucket,
-            destinationKey,
-            executeContext.CancellationToken);
-        return executeContext.CompletedWithVariables(new UploadFileToBucketLog(
-            executeContext.Arguments.DestinationBucket,
-            destinationKey));
-    }
-
-    public async Task<CompensationResult> Compensate(CompensateContext<UploadFileToBucketLog> compensateContext)
-    {
-        try
+        public async Task<ExecutionResult> Execute(ExecuteContext<UploadFileToBucketArguments> executeContext)
        {
-            await storageService.RemoveFileAsync(
-                compensateContext.Log.DestinationBucket,
-                compensateContext.Log.DestinationKey,
-                compensateContext.CancellationToken);
-            return compensateContext.Compensated();
+            var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.FilePathVariable);
+            ArgumentNullException.ThrowIfNull(sourceFilePath);
+            var fileName = Path.GetFileName(sourceFilePath);
+            var destinationKey = string.Join('/', new[] { executeContext.Arguments.DestinationRoute, fileName }
+                .Where(static s => !string.IsNullOrWhiteSpace(s))
+                .Select(static s => s.Trim().Trim('/', '\\')));
+
+            await storageService.UploadFileAsync(
+                sourceFilePath,
+                executeContext.Arguments.DestinationBucket,
+                destinationKey,
+                executeContext.CancellationToken);
+            return executeContext.CompletedWithVariables(new UploadFileToBucketLog(
+                executeContext.Arguments.DestinationBucket,
+                destinationKey));
        }
-        catch (Exception exception)
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UploadFileToBucketLog> compensateContext)
        {
-            logger.LogError(exception, "Error compensating file upload for {Bucket}/{Key}",
-                compensateContext.Log.DestinationBucket,
-                compensateContext.Log.DestinationKey);
-            return compensateContext.Failed(exception);
+            try
+            {
+                await storageService.RemoveFileAsync(
+                    compensateContext.Log.DestinationBucket,
+                    compensateContext.Log.DestinationKey,
+                    compensateContext.CancellationToken);
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Error compensating file upload for {Bucket}/{Key}",
+                    compensateContext.Log.DestinationBucket,
+                    compensateContext.Log.DestinationKey);
+                return compensateContext.Failed(exception);
+            }
        }
    }
 }