Deduplicate MassTransit routing slips, activities and consumers

backend/Core/Musify.Infrastructure/MassTransit/Activities/Albums/DeleteAlbumFromDbActivity.cs

@@ -1,35 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Albums;
-
-internal class DeleteAlbumFromDbActivity(
-    IDatabase database,
-    ILogger<DeleteAlbumFromDbActivity> logger)
-    : IExecuteActivity<DeleteAlbumFromDbArguments>
-{
-    public const string ExecuteEndpointName = "delete-album-from-db";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<DeleteAlbumFromDbArguments> executeContext)
-    {
-        var album = await database.Albums
-            .SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.AlbumId, executeContext.CancellationToken);
-
-        if (album == null)
-        {
-            logger.LogInformation(
-                "Album {AlbumId} not found while deleting from DB, skipping",
-                executeContext.Arguments.AlbumId);
-            return executeContext.Completed();
-        }
-
-        database.Albums.Remove(album);
-        await database.SaveChangesAsync(executeContext.CancellationToken);
-
-        logger.LogInformation("Deleted album {AlbumId} from DB", album.Id);
-        return executeContext.Completed();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Albums/MarkAlbumAsFailedActivity.cs

@@ -1,31 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Albums;
-
-internal class MarkAlbumAsFailedActivity(
-    IDatabase database,
-    ILogger<MarkAlbumAsFailedActivity> logger)
-    : IExecuteActivity<MarkAlbumAsFailedArguments>
-{
-    public const string ExecuteEndpointName = "mark-album-as-failed";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<MarkAlbumAsFailedArguments> executeContext)
-    {
-        var album = await database.Albums
-            .SingleOrDefaultAsync(a => a.Id == executeContext.Arguments.AlbumId, executeContext.CancellationToken);
-
-        if (album != null)
-        {
-            album.LifeCycleStatus = LifeCycleStatus.Failed;
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-            logger.LogInformation("Marked album {AlbumId} as failed", executeContext.Arguments.AlbumId);
-        }
-
-        return executeContext.Completed();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Albums/MarkAlbumAsRemovingActivity.cs

@@ -1,36 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Albums;
-
-internal class MarkAlbumAsRemovingActivity(
-    IDatabase database,
-    ILogger<MarkAlbumAsRemovingActivity> logger)
-    : IExecuteActivity<MarkAlbumAsRemovingArguments>
-{
-    public const string ExecuteEndpointName = "mark-album-as-removing";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<MarkAlbumAsRemovingArguments> executeContext)
-    {
-        var album = await database.Albums
-            .SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.AlbumId, executeContext.CancellationToken);
-
-        if (album == null)
-        {
-            logger.LogInformation(
-                "Album {AlbumId} not found while marking as removing, skipping",
-                executeContext.Arguments.AlbumId);
-            return executeContext.Completed();
-        }
-
-        album.LifeCycleStatus = LifeCycleStatus.Removing;
-        await database.SaveChangesAsync(executeContext.CancellationToken);
-
-        logger.LogInformation("Marked album {AlbumId} as removing", album.Id);
-        return executeContext.Completed();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Audio/GenerateAudioWorkflowPathsActivity.cs

@@ -1,10 +1,9 @@
 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.RoutingSlip;
 
 namespace Musify.Infrastructure.MassTransit.Activities.Audio;
 
@@ -17,26 +16,15 @@ internal class GenerateAudioWorkflowPathsActivity(
 
     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;
-        }
+        var arguments = executeContext.Arguments;
+        var track = await TrackAudioStatus.LoadAsync(database, arguments.TrackId, executeContext.CancellationToken);
 
         try
         {
             track.Audio.TranscodeStatus = 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);
+
+            var workingDirectory = Path.Combine(arguments.TemporaryRootDirectory, Guid.NewGuid().ToString());
+            var sourceFilePath = Path.Combine(workingDirectory, Path.GetFileName(arguments.SourceKey));
 
             Directory.CreateDirectory(workingDirectory);
             await database.SaveChangesAsync(executeContext.CancellationToken);
@@ -50,22 +38,9 @@ internal class GenerateAudioWorkflowPathsActivity(
                 [RoutingSlipVariableNames.Audio.TranscodedDirectory] = workingDirectory
             });
         }
-        catch (Exception exception)
+        catch
         {
-            logger.LogError(exception, "Failed to generate audio workflow paths for {SourceKey}",
-                executeContext.Arguments.SourceKey);
-
-            try
-            {
-                track.Audio.TranscodeStatus = 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);
-            }
-
+            await TrackAudioStatus.MarkFailedAsync(database, arguments.TrackId, executeContext.CancellationToken);
             throw;
         }
     }

backend/Core/Musify.Infrastructure/MassTransit/Activities/Audio/TrackAudioStatus.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Contracts;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Audio;
+
+/// <summary>Shared bookkeeping of the audio processing activities.</summary>
+internal static class TrackAudioStatus
+{
+    public static async Task<Track> LoadAsync(IDatabase database, Guid trackId, CancellationToken cancellationToken) =>
+        await database.Tracks.SingleOrDefaultAsync(track => track.Id == trackId, cancellationToken)
+            ?? throw new InvalidOperationException($"Track with id {trackId} not found");
+
+    public static async Task MarkFailedAsync(IDatabase database, Guid trackId, CancellationToken cancellationToken)
+    {
+        var track = await database.Tracks.SingleOrDefaultAsync(t => t.Id == trackId, cancellationToken);
+        if (track == null)
+            return;
+
+        track.Audio.TranscodeStatus = ProcessingStatus.Failed;
+        await database.SaveChangesAsync(cancellationToken);
+    }
+}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Audio/TranscodeAudioActivity.cs

@@ -1,11 +1,9 @@
 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;
+using Musify.Infrastructure.MassTransit.RoutingSlip;
 
 namespace Musify.Infrastructure.MassTransit.Activities.Audio;
 
@@ -19,22 +17,13 @@ internal class TranscodeAudioActivity(
 
     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));
+        var arguments = executeContext.Arguments;
+        var sourceFilePath = executeContext.GetVariable<string>(arguments.SourceFilePathVariable);
+        ArgumentNullException.ThrowIfNull(sourceFilePath);
+        var workingDirectory = executeContext.GetVariable<string>(arguments.WorkingDirectoryVariable);
+        ArgumentNullException.ThrowIfNull(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;
-        }
+        await TrackAudioStatus.LoadAsync(database, arguments.TrackId, executeContext.CancellationToken);
 
         try
         {
@@ -42,9 +31,7 @@ internal class TranscodeAudioActivity(
             await using (var fileStream = File.OpenRead(sourceFilePath))
             {
                 transcodeResult = await audioTranscoder.TranscodeToAudioFileAsync(
-                    fileStream,
-                    workingDirectory,
-                    executeContext.CancellationToken);
+                    fileStream, workingDirectory, executeContext.CancellationToken);
             }
 
             if (transcodeResult.StatusCode != 0)
@@ -52,51 +39,27 @@ internal class TranscodeAudioActivity(
 
             File.Delete(sourceFilePath);
 
-            var log = new TranscodeAudioLog(workingDirectory);
-            return executeContext.CompletedWithVariables(log, new Dictionary<string, object>
+            return executeContext.CompletedWithVariables(new TranscodeAudioLog(workingDirectory), new Dictionary<string, object>
             {
                 [RoutingSlipVariableNames.Audio.DurationSeconds] = transcodeResult.Duration.TotalSeconds
             });
         }
-        catch (Exception exception)
+        catch
         {
-            logger.LogError(exception, "Failed to transcode {SourceFilePath}", sourceFilePath);
-
-            try
-            {
-                track.Audio.TranscodeStatus = 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);
-            }
-
+            await TrackAudioStatus.MarkFailedAsync(database, arguments.TrackId, executeContext.CancellationToken);
             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);
-            }
+        var workingDirectory = 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));
-        }
+        if (Directory.Exists(workingDirectory))
+            Directory.Delete(workingDirectory, recursive: true);
+        else
+            logger.LogWarning("Working directory {WorkingDirectory} not found during compensation", workingDirectory);
+
+        return Task.FromResult(compensateContext.Compensated());
     }
 }

backend/Core/Musify.Infrastructure/MassTransit/Activities/Audio/UpdateTrackAudioActivity.cs

@@ -1,9 +1,7 @@
 using MassTransit;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Application.Events;
-using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Logs;
@@ -20,92 +18,49 @@ internal class UpdateTrackAudioActivity(
 
     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))
-        {
-            throw new InvalidOperationException($"Audio folder key is empty for track {track.Id}");
-        }
+        var arguments = executeContext.Arguments;
+        var track = await TrackAudioStatus.LoadAsync(database, arguments.TrackId, executeContext.CancellationToken);
 
         try
         {
-            var durationSeconds = executeContext.GetVariable<double>(executeContext.Arguments.DurationSecondsVariable)
-                ?? throw new InvalidOperationException($"Missing routing slip variable {executeContext.Arguments.DurationSecondsVariable}");
+            if (string.IsNullOrWhiteSpace(arguments.AudioFolderKey))
+                throw new InvalidOperationException($"Audio folder key is empty for track {track.Id}");
 
-            var log = new UpdateTrackAudioLog(
-                track.Id,
-                track.Audio.FolderName,
-                track.DurationSeconds);
+            var durationSeconds = executeContext.GetVariable<double>(arguments.DurationSecondsVariable)
+                ?? throw new InvalidOperationException($"Missing routing slip variable {arguments.DurationSecondsVariable}");
 
-            track.Audio.FolderName = Path.GetFileName(audioFolderKey);
+            var log = new UpdateTrackAudioLog(track.Id, track.Audio.FolderName, track.DurationSeconds);
+
+            track.Audio.FolderName = Path.GetFileName(arguments.AudioFolderKey);
             track.DurationSeconds = durationSeconds;
             track.Audio.TranscodeStatus = ProcessingStatus.Completed;
             await database.SaveChangesAsync(executeContext.CancellationToken);
 
-            logger.LogInformation("Updated track {TrackId} audio", executeContext.Arguments.TrackId);
+            logger.LogInformation("Updated track {TrackId} audio", arguments.TrackId);
 
-            await publishEndpoint.Publish(
-                new TrackAudioProcessed(executeContext.Arguments.TrackId),
-                executeContext.CancellationToken);
+            await publishEndpoint.Publish(new TrackAudioProcessed(arguments.TrackId), executeContext.CancellationToken);
 
             return executeContext.Completed(log);
         }
-        catch (Exception exception)
+        catch
         {
-            logger.LogError(exception, "Failed to update track {TrackId} audio",
-                executeContext.Arguments.TrackId);
-
-            try
-            {
-                track.Audio.TranscodeStatus = 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);
-            }
-
+            await TrackAudioStatus.MarkFailedAsync(database, arguments.TrackId, executeContext.CancellationToken);
             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 == null)
-                throw new InvalidOperationException($"Track with id {compensateContext.Log.TrackId} not found");
+        var log = compensateContext.Log;
 
-            track.Audio.FolderName = compensateContext.Log.PreviousAudioFolderName;
-            track.DurationSeconds = compensateContext.Log.PreviousDurationSeconds;
-            track.Audio.TranscodeStatus = ProcessingStatus.Failed;
-            await database.SaveChangesAsync(compensateContext.CancellationToken);
+        var track = await TrackAudioStatus.LoadAsync(database, log.TrackId, compensateContext.CancellationToken);
+        track.Audio.FolderName = log.PreviousAudioFolderName;
+        track.DurationSeconds = log.PreviousDurationSeconds;
+        track.Audio.TranscodeStatus = ProcessingStatus.Failed;
+        await database.SaveChangesAsync(compensateContext.CancellationToken);
 
-            logger.LogInformation("Compensated track {TrackId} audio", compensateContext.Log.TrackId);
+        logger.LogInformation("Compensated track {TrackId} audio", log.TrackId);
 
-            return compensateContext.Compensated();
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to compensate track {TrackId} audio",
-                compensateContext.Log.TrackId);
-            return compensateContext.Failed(exception);
-        }
+        return compensateContext.Compensated();
     }
 }

backend/Core/Musify.Infrastructure/MassTransit/Activities/Files/CopyFileInBucketActivity.cs

@@ -7,7 +7,7 @@ using Musify.Infrastructure.MassTransit.Logs;
 namespace Musify.Infrastructure.MassTransit.Activities.Files;
 
 internal class CopyFileInBucketActivity(
-    IStorageService storageHandler,
+    IStorageService storageService,
     ILogger<CopyFileInBucketActivity> logger)
     : IActivity<CopyFileInBucketArguments, CopyFileInBucketLog>
 {
@@ -17,7 +17,7 @@ internal class CopyFileInBucketActivity(
     {
         try
         {
-            await storageHandler.CopyFileAsync(
+            await storageService.CopyFileAsync(
                 executeContext.Arguments.SourceBucket,
                 executeContext.Arguments.SourceKey,
                 executeContext.Arguments.DestinationBucket,
@@ -43,7 +43,7 @@ internal class CopyFileInBucketActivity(
     {
         try
         {
-            await storageHandler.RemoveFileAsync(
+            await storageService.RemoveFileAsync(
                 compensateContext.Log.DestinationBucket,
                 compensateContext.Log.DestinationKey,
                 compensateContext.CancellationToken);

backend/Core/Musify.Infrastructure/MassTransit/Activities/Files/DownloadFileFromBucketActivity.cs

@@ -7,7 +7,7 @@ using Musify.Infrastructure.MassTransit.Logs;
 namespace Musify.Infrastructure.MassTransit.Activities.Files;
 
 internal class DownloadFileFromBucketActivity(
-    IStorageService storageHandler,
+    IStorageService storageService,
     ILogger<DownloadFileFromBucketActivity> logger)
     : IActivity<DownloadFileFromBucketArguments, DownloadFileFromBucketLog>
 {
@@ -16,11 +16,11 @@ internal class DownloadFileFromBucketActivity(
     public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
     {
         var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
-        ArgumentNullException.ThrowIfNull(destinationPath, nameof(destinationPath));
+        ArgumentNullException.ThrowIfNull(destinationPath);
 
         try
         {
-            using var fileStream = await storageHandler.GetFileAsync(
+            using var fileStream = await storageService.GetFileAsync(
                 executeContext.Arguments.Bucket,
                 executeContext.Arguments.Key,
                 executeContext.CancellationToken)

backend/Core/Musify.Infrastructure/MassTransit/Activities/Files/RemoveFileFromBucketActivity.cs

@@ -8,7 +8,7 @@ using Musify.Infrastructure.MassTransit.Arguments;
 namespace Musify.Infrastructure.MassTransit.Activities.Files;
 
 internal class RemoveFileFromBucketActivity(
-    IStorageService storageHandler,
+    IStorageService storageService,
     ILogger<RemoveFileFromBucketActivity> logger)
     : IExecuteActivity<RemoveFileFromBucketArguments>
 {
@@ -18,7 +18,7 @@ internal class RemoveFileFromBucketActivity(
     {
         try
         {
-            await storageHandler.RemoveFileAsync(
+            await storageService.RemoveFileAsync(
                 executeContext.Arguments.Bucket,
                 executeContext.Arguments.Key,
                 executeContext.CancellationToken);

backend/Core/Musify.Infrastructure/MassTransit/Activities/Files/TransferFilesToBucketActivity.cs

@@ -7,7 +7,7 @@ using Musify.Infrastructure.MassTransit.Logs;
 namespace Musify.Infrastructure.MassTransit.Activities.Files;
 
 internal class TransferFilesToBucketActivity(
-    IStorageService storageHandler,
+    IStorageService storageService,
     ILogger<TransferFilesToBucketActivity> logger)
     : IActivity<TransferFilesToBucketArguments, TransferFilesToBucketLog>
 {
@@ -16,13 +16,13 @@ internal class TransferFilesToBucketActivity(
     public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
     {
         var folderPath = executeContext.GetVariable<string>(executeContext.Arguments.SourceDirectoryVariable);
-        ArgumentNullException.ThrowIfNull(folderPath, nameof(folderPath));
+        ArgumentNullException.ThrowIfNull(folderPath);
         var destinationKey = executeContext.Arguments.DestinationKey;
-        ArgumentNullException.ThrowIfNull(destinationKey, nameof(destinationKey));
+        ArgumentNullException.ThrowIfNull(destinationKey);
 
         try
         {
-            var uploadedKeys = await storageHandler.TransferFilesAsync(
+            var uploadedKeys = await storageService.TransferFilesAsync(
                 folderPath,
                 executeContext.Arguments.DestinationBucket,
                 destinationKey,
@@ -47,7 +47,7 @@ internal class TransferFilesToBucketActivity(
         {
             foreach (var uploadedKey in compensateContext.Log.UploadedKeys)
             {
-                await storageHandler.RemoveFileAsync(
+                await storageService.RemoveFileAsync(
                     compensateContext.Log.DestinationBucket,
                     uploadedKey,
                     compensateContext.CancellationToken);

backend/Core/Musify.Infrastructure/MassTransit/Activities/Files/UploadFileToBucketActivity.cs

@@ -6,7 +6,7 @@ using Musify.Infrastructure.MassTransit.Logs;
 
 namespace Musify.Infrastructure.MassTransit.Activities.Files;
 
-internal class UploadFileToBucketActivity(IStorageService storageHandler,
+internal class UploadFileToBucketActivity(IStorageService storageService,
     ILogger<UploadFileToBucketActivity> logger)
     : IActivity<UploadFileToBucketArguments, UploadFileToBucketLog>
 {
@@ -15,7 +15,7 @@ internal class UploadFileToBucketActivity(IStorageService storageHandler,
     public async Task<ExecutionResult> Execute(ExecuteContext<UploadFileToBucketArguments> executeContext)
     {
         var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.FilePathVariable);
-        ArgumentNullException.ThrowIfNull(sourceFilePath, nameof(sourceFilePath));
+        ArgumentNullException.ThrowIfNull(sourceFilePath);
         var fileName = Path.GetFileName(sourceFilePath);
         var destinationKey = string.Join('/', new[] { executeContext.Arguments.DestinationRoute, fileName }
             .Where(static s => !string.IsNullOrWhiteSpace(s))
@@ -23,7 +23,7 @@ internal class UploadFileToBucketActivity(IStorageService storageHandler,
 
         try
         {
-            await storageHandler.UploadFileAsync(
+            await storageService.UploadFileAsync(
                 sourceFilePath,
                 executeContext.Arguments.DestinationBucket,
                 destinationKey,
@@ -43,7 +43,7 @@ internal class UploadFileToBucketActivity(IStorageService storageHandler,
     {
         try
         {
-            await storageHandler.RemoveFileAsync(
+            await storageService.RemoveFileAsync(
                 compensateContext.Log.DestinationBucket,
                 compensateContext.Log.DestinationKey,
                 compensateContext.CancellationToken);

backend/Core/Musify.Infrastructure/MassTransit/Activities/LifeCycle/LifeCycleActivities.cs

@@ -0,0 +1,97 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Domain.Abstractions;
+using Musify.Domain.Entities;
+using Musify.Infrastructure.MassTransit.Arguments;
+
+namespace Musify.Infrastructure.MassTransit.Activities.LifeCycle;
+
+/// <summary>Sets the life-cycle status of an entity (removing, failed, ...). A missing entity is skipped.</summary>
+internal abstract class MarkLifeCycleActivity<TEntity>(IDatabase database, ILogger logger)
+    : IExecuteActivity<MarkLifeCycleArguments>
+    where TEntity : class, IHasLifeCycle
+{
+    public async Task<ExecutionResult> Execute(ExecuteContext<MarkLifeCycleArguments> executeContext)
+    {
+        var arguments = executeContext.Arguments;
+        var entity = await database.Set<TEntity>()
+            .SingleOrDefaultAsync(e => e.Id == arguments.Id, executeContext.CancellationToken);
+
+        if (entity == null)
+        {
+            logger.LogInformation("{Entity} {Id} not found while marking it as {Status}, skipping", typeof(TEntity).Name, arguments.Id, arguments.Status);
+            return executeContext.Completed();
+        }
+
+        entity.LifeCycleStatus = arguments.Status;
+        await database.SaveChangesAsync(executeContext.CancellationToken);
+
+        logger.LogInformation("Marked {Entity} {Id} as {Status}", typeof(TEntity).Name, arguments.Id, arguments.Status);
+        return executeContext.Completed();
+    }
+}
+
+/// <summary>Deletes an entity row. A missing entity is skipped.</summary>
+internal abstract class DeleteEntityActivity<TEntity>(IDatabase database, ILogger logger)
+    : IExecuteActivity<DeleteEntityArguments>
+    where TEntity : class, IHasLifeCycle
+{
+    public async Task<ExecutionResult> Execute(ExecuteContext<DeleteEntityArguments> executeContext)
+    {
+        var id = executeContext.Arguments.Id;
+        var entity = await database.Set<TEntity>()
+            .SingleOrDefaultAsync(e => e.Id == id, executeContext.CancellationToken);
+
+        if (entity == null)
+        {
+            logger.LogInformation("{Entity} {Id} not found while deleting it, skipping", typeof(TEntity).Name, id);
+            return executeContext.Completed();
+        }
+
+        database.Set<TEntity>().Remove(entity);
+        await database.SaveChangesAsync(executeContext.CancellationToken);
+
+        logger.LogInformation("Deleted {Entity} {Id} from the database", typeof(TEntity).Name, id);
+        return executeContext.Completed();
+    }
+}
+
+// One concrete activity per entity keeps a separate queue for each of them:
+// the endpoint name is the kebab-cased class name.
+internal sealed class MarkTrackLifeCycleActivity(IDatabase database, ILogger<MarkTrackLifeCycleActivity> logger)
+    : MarkLifeCycleActivity<Track>(database, logger)
+{
+    public const string ExecuteEndpointName = "mark-track-life-cycle";
+}
+
+internal sealed class MarkPlayListLifeCycleActivity(IDatabase database, ILogger<MarkPlayListLifeCycleActivity> logger)
+    : MarkLifeCycleActivity<PlayList>(database, logger)
+{
+    public const string ExecuteEndpointName = "mark-play-list-life-cycle";
+}
+
+internal sealed class MarkAlbumLifeCycleActivity(IDatabase database, ILogger<MarkAlbumLifeCycleActivity> logger)
+    : MarkLifeCycleActivity<Album>(database, logger)
+{
+    public const string ExecuteEndpointName = "mark-album-life-cycle";
+}
+
+internal sealed class DeleteTrackActivity(IDatabase database, ILogger<DeleteTrackActivity> logger)
+    : DeleteEntityActivity<Track>(database, logger)
+{
+    public const string ExecuteEndpointName = "delete-track";
+}
+
+internal sealed class DeletePlayListActivity(IDatabase database, ILogger<DeletePlayListActivity> logger)
+    : DeleteEntityActivity<PlayList>(database, logger)
+{
+    public const string ExecuteEndpointName = "delete-play-list";
+}
+
+internal sealed class DeleteAlbumActivity(IDatabase database, ILogger<DeleteAlbumActivity> logger)
+    : DeleteEntityActivity<Album>(database, logger)
+{
+    public const string ExecuteEndpointName = "delete-album";
+}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/GeneratePictureWorkflowPathsActivity.cs

@@ -1,6 +1,7 @@
 using MassTransit;
 using Microsoft.Extensions.Logging;
 using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.RoutingSlip;
 
 namespace Musify.Infrastructure.MassTransit.Activities.Pictures;
 
@@ -12,39 +13,27 @@ internal class GeneratePictureWorkflowPathsActivity(
 
     internal const string ResizedPictureFileExtension = ".webp";
 
-    public async Task<ExecutionResult> Execute(ExecuteContext<GeneratePictureWorkflowPathsArguments> executeContext)
+    public 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 Task.FromResult(executeContext.CompletedWithVariables(new Dictionary<string, object>
         {
-            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;
-        }
+            [RoutingSlipVariableNames.Workflow.TemporalDirectory] = workingDirectory,
+            [RoutingSlipVariableNames.Picture.OriginalFilePath] = sourceFilePath,
+            [RoutingSlipVariableNames.Picture.SmallResizedFilePath] = smallPictureFilePath,
+            [RoutingSlipVariableNames.Picture.MediumResizedFilePath] = mediumPictureFilePath,
+            [RoutingSlipVariableNames.Picture.LargeResizedFilePath] = largePictureFilePath
+        }));
     }
 }

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/ResizePictureActivity.cs

@@ -16,9 +16,9 @@ internal class ResizePictureActivity(
     public async Task<ExecutionResult> Execute(ExecuteContext<ResizePictureLocalArguments> executeContext)
     {
         var sourceFilePath = executeContext.GetVariable<string>(executeContext.Arguments.SourceFilePathVariable);
-        ArgumentNullException.ThrowIfNull(sourceFilePath, nameof(sourceFilePath));
+        ArgumentNullException.ThrowIfNull(sourceFilePath);
         var destinationFilePath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
-        ArgumentNullException.ThrowIfNull(destinationFilePath, nameof(destinationFilePath));
+        ArgumentNullException.ThrowIfNull(destinationFilePath);
 
         try
         {

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdateAlbumPictureActivity.cs

@@ -1,110 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-using Musify.Infrastructure.MassTransit.Logs;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Pictures;
-
-internal class UpdateAlbumPictureActivity(
-    IDatabase database,
-    IPublishEndpoint publishEndpoint,
-    ILogger<UpdateAlbumPictureActivity> logger)
-    : IActivity<UpdateAlbumPictureArguments, UpdateAlbumPictureLog>
-{
-    public const string ExecuteEndpointName = "update-album-picture";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<UpdateAlbumPictureArguments> 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 album = await database.Albums.FindAsync(
-                [executeContext.Arguments.AlbumId],
-                cancellationToken: executeContext.CancellationToken);
-
-            if (album == null)
-            {
-                logger.LogWarning("Album {AlbumId} not found",
-                    executeContext.Arguments.AlbumId);
-                throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} not found");
-            }
-
-            if (album.Pictures == null)
-            {
-                logger.LogWarning("Album {AlbumId} has no pending picture upload",
-                    executeContext.Arguments.AlbumId);
-                throw new InvalidOperationException($"Album with id {executeContext.Arguments.AlbumId} has no pending picture upload");
-            }
-
-            var log = new UpdateAlbumPictureLog(
-                album.Id,
-                album.Pictures.OriginalName,
-                album.Pictures.SmallName,
-                album.Pictures.MediumName,
-                album.Pictures.LargeName);
-
-            album.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
-            album.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
-            album.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
-            album.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
-
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-
-            logger.LogInformation("Updated album {AlbumId} pictures",
-                executeContext.Arguments.AlbumId);
-
-            await publishEndpoint.Publish(
-                new AlbumPictureProcessed(executeContext.Arguments.AlbumId),
-                executeContext.CancellationToken);
-
-            return executeContext.Completed();
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to update album {AlbumId} pictures",
-                executeContext.Arguments.AlbumId);
-            throw;
-        }
-    }
-
-    public async Task<CompensationResult> Compensate(CompensateContext<UpdateAlbumPictureLog> compensateContext)
-    {
-        try
-        {
-            var album = await database.Albums.FindAsync(
-                [compensateContext.Log.AlbumId],
-                cancellationToken: compensateContext.CancellationToken);
-
-            if (album == null)
-            {
-                return compensateContext.Compensated();
-            }
-
-            album.Pictures = new EntityPictures
-            {
-                OriginalName = compensateContext.Log.PreviousOriginalPictureKey,
-                SmallName = compensateContext.Log.PreviousSmallPictureKey,
-                MediumName = compensateContext.Log.PreviousMediumPictureKey,
-                LargeName = compensateContext.Log.PreviousLargePictureKey
-            };
-
-            await database.SaveChangesAsync(compensateContext.CancellationToken);
-
-            return compensateContext.Compensated();
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to compensate album {AlbumId} pictures", compensateContext.Log.AlbumId);
-            return compensateContext.Failed(exception);
-        }
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdatePicturesActivity.cs

@@ -0,0 +1,160 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts;
+using Musify.Application.Events;
+using Musify.Domain.Entities;
+using Musify.Domain.ValueObjects;
+using Musify.Infrastructure.MassTransit.Arguments;
+using Musify.Infrastructure.MassTransit.Logs;
+
+namespace Musify.Infrastructure.MassTransit.Activities.Pictures;
+
+internal sealed record PictureNames(string? Original, string? Small, string? Medium, string? Large);
+
+/// <summary>Stores the processed picture names on the owner and reports it; compensation restores the previous names.</summary>
+internal abstract class UpdatePicturesActivity<TEntity>(
+    IDatabase database,
+    IPublishEndpoint publishEndpoint,
+    ILogger logger)
+    : IActivity<UpdatePicturesArguments, UpdatePicturesLog>
+    where TEntity : class
+{
+    protected IDatabase Database { get; } = database;
+
+    protected abstract Task<TEntity?> FindAsync(Guid id, CancellationToken cancellationToken);
+
+    /// <summary>Reads the current names; throws when the entity has no pending picture.</summary>
+    protected abstract PictureNames Read(TEntity entity);
+
+    protected abstract void Write(TEntity entity, PictureNames names, bool succeeded);
+
+    protected abstract object ProcessedEvent(Guid id);
+
+    public async Task<ExecutionResult> Execute(ExecuteContext<UpdatePicturesArguments> executeContext)
+    {
+        var arguments = executeContext.Arguments;
+        var small = RequireVariable(executeContext, arguments.SmallPictureVariable);
+        var medium = RequireVariable(executeContext, arguments.MediumPictureVariable);
+        var large = RequireVariable(executeContext, arguments.LargePictureVariable);
+
+        var entity = await FindAsync(arguments.SubjectId, executeContext.CancellationToken)
+            ?? throw new InvalidOperationException($"{typeof(TEntity).Name} {arguments.SubjectId} not found");
+
+        var previous = Read(entity);
+        Write(
+            entity,
+            new PictureNames(
+                Path.GetFileName(arguments.OriginalPictureKey),
+                Path.GetFileName(small),
+                Path.GetFileName(medium),
+                Path.GetFileName(large)),
+            succeeded: true);
+        await Database.SaveChangesAsync(executeContext.CancellationToken);
+
+        logger.LogInformation("Updated {Entity} {Id} pictures", typeof(TEntity).Name, arguments.SubjectId);
+
+        await publishEndpoint.Publish(ProcessedEvent(arguments.SubjectId), executeContext.CancellationToken);
+
+        return executeContext.Completed(new UpdatePicturesLog(
+            arguments.SubjectId, previous.Original, previous.Small, previous.Medium, previous.Large));
+    }
+
+    public async Task<CompensationResult> Compensate(CompensateContext<UpdatePicturesLog> compensateContext)
+    {
+        var log = compensateContext.Log;
+
+        try
+        {
+            var entity = await FindAsync(log.SubjectId, compensateContext.CancellationToken);
+            if (entity == null)
+                return compensateContext.Compensated();
+
+            var previous = new PictureNames(log.PreviousOriginalName, log.PreviousSmallName, log.PreviousMediumName, log.PreviousLargeName);
+            Write(entity, previous, succeeded: false);
+            await Database.SaveChangesAsync(compensateContext.CancellationToken);
+
+            return compensateContext.Compensated();
+        }
+        catch (Exception exception)
+        {
+            logger.LogError(exception, "Failed to compensate {Entity} {Id} pictures", typeof(TEntity).Name, log.SubjectId);
+            return compensateContext.Failed(exception);
+        }
+    }
+
+    protected static PictureNames ReadPictures(EntityPictures? pictures) =>
+        pictures == null
+            ? throw new InvalidOperationException("The entity has no pending picture upload")
+            : new PictureNames(pictures.OriginalName, pictures.SmallName, pictures.MediumName, pictures.LargeName);
+
+    protected static void WritePictures(EntityPictures? pictures, PictureNames names)
+    {
+        if (pictures == null)
+            return;
+
+        pictures.OriginalName = names.Original ?? pictures.OriginalName;
+        pictures.SmallName = names.Small;
+        pictures.MediumName = names.Medium;
+        pictures.LargeName = names.Large;
+    }
+
+    private static string RequireVariable(ExecuteContext<UpdatePicturesArguments> executeContext, string variableName) =>
+        executeContext.GetVariable<string>(variableName)
+            ?? throw new InvalidOperationException($"Missing routing slip variable {variableName}");
+}
+
+internal sealed class UpdateTrackPictureActivity(IDatabase database, IPublishEndpoint publishEndpoint, ILogger<UpdateTrackPictureActivity> logger)
+    : UpdatePicturesActivity<Track>(database, publishEndpoint, logger)
+{
+    public const string ExecuteEndpointName = "update-track-picture";
+
+    protected override Task<Track?> FindAsync(Guid id, CancellationToken cancellationToken) =>
+        Database.Tracks.SingleOrDefaultAsync(track => track.Id == id, cancellationToken);
+
+    protected override PictureNames Read(Track track) =>
+        new(track.Pictures.OriginalName, track.Pictures.SmallName, track.Pictures.MediumName, track.Pictures.LargeName);
+
+    protected override void Write(Track track, PictureNames names, bool succeeded)
+    {
+        track.Pictures.OriginalName = names.Original;
+        track.Pictures.SmallName = names.Small;
+        track.Pictures.MediumName = names.Medium;
+        track.Pictures.LargeName = names.Large;
+        track.Pictures.ProcessingStatus = succeeded ? ProcessingStatus.Completed : ProcessingStatus.Failed;
+    }
+
+    protected override object ProcessedEvent(Guid id) => new TrackPictureProcessed(id);
+}
+
+internal sealed class UpdatePlayListPictureActivity(IDatabase database, IPublishEndpoint publishEndpoint, ILogger<UpdatePlayListPictureActivity> logger)
+    : UpdatePicturesActivity<PlayList>(database, publishEndpoint, logger)
+{
+    public const string ExecuteEndpointName = "update-play-list-picture";
+
+    protected override Task<PlayList?> FindAsync(Guid id, CancellationToken cancellationToken) =>
+        Database.PlayLists.SingleOrDefaultAsync(playList => playList.Id == id, cancellationToken);
+
+    protected override PictureNames Read(PlayList playList) => ReadPictures(playList.Pictures);
+
+    protected override void Write(PlayList playList, PictureNames names, bool succeeded) =>
+        WritePictures(playList.Pictures, names);
+
+    protected override object ProcessedEvent(Guid id) => new PlayListPictureProcessed(id);
+}
+
+internal sealed class UpdateAlbumPictureActivity(IDatabase database, IPublishEndpoint publishEndpoint, ILogger<UpdateAlbumPictureActivity> logger)
+    : UpdatePicturesActivity<Album>(database, publishEndpoint, logger)
+{
+    public const string ExecuteEndpointName = "update-album-picture";
+
+    protected override Task<Album?> FindAsync(Guid id, CancellationToken cancellationToken) =>
+        Database.Albums.SingleOrDefaultAsync(album => album.Id == id, cancellationToken);
+
+    protected override PictureNames Read(Album album) => ReadPictures(album.Pictures);
+
+    protected override void Write(Album album, PictureNames names, bool succeeded) =>
+        WritePictures(album.Pictures, names);
+
+    protected override object ProcessedEvent(Guid id) => new AlbumPictureProcessed(id);
+}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdatePlayListPictureActivity.cs

@@ -1,110 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-using Musify.Infrastructure.MassTransit.Logs;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Pictures;
-
-internal class UpdatePlayListPictureActivity(
-    IDatabase database,
-    IPublishEndpoint publishEndpoint,
-    ILogger<UpdatePlayListPictureActivity> logger)
-    : IActivity<UpdatePlayListPictureArguments, UpdatePlayListPictureLog>
-{
-    public const string ExecuteEndpointName = "update-play-list-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 == null)
-            {
-                logger.LogWarning("Playlist {PlayListId} not found",
-                    executeContext.Arguments.PlayListId);
-                throw new InvalidOperationException($"PlayList with id {executeContext.Arguments.PlayListId} not found");
-            }
-
-            if (playList.Pictures == null)
-            {
-                logger.LogWarning("Playlist {PlayListId} has no pending picture upload",
-                    executeContext.Arguments.PlayListId);
-                throw new InvalidOperationException($"PlayList with id {executeContext.Arguments.PlayListId} has no pending picture upload");
-            }
-
-            var log = new UpdatePlayListPictureLog(
-                playList.Id,
-                playList.Pictures.OriginalName,
-                playList.Pictures.SmallName,
-                playList.Pictures.MediumName,
-                playList.Pictures.LargeName);
-
-            playList.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
-            playList.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
-            playList.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
-            playList.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
-
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-
-            logger.LogInformation("Updated playlist {PlayListId} pictures",
-                executeContext.Arguments.PlayListId);
-
-            await publishEndpoint.Publish(
-                new PlayListPictureProcessed(executeContext.Arguments.PlayListId),
-                executeContext.CancellationToken);
-
-            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 == null)
-            {
-                return compensateContext.Compensated();
-            }
-
-            playList.Pictures = new EntityPictures
-            {
-                OriginalName = compensateContext.Log.PreviousOriginalPictureKey,
-                SmallName = compensateContext.Log.PreviousSmallPictureKey,
-                MediumName = compensateContext.Log.PreviousMediumPictureKey,
-                LargeName = compensateContext.Log.PreviousLargePictureKey
-            };
-
-            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);
-        }
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Pictures/UpdateTrackPictureActivity.cs

@@ -1,100 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Application.Events;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-using Musify.Infrastructure.MassTransit.Logs;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Pictures;
-
-internal class UpdateTrackPictureActivity(
-    IDatabase database,
-    IPublishEndpoint publishEndpoint,
-    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 == 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.Pictures.OriginalName,
-                track.Pictures.SmallName,
-                track.Pictures.MediumName,
-                track.Pictures.LargeName);
-
-            track.Pictures.OriginalName = Path.GetFileName(executeContext.Arguments.OriginalPictureKey);
-            track.Pictures.SmallName = Path.GetFileName(smallResizedVariable);
-            track.Pictures.MediumName = Path.GetFileName(mediumResizedVariable);
-            track.Pictures.LargeName = Path.GetFileName(largeResizedVariable);
-            track.Pictures.ProcessingStatus = ProcessingStatus.Completed;
-
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-
-            logger.LogInformation("Updated track {TrackId} pictures",
-                executeContext.Arguments.TrackId);
-
-            await publishEndpoint.Publish(
-                new TrackPictureProcessed(executeContext.Arguments.TrackId),
-                executeContext.CancellationToken);
-
-            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 == null)
-                return compensateContext.Compensated();
-
-            track.Pictures.OriginalName = compensateContext.Log.PreviousOriginalPictureKey;
-            track.Pictures.SmallName = compensateContext.Log.PreviousSmallPictureKey;
-            track.Pictures.MediumName = compensateContext.Log.PreviousMediumPictureKey;
-            track.Pictures.LargeName = compensateContext.Log.PreviousLargePictureKey;
-            track.Pictures.ProcessingStatus = ProcessingStatus.Failed;
-
-            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);
-        }
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/PlayLists/DeletePlayListFromDbActivity.cs

@@ -1,35 +0,0 @@
-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-play-list-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 == 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();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/PlayLists/MarkPlayListAsFailedActivity.cs

@@ -1,31 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.PlayLists;
-
-internal class MarkPlayListAsFailedActivity(
-    IDatabase database,
-    ILogger<MarkPlayListAsFailedActivity> logger)
-    : IExecuteActivity<MarkPlayListAsFailedArguments>
-{
-    public const string ExecuteEndpointName = "mark-play-list-as-failed";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<MarkPlayListAsFailedArguments> executeContext)
-    {
-        var playList = await database.PlayLists
-            .SingleOrDefaultAsync(p => p.Id == executeContext.Arguments.PlayListId, executeContext.CancellationToken);
-
-        if (playList != null)
-        {
-            playList.LifeCycleStatus = LifeCycleStatus.Failed;
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-            logger.LogInformation("Marked playlist {PlayListId} as failed", executeContext.Arguments.PlayListId);
-        }
-
-        return executeContext.Completed();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/PlayLists/MarkPlayListAsRemovingActivity.cs

@@ -1,36 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.PlayLists;
-
-internal class MarkPlayListAsRemovingActivity(
-    IDatabase database,
-    ILogger<MarkPlayListAsRemovingActivity> logger)
-    : IExecuteActivity<MarkPlayListAsRemovingArguments>
-{
-    public const string ExecuteEndpointName = "mark-play-list-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 == 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();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Tracks/DeleteTrackFromDbActivity.cs

@@ -1,35 +0,0 @@
-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 == 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();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Tracks/MarkTrackAsFailedActivity.cs

@@ -1,31 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Tracks;
-
-internal class MarkTrackAsFailedActivity(
-    IDatabase database,
-    ILogger<MarkTrackAsFailedActivity> logger)
-    : IExecuteActivity<MarkTrackAsFailedArguments>
-{
-    public const string ExecuteEndpointName = "mark-track-as-failed";
-
-    public async Task<ExecutionResult> Execute(ExecuteContext<MarkTrackAsFailedArguments> executeContext)
-    {
-        var track = await database.Tracks
-            .SingleOrDefaultAsync(t => t.Id == executeContext.Arguments.TrackId, executeContext.CancellationToken);
-
-        if (track != null)
-        {
-            track.LifeCycleStatus = LifeCycleStatus.Failed;
-            await database.SaveChangesAsync(executeContext.CancellationToken);
-            logger.LogInformation("Marked track {TrackId} as failed", executeContext.Arguments.TrackId);
-        }
-
-        return executeContext.Completed();
-    }
-}

backend/Core/Musify.Infrastructure/MassTransit/Activities/Tracks/MarkTrackAsRemovingActivity.cs

@@ -1,36 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
-
-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 == 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();
-    }
-}