chore: group .NET into backend/ and drop non-.NET test artifacts

- Move all .NET (6 projects, solution, Directory.*.props, nuget.config) into backend/ so the monorepo root can host non-.NET projects later - Remove throwaway test artifacts: player.html, pl.json - Trim dead Flutter rules from .gitignore Build from backend/Musify.slnx: 0 warnings, 0 errors. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-05 03:43:52 +02:00
parent d9c8c17b21
commit 8f34ed4874
247 changed files with 0 additions and 229 deletions
@@ -0,0 +1,73 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    internal class GenerateAudioWorkflowPathsActivity(
+        IDatabase database,
+        ILogger<GenerateAudioWorkflowPathsActivity> logger)
+        : IExecuteActivity<GenerateAudioWorkflowPathsArguments>
+    {
+        public const string ExecuteEndpointName = "generate-audio-workflow-paths";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<GenerateAudioWorkflowPathsArguments> executeContext)
+        {
+            Track track;
+            try
+            {
+                var getTrack = await database.Tracks.SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
+                track = getTrack ?? throw new InvalidOperationException($"Track with id {executeContext.Arguments.TrackId} not found.");
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to retrieve track for TrackId {TrackId}",
+                    executeContext.Arguments.TrackId);
+                throw;
+            }
+
+            try
+            {
+                track.AudioTranscodeProcessingStatus = ProcessingStatus.Processing;
+                var folderName = Guid.NewGuid().ToString();
+                var sourceFileName = Path.GetFileName(executeContext.Arguments.SourceKey);
+                var workingDirectory = Path.Combine(executeContext.Arguments.TemporaryRootDirectory, folderName);
+                var sourceFilePath = Path.Combine(workingDirectory, sourceFileName);
+
+                Directory.CreateDirectory(workingDirectory);
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+
+                logger.LogDebug("Generated audio workflow paths in {WorkingDirectory}", workingDirectory);
+
+                return executeContext.CompletedWithVariables(new Dictionary<string, object>
+                {
+                    [RoutingSlipVariableNames.Workflow.TemporalDirectory] = workingDirectory,
+                    [RoutingSlipVariableNames.Audio.SourceFilePath] = sourceFilePath,
+                    [RoutingSlipVariableNames.Audio.TranscodedDirectory] = workingDirectory
+                } );
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to generate audio workflow paths for {SourceKey}",
+                    executeContext.Arguments.SourceKey);
+
+                try
+                {
+                    track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
+                    await database.SaveChangesAsync(executeContext.CancellationToken);
+                }
+                catch (Exception dbException)
+                {
+                    logger.LogError(dbException, "Failed to update ProcessingStatus to Failed for track {TrackId}",
+                        executeContext.Arguments.TrackId);
+                }
+
+                throw;
+            }
+        }
+    }
+}
@@ -0,0 +1,89 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    internal class TranscodeAudioActivity(
+        IDatabase database,
+        IAudioTranscoderService audioTranscoder,
+        ILogger<TranscodeAudioActivity> logger)
+        : IActivity<TranscodeAudioArguments, TranscodeAudioLog>
+    {
+        public const string ExecuteEndpointName = "transcode-audio";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<TranscodeAudioArguments> executeContext)
+        {
+            var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.SourceFilePathVariable);
+            ArgumentNullException.ThrowIfNull(sourceFilePath, nameof(sourceFilePath));
+            var workingDirectory = executeContext.GetVariable<string>(executeContext.Arguments.WorkingDirectoryVariable);
+            ArgumentNullException.ThrowIfNull(workingDirectory, nameof(workingDirectory));
+
+            Track track;
+            try
+            {
+                var getTrack = await database.Tracks.SingleOrDefaultAsync(t => t.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
+                track = getTrack ?? throw new InvalidOperationException($"Track with Id {executeContext.Arguments.TrackId} not found");
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to retrieve track with Id {TrackId} from database", executeContext.Arguments.TrackId);
+                throw;
+            }
+
+            try
+            {
+                await using (var fileStream = File.OpenRead(sourceFilePath))
+                {
+                    await audioTranscoder.TranscodeToAudioFileAsync(
+                        fileStream,
+                        workingDirectory,
+                        executeContext.CancellationToken);
+                }
+
+                File.Delete(sourceFilePath);
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to transcode {SourceFilePath}", sourceFilePath);
+
+                try
+                {
+                    track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
+                    await database.SaveChangesAsync(executeContext.CancellationToken);
+                }
+                catch (Exception dbException)
+                {
+                    logger.LogError(dbException, "Failed to update ProcessingStatus to Failed for track {TrackId}",
+                        executeContext.Arguments.TrackId);
+                }
+
+                throw;
+            }
+        }
+
+        public Task<CompensationResult> Compensate(CompensateContext<TranscodeAudioLog> compensateContext)
+        {
+            try
+            {
+                if (Directory.Exists(compensateContext.Log.WorkingDirectory))
+                    Directory.Delete(compensateContext.Log.WorkingDirectory, recursive: true);
+                else
+                    logger.LogWarning("Working directory {WorkingDirectory} not found during compensation",
+                        compensateContext.Log.WorkingDirectory);
+                return Task.FromResult(compensateContext.Compensated());
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate transcoded audio directory {WorkingDirectory}", compensateContext.Log.WorkingDirectory);
+                return Task.FromResult(compensateContext.Failed(exception));
+            }
+        }
+    }
+}
@@ -0,0 +1,101 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Audio
+{
+    internal class UpdateTrackAudioActivity(
+        IDatabase database,
+        ILogger<UpdateTrackAudioActivity> logger)
+        : IActivity<UpdateTrackAudioArguments, UpdateTrackAudioLog>
+    {
+        public const string ExecuteEndpointName = "update-track-audio";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<UpdateTrackAudioArguments> executeContext)
+        {
+            Track track;
+            try
+            {
+                var getTrack = await database.Tracks.SingleOrDefaultAsync(t => t.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
+                track = getTrack ?? throw new InvalidOperationException($"Track with id {executeContext.Arguments.TrackId} not found");
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to retrieve track {TrackId}",
+                    executeContext.Arguments.TrackId);
+                throw;
+            }
+
+            var audioFolderKey = executeContext.Arguments.AudioFolderKey;
+            logger.LogDebug("Resolved audio folder key: {AudioFolderKey}", audioFolderKey);
+
+            if (string.IsNullOrWhiteSpace(audioFolderKey))
+            {
+                logger.LogWarning("Audio folder key is empty for track {TrackId}; skipping update", track.Id);
+                return executeContext.Completed();
+            }
+
+            try
+            {
+                var log = new UpdateTrackAudioLog(
+                    track.Id,
+                    track.AudioFolderName);
+
+                track.AudioFolderName = Path.GetFileName(audioFolderKey);
+                track.AudioTranscodeProcessingStatus = ProcessingStatus.Completed;
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+
+                logger.LogInformation("Updated track {TrackId} audio", executeContext.Arguments.TrackId);
+
+                return executeContext.Completed(log);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to update track {TrackId} audio",
+                    executeContext.Arguments.TrackId);
+
+                try
+                {
+                    track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
+                    await database.SaveChangesAsync(executeContext.CancellationToken);
+                }
+                catch (Exception dbException)
+                {
+                    logger.LogError(dbException, "Failed to update ProcessingStatus to Failed for track {TrackId}",
+                        executeContext.Arguments.TrackId);
+                }
+
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UpdateTrackAudioLog> compensateContext)
+        {
+            try
+            {
+                var track = await database.Tracks.SingleOrDefaultAsync(t => t.Id == compensateContext.Log.TrackId, compensateContext.CancellationToken);
+                if (track is null)
+                    throw new InvalidOperationException($"Track with id {compensateContext.Log.TrackId} not found");
+
+                track.AudioFolderName = compensateContext.Log.PreviousAudioFolderName;
+                track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
+                await database.SaveChangesAsync(compensateContext.CancellationToken);
+
+                logger.LogInformation("Compensated track {TrackId} audio", compensateContext.Log.TrackId);
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate track {TrackId} audio",
+                    compensateContext.Log.TrackId);
+                return compensateContext.Failed(exception);
+            }
+        }
+    }
+}
@@ -0,0 +1,61 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Files
+{
+    internal class CopyFileInBucketActivity(
+        IStorageService storageHandler,
+        ILogger<CopyFileInBucketActivity> logger)
+        : IActivity<CopyFileInBucketArguments, CopyFileInBucketLog>
+    {
+        public const string ExecuteEndpointName = "copy-file-in-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileInBucketArguments> executeContext)
+        {
+            try
+            {
+                await storageHandler.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)
+            {
+                logger.LogError(exception, "Failed to copy {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}",
+                    executeContext.Arguments.SourceBucket,
+                    executeContext.Arguments.SourceKey,
+                    executeContext.Arguments.DestinationBucket,
+                    executeContext.Arguments.DestinationKey);
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<CopyFileInBucketLog> compensateContext)
+        {
+            try
+            {
+                await storageHandler.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);
+            }
+        }
+    }
+}
@@ -0,0 +1,63 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Files
+{
+    internal class DownloadFileFromBucketActivity(
+        IStorageService storageHandler,
+        ILogger<DownloadFileFromBucketActivity> logger)
+        : IActivity<DownloadFileFromBucketArguments, DownloadFileFromBucketLog>
+    {
+        public const string ExecuteEndpointName = "download-file-from-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
+        {
+            var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
+            ArgumentNullException.ThrowIfNull(destinationPath, nameof(destinationPath));
+
+            try
+            {
+                using var fileStream = await storageHandler.GetFileAsync(
+                    executeContext.Arguments.Bucket,
+                    executeContext.Arguments.Key,
+                    executeContext.CancellationToken);
+
+                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)
+            {
+                logger.LogError(exception, "Failed to download file from bucket");
+                throw;
+            }
+        }
+
+        public Task<CompensationResult> Compensate(CompensateContext<DownloadFileFromBucketLog> compensateContext)
+        {
+            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));
+            }
+        }
+    }
+}
@@ -0,0 +1,46 @@
+using MassTransit;
+using Amazon.S3;
+using Microsoft.Extensions.Logging;
+using Musify.Infrastructure.MassTransit.Arguments;
+using System.Net;
+using Musify.Application.Contracts;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Files
+{
+    internal class RemoveFileFromBucketActivity(
+        IStorageService storageHandler,
+        ILogger<RemoveFileFromBucketActivity> logger)
+        : IExecuteActivity<RemoveFileFromBucketArguments>
+    {
+        public const string ExecuteEndpointName = "remove-file-from-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileFromBucketArguments> executeContext)
+        {
+            try
+            {
+                await storageHandler.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();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to remove {Key} from bucket {Bucket}",
+                    executeContext.Arguments.Key,
+                    executeContext.Arguments.Bucket);
+                throw;
+            }
+        }
+    }
+}
@@ -0,0 +1,66 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    public class TransferFilesToBucketActivity(
+        IStorageService storageHandler,
+        ILogger<TransferFilesToBucketActivity> logger)
+        : IActivity<TransferFilesToBucketArguments, TransferFilesToBucketLog>
+    {
+        public const string ExecuteEndpointName = "transfer-files-to-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
+        {
+            var folderPath = executeContext.GetVariable<string>(executeContext.Arguments.SourceDirectoryVariable);
+            ArgumentNullException.ThrowIfNull(folderPath, nameof(folderPath));
+            var destinationKey = executeContext.Arguments.DestinationKey;
+            ArgumentNullException.ThrowIfNull(destinationKey, nameof(destinationKey));
+
+            try
+            {
+                var uploadedKeys = Directory.GetFiles(folderPath)
+                    .Select(file => Path.Combine(destinationKey, Path.GetFileName(file)))
+                    .ToArray();
+
+                await storageHandler.TransferFilesAsync(
+                    folderPath,
+                    executeContext.Arguments.DestinationBucket,
+                    destinationKey,
+                    executeContext.CancellationToken);
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to transfer files from {FolderPath} to {DestinationBucket}",
+                    folderPath,
+                    executeContext.Arguments.DestinationBucket);
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<TransferFilesToBucketLog> compensateContext)
+        {
+            try
+            {
+                foreach (var uploadedKey in compensateContext.Log.UploadedKeys)
+                {
+                    await storageHandler.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);
+            }
+        }
+    }
+}
@@ -0,0 +1,61 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Files
+{
+    public class UploadFileToBucketActivity(IStorageService storageHandler,
+        ILogger<UploadFileToBucketActivity> logger)
+        : IActivity<UploadFileToBucketArguments, UploadFileToBucketLog>
+    {
+        public const string ExecuteEndpointName = "upload-file-to-bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<UploadFileToBucketArguments> executeContext)
+        {
+            var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.FilePathVariable);
+            ArgumentNullException.ThrowIfNull(sourceFilePath, nameof(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('/', '\\')));
+
+            try
+            {
+                await storageHandler.UploadFileAsync(
+                    sourceFilePath,
+                    executeContext.Arguments.DestinationBucket,
+                    destinationKey,
+                    executeContext.CancellationToken);
+                return executeContext.CompletedWithVariables(new UploadFileToBucketLog(
+                    executeContext.Arguments.DestinationBucket,
+                    destinationKey));
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to upload file to bucket");
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UploadFileToBucketLog> compensateContext)
+        {
+            try
+            {
+                await storageHandler.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);
+            }
+        }
+    }
+}
@@ -0,0 +1,51 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    public class GeneratePictureWorkflowPathsActivity(
+        ILogger<GeneratePictureWorkflowPathsActivity> logger)
+        : IExecuteActivity<GeneratePictureWorkflowPathsArguments>
+    {
+        public const string ExecuteEndpointName = "generate-picture-workflow-paths";
+
+        internal const string ResizedPictureFileExtension = ".webp";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<GeneratePictureWorkflowPathsArguments> executeContext)
+        {
+            try
+            {
+                var workingDirectory = Path.Combine(executeContext.Arguments.TemporaryRootDirectory, Guid.NewGuid().ToString());
+
+                var sourceFilePath = Path.Combine(
+                    workingDirectory, Guid.NewGuid().ToString() + Path.GetExtension(executeContext.Arguments.SourceKey));
+                var smallPictureFilePath = Path.Combine(
+                    workingDirectory, Guid.NewGuid().ToString() + ResizedPictureFileExtension);
+                var mediumPictureFilePath = Path.Combine(
+                    workingDirectory, Guid.NewGuid().ToString() + ResizedPictureFileExtension);
+                var largePictureFilePath = Path.Combine(
+                    workingDirectory, Guid.NewGuid().ToString() + ResizedPictureFileExtension);
+
+                Directory.CreateDirectory(workingDirectory);
+
+                logger.LogDebug("Generated picture workflow paths in {WorkingDirectory}",
+                    workingDirectory);
+                return executeContext.CompletedWithVariables(new Dictionary<string, object>
+                {
+                    [RoutingSlipVariableNames.Workflow.TemporalDirectory] = workingDirectory,
+                    [RoutingSlipVariableNames.Picture.OriginalFilePath] = sourceFilePath,
+                    [RoutingSlipVariableNames.Picture.SmallResizedFilePath] = smallPictureFilePath,
+                    [RoutingSlipVariableNames.Picture.MediumResizedFilePath] = mediumPictureFilePath,
+                    [RoutingSlipVariableNames.Picture.LargeResizedFilePath] = largePictureFilePath
+                } );
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to generate picture workflow paths for {SourceKey}",
+                    executeContext.Arguments.SourceKey);
+                throw;
+            }
+        }
+    }
+}
@@ -0,0 +1,72 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    public class ResizePictureActivity(
+        IPictureService pictureHandler,
+        ILogger<ResizePictureActivity> logger)
+        : IActivity<ResizePictureLocalArguments, ResizePictureLog>
+    {
+        public const string ExecuteEndpointName = "resize-picture";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<ResizePictureLocalArguments> executeContext)
+        {
+            var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.SourceFilePathVariable);
+            ArgumentNullException.ThrowIfNull(sourceFilePath, nameof(sourceFilePath));
+            var destinationFilePath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
+            ArgumentNullException.ThrowIfNull(destinationFilePath, nameof(destinationFilePath));
+
+            try
+            {
+                if (!File.Exists(sourceFilePath))
+                {
+                    logger.LogWarning("Source file not found: {SourceFilePath}", sourceFilePath);
+                    throw new FileNotFoundException($"Source file not found: {sourceFilePath}");
+                }
+
+                await using var fileStream = File.OpenRead(sourceFilePath);
+
+                var resizedPicture = await pictureHandler.ResizePictureAsWebpAsync(
+                    fileStream,
+                    executeContext.Arguments.Width,
+                    executeContext.Arguments.Height,
+                    executeContext.CancellationToken);
+
+                var destinationDirectory = Path.GetDirectoryName(destinationFilePath);
+                if (!string.IsNullOrEmpty(destinationDirectory))
+                    Directory.CreateDirectory(destinationDirectory);
+
+                await using var destinationStream = File.Create(destinationFilePath);
+                await resizedPicture.CopyToAsync(destinationStream, executeContext.CancellationToken);
+
+                logger.LogDebug("Resized picture from {SourceFilePath} to {DestinationFilePath}",
+                    sourceFilePath,
+                    destinationFilePath);
+                return executeContext.Completed(new ResizePictureLog(destinationFilePath));
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to resize picture {SourceFilePath}", sourceFilePath);
+                throw;
+            }
+        }
+
+        public Task<CompensationResult> Compensate(CompensateContext<ResizePictureLog> compensateContext)
+        {
+            try
+            {
+                File.Delete(compensateContext.Log.DestinationFilePath);
+                return Task.FromResult(compensateContext.Compensated());
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate resized file {DestinationFilePath}", compensateContext.Log.DestinationFilePath);
+                return Task.FromResult(compensateContext.Failed(exception));
+            }
+        }
+    }
+}
@@ -0,0 +1,95 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    public class UpdatePlayListPictureActivity(
+        IDatabase database,
+        ILogger<UpdatePlayListPictureActivity> logger)
+        : IActivity<UpdatePlayListPictureArguments, UpdatePlayListPictureLog>
+    {
+        public const string ExecuteEndpointName = "update-playlist-picture";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<UpdatePlayListPictureArguments> executeContext)
+        {
+            var smallResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.SmallPictureVariable);
+            ArgumentNullException.ThrowIfNull(smallResizedVariable, nameof(smallResizedVariable));
+            var mediumResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.MediumPictureVariable);
+            ArgumentNullException.ThrowIfNull(mediumResizedVariable, nameof(mediumResizedVariable));
+            var largeResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.LargePictureVariable);
+            ArgumentNullException.ThrowIfNull(largeResizedVariable, nameof(largeResizedVariable));
+
+            try
+            {
+                var playList = await database.PlayLists.FindAsync(
+                    [executeContext.Arguments.PlayListId],
+                    cancellationToken: executeContext.CancellationToken);
+
+                if (playList is null)
+                {
+                    logger.LogWarning("Playlist {PlayListId} not found",
+                        executeContext.Arguments.PlayListId);
+                    throw new InvalidOperationException($"PlayList with id {executeContext.Arguments.PlayListId} not found");
+                }
+
+                var log = new UpdatePlayListPictureLog(
+                    playList.Id,
+                    playList.OriginalPictureName,
+                    playList.SmallPictureName,
+                    playList.MediumPictureName,
+                    playList.LargePictureName);
+
+                playList.OriginalPictureName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
+                playList.SmallPictureName = Path.GetFileName(smallResizedVariable);
+                playList.MediumPictureName = Path.GetFileName(mediumResizedVariable);
+                playList.LargePictureName = Path.GetFileName(largeResizedVariable);
+
+                database.PlayLists.Update(playList);
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+
+                logger.LogInformation("Updated playlist {PlayListId} pictures",
+                    executeContext.Arguments.PlayListId);
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to update playlist {PlayListId} pictures",
+                    executeContext.Arguments.PlayListId);
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UpdatePlayListPictureLog> compensateContext)
+        {
+            try
+            {
+                var playList = await database.PlayLists.FindAsync(
+                    [compensateContext.Log.PlayListId],
+                    cancellationToken: compensateContext.CancellationToken);
+
+                if (playList is null)
+                {
+                    return compensateContext.Compensated();
+                }
+
+                playList.OriginalPictureName = compensateContext.Log.PreviousOriginalPictureKey;
+                playList.SmallPictureName = compensateContext.Log.PreviousSmallPictureKey;
+                playList.MediumPictureName = compensateContext.Log.PreviousMediumPictureKey;
+                playList.LargePictureName = compensateContext.Log.PreviousLargePictureKey;
+
+                database.PlayLists.Update(playList);
+                await database.SaveChangesAsync(compensateContext.CancellationToken);
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate playlist {PlayListId} pictures", compensateContext.Log.PlayListId);
+                return compensateContext.Failed(exception);
+            }
+        }
+    }
+}
@@ -0,0 +1,97 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities
+{
+    public class UpdateTrackPictureActivity(
+        IDatabase database,
+        ILogger<UpdateTrackPictureActivity> logger)
+        : IActivity<UpdateTrackPictureArguments, UpdateTrackPictureLog>
+    {
+        public const string ExecuteEndpointName = "update-track-picture";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<UpdateTrackPictureArguments> executeContext)
+        {
+            var smallResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.SmallPictureVariable);
+            ArgumentNullException.ThrowIfNull(smallResizedVariable, nameof(smallResizedVariable));
+            var mediumResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.MediumPictureVariable);
+            ArgumentNullException.ThrowIfNull(mediumResizedVariable, nameof(mediumResizedVariable));
+            var largeResizedVariable = executeContext.GetVariable<string>(executeContext.Arguments.LargePictureVariable);
+            ArgumentNullException.ThrowIfNull(largeResizedVariable, nameof(largeResizedVariable));
+
+            try
+            {
+                var track = await database.Tracks.FindAsync(
+                    [executeContext.Arguments.TrackId],
+                    cancellationToken: executeContext.CancellationToken);
+
+                if (track is null)
+                {
+                    logger.LogWarning("Track {TrackId} not found",
+                        executeContext.Arguments.TrackId);
+                    throw new InvalidOperationException($"Track with id {executeContext.Arguments.TrackId} not found");
+                }
+
+                var log = new UpdateTrackPictureLog(
+                    track.Id,
+                    track.OriginalPictureName,
+                    track.SmallPictureName,
+                    track.MediumPictureName,
+                    track.LargePictureName);
+
+                track.OriginalPictureName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
+                track.SmallPictureName = Path.GetFileName(smallResizedVariable);
+                track.MediumPictureName = Path.GetFileName(mediumResizedVariable);
+                track.LargePictureName = Path.GetFileName(largeResizedVariable);
+                track.PicturesProcessingStatus = ProcessingStatus.Completed;
+
+                database.Tracks.Update(track);
+                await database.SaveChangesAsync(executeContext.CancellationToken);
+
+                logger.LogInformation("Updated track {TrackId} pictures",
+                    executeContext.Arguments.TrackId);
+
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to update track {TrackId} pictures",
+                    executeContext.Arguments.TrackId);
+                throw;
+            }
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<UpdateTrackPictureLog> compensateContext)
+        {
+            try
+            {
+                var track = await database.Tracks.FindAsync(
+                    [compensateContext.Log.TrackId],
+                    cancellationToken: compensateContext.CancellationToken);
+
+                if (track is null)
+                    return compensateContext.Compensated();
+
+                track.OriginalPictureName = compensateContext.Log.PreviousOriginalPictureKey;
+                track.SmallPictureName = compensateContext.Log.PreviousSmallPictureKey;
+                track.MediumPictureName = compensateContext.Log.PreviousMediumPictureKey;
+                track.LargePictureName = compensateContext.Log.PreviousLargePictureKey;
+                track.PicturesProcessingStatus = ProcessingStatus.Failed;
+
+                database.Tracks.Update(track);
+                await database.SaveChangesAsync(compensateContext.CancellationToken);
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate track {TrackId} pictures", compensateContext.Log.TrackId);
+                return compensateContext.Failed(exception);
+            }
+        }
+    }
+}
@@ -0,0 +1,36 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.PlayLists
+{
+    internal class DeletePlayListFromDbActivity(
+        IDatabase database,
+        ILogger<DeletePlayListFromDbActivity> logger)
+        : IExecuteActivity<DeletePlayListFromDbArguments>
+    {
+        public const string ExecuteEndpointName = "delete-playList-from-db";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<DeletePlayListFromDbArguments> executeContext)
+        {
+            var playList = await database.PlayLists
+                .SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.PlayListId, executeContext.CancellationToken);
+
+            if (playList is null)
+            {
+                logger.LogInformation(
+                    "PlayList {PlayListId} not found while deleting from DB, skipping",
+                    executeContext.Arguments.PlayListId);
+                return executeContext.Completed();
+            }
+
+            database.PlayLists.Remove(playList);
+            await database.SaveChangesAsync(executeContext.CancellationToken);
+
+            logger.LogInformation("Deleted playlist {PlayListId} from DB", playList.Id);
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,37 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
+
+namespace Musify.Infrastructure.MassTransit.Activities.PlayLists
+{
+    internal class MarkPlayListAsRemovingActivity(
+        IDatabase database,
+        ILogger<MarkPlayListAsRemovingActivity> logger)
+        : IExecuteActivity<MarkPlayListAsRemovingArguments>
+    {
+        public const string ExecuteEndpointName = "mark-playList-as-removing";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<MarkPlayListAsRemovingArguments> executeContext)
+        {
+            var playList = await database.PlayLists
+                .SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.PlayListId, executeContext.CancellationToken);
+
+            if (playList is null)
+            {
+                logger.LogInformation(
+                    "PlayList {PlayListId} not found while marking as removing, skipping",
+                    executeContext.Arguments.PlayListId);
+                return executeContext.Completed();
+            }
+
+            playList.LifeCycleStatus = LifeCycleStatus.Removing;
+            await database.SaveChangesAsync(executeContext.CancellationToken);
+
+            logger.LogInformation("Marked playlist {PlayListId} as removing", playList.Id);
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,34 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.PlayLists
+{
+    internal class PublishPlayListPictureProcessingEventActivity(
+        IPublishEndpoint publishEndpoint,
+        ILogger<PublishPlayListPictureProcessingEventActivity> logger)
+        : IExecuteActivity<PublishPlayListPictureProcessingEventArguments>
+    {
+        public const string ExecuteEndpointName = "publish-playList-picture-processing-event";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<PublishPlayListPictureProcessingEventArguments> executeContext)
+        {
+            var arguments = executeContext.Arguments;
+
+            await publishEndpoint.Publish(
+                new UpdatePlayListPictureEvent(
+                    arguments.PlayListId,
+                    arguments.Bucket,
+                    arguments.FinalPictureKey,
+                    arguments.Small,
+                    arguments.Medium,
+                    arguments.Large),
+                executeContext.CancellationToken);
+
+            logger.LogInformation("Published picture processing event for playlist {PlayListId}", arguments.PlayListId);
+
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,36 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Tracks
+{
+    internal class DeleteTrackFromDbActivity(
+        IDatabase database,
+        ILogger<DeleteTrackFromDbActivity> logger)
+        : IExecuteActivity<DeleteTrackFromDbArguments>
+    {
+        public const string ExecuteEndpointName = "delete-track-from-db";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<DeleteTrackFromDbArguments> executeContext)
+        {
+            var track = await database.Tracks
+                .SingleOrDefaultAsync(t => t.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
+
+            if (track is null)
+            {
+                logger.LogInformation(
+                    "Track {TrackId} not found while deleting from DB, skipping",
+                    executeContext.Arguments.TrackId);
+                return executeContext.Completed();
+            }
+
+            database.Tracks.Remove(track);
+            await database.SaveChangesAsync(executeContext.CancellationToken);
+
+            logger.LogInformation("Deleted track {TrackId} from DB", track.Id);
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,37 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Domain.ValueObjects;
+using Musify.Application.Contracts;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Tracks
+{
+    internal class MarkTrackAsRemovingActivity(
+        IDatabase database,
+        ILogger<MarkTrackAsRemovingActivity> logger)
+        : IExecuteActivity<MarkTrackAsRemovingArguments>
+    {
+        public const string ExecuteEndpointName = "mark-track-as-removing";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<MarkTrackAsRemovingArguments> executeContext)
+        {
+            var track = await database.Tracks
+                .SingleOrDefaultAsync(t => t.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
+
+            if (track is null)
+            {
+                logger.LogInformation(
+                    "Track {TrackId} not found while marking as removing, skipping",
+                    executeContext.Arguments.TrackId);
+                return executeContext.Completed();
+            }
+
+            track.LifeCycleStatus = LifeCycleStatus.Removing;
+            await database.SaveChangesAsync(executeContext.CancellationToken);
+
+            logger.LogInformation("Marked track {TrackId} as removing", track.Id);
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,43 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Tracks
+{
+    internal class PublishTrackProcessingEventsActivity(
+        IPublishEndpoint publishEndpoint,
+        ILogger<PublishTrackProcessingEventsActivity> logger)
+        : IExecuteActivity<PublishTrackProcessingEventsArguments>
+    {
+        public const string ExecuteEndpointName = "publish-track-processing-events";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<PublishTrackProcessingEventsArguments> executeContext)
+        {
+            var arguments = executeContext.Arguments;
+
+            await publishEndpoint.Publish(
+                new UpdateTrackPictureEvent(
+                    arguments.TrackId,
+                    arguments.Bucket,
+                    arguments.FinalPictureKey,
+                    arguments.Small,
+                    arguments.Medium,
+                    arguments.Large),
+                executeContext.CancellationToken);
+
+            await publishEndpoint.Publish(
+                new UpdateTrackAudioEvent(
+                    arguments.TrackId,
+                    arguments.Bucket,
+                    arguments.FinalAudioKey,
+                    arguments.Bucket,
+                    arguments.AudioDestinationFolderKey),
+                executeContext.CancellationToken);
+
+            logger.LogInformation("Published processing events for track {TrackId}", arguments.TrackId);
+
+            return executeContext.Completed();
+        }
+    }
+}
@@ -0,0 +1,62 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.UploadIntents
+{
+    internal class ConsumeUploadIntentsActivity(
+        IDatabase database,
+        ILogger<ConsumeUploadIntentsActivity> logger)
+        : IActivity<ConsumeUploadIntentsArguments, ConsumeUploadIntentsLog>
+    {
+        public const string ExecuteEndpointName = "consume-upload-intents";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<ConsumeUploadIntentsArguments> executeContext)
+        {
+            var intentIds = executeContext.Arguments.IntentIds;
+
+            var intents = await database.UploadIntents
+                .Where(i => intentIds.Contains(i.Id))
+                .ToListAsync(executeContext.CancellationToken);
+
+            foreach (var intent in intents)
+                intent.Status = UploadIntentStatus.Consumed;
+
+            await database.SaveChangesAsync(executeContext.CancellationToken);
+
+            logger.LogInformation("Marked {Count} upload intent(s) as consumed", intents.Count);
+
+            return executeContext.Completed(new ConsumeUploadIntentsLog(intentIds));
+        }
+
+        public async Task<CompensationResult> Compensate(CompensateContext<ConsumeUploadIntentsLog> compensateContext)
+        {
+            try
+            {
+                var intentIds = compensateContext.Log.IntentIds;
+
+                var intents = await database.UploadIntents
+                    .Where(i => intentIds.Contains(i.Id))
+                    .ToListAsync(compensateContext.CancellationToken);
+
+                foreach (var intent in intents)
+                    intent.Status = UploadIntentStatus.Issued;
+
+                await database.SaveChangesAsync(compensateContext.CancellationToken);
+
+                logger.LogInformation("Reverted {Count} upload intent(s) back to Issued", intents.Count);
+
+                return compensateContext.Compensated();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to compensate upload intent consumption");
+                return compensateContext.Failed(exception);
+            }
+        }
+    }
+}