Update delete workflows

Infrastructure/MassTransit/Activities/Files/RemoveFileFromBucketActivity.cs

@@ -1,7 +1,9 @@
 using MassTransit;
+using Amazon.S3;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Abstractions.Infrastructure;
 using Musify.Infrastructure.MassTransit.Activities.Arguments;
+using System.Net;
 
 namespace Musify.Infrastructure.MassTransit.Activities.Files
 {
@@ -22,6 +24,16 @@ namespace Musify.Infrastructure.MassTransit.Activities.Files
                     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}",

Infrastructure/MassTransit/Activities/PlayLists/DeletePlayListFromDbActivity.cs

@@ -0,0 +1,35 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Abstractions.Infrastructure;
+
+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();
+        }
+    }
+}

Infrastructure/MassTransit/Activities/PlayLists/DeletePlayListFromDbArguments.cs

@@ -0,0 +1,5 @@
+namespace Musify.Infrastructure.MassTransit.Activities.PlayLists
+{
+    internal record DeletePlayListFromDbArguments(
+        Guid PlayListId);
+}

Infrastructure/MassTransit/Activities/PlayLists/MarkPlayListAsRemovingActivity.cs

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

Infrastructure/MassTransit/Activities/PlayLists/MarkPlayListAsRemovingArguments.cs

@@ -0,0 +1,5 @@
+namespace Musify.Infrastructure.MassTransit.Activities.PlayLists
+{
+    internal record MarkPlayListAsRemovingArguments(
+        Guid PlayListId);
+}

Infrastructure/MassTransit/Activities/Tracks/DeleteTrackActivity.cs

@@ -1,115 +0,0 @@
-using MassTransit;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Configuration;
-using Musify.Application.Abstractions.Infrastructure;
-using Musify.Domain.Entities;
-
-namespace Musify.Infrastructure.MassTransit.Activities.Tracks
-{
-    internal class DeleteTrackActivity(
-        IDatabase database,
-        IStorageService storageService,
-        TrackConfiguration trackConfiguration,
-        ApplicationStorageConfiguration storageConfiguration,
-        ILogger<DeleteTrackActivity> logger)
-        : IExecuteActivity<DeleteTrackArguments>
-    {
-        public const string ExecuteEndpointName = "delete-track";
-
-        public async Task<ExecutionResult> Execute(ExecuteContext<DeleteTrackArguments> 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} for deletion", executeContext.Arguments.TrackId);
-                throw;
-            }
-
-            try
-            {
-                await RemovePicturesAsync(track, executeContext.Arguments.UserId, executeContext.CancellationToken);
-                track.PicturesProcessingStatus = ProcessingStatus.Completed;
-                await database.SaveChangesAsync(executeContext.CancellationToken);
-
-                await RemoveAudiosAsync(track, executeContext.Arguments.UserId, executeContext.CancellationToken);
-                track.AudioTranscodeProcessingStatus = ProcessingStatus.Completed;
-                await database.SaveChangesAsync(executeContext.CancellationToken);
-
-                database.Tracks.Remove(track);
-                await database.SaveChangesAsync(executeContext.CancellationToken);
-
-                logger.LogInformation("Deleted track {TrackId}", track.Id);
-                return executeContext.Completed();
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to delete track {TrackId}", executeContext.Arguments.TrackId);
-
-                try
-                {
-                    track.PicturesProcessingStatus = ProcessingStatus.Failed;
-                    track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
-                    await database.SaveChangesAsync(executeContext.CancellationToken);
-                }
-                catch (Exception dbException)
-                {
-                    logger.LogError(dbException, "Failed to update processing statuses to Failed for track {TrackId}", executeContext.Arguments.TrackId);
-                }
-
-                throw;
-            }
-        }
-
-        async Task RemovePicturesAsync(Track track, Guid userId, CancellationToken cancellationToken)
-        {
-            await RemoveFileAsync(trackConfiguration.Routes.BuildOriginalPicturePath(userId, track.OriginalPictureName), cancellationToken);
-
-            if (!track.IsPicturesProcessed)
-            {
-                logger.LogInformation(
-                    "Track {TrackId} pictures are not fully processed, skipping removal of small, medium, and large pictures",
-                    track.Id);
-                return;
-            }
-
-            await RemoveFileAsync(trackConfiguration.Routes.BuildSmallPicturePath(track.SmallPictureName), cancellationToken);
-            await RemoveFileAsync(trackConfiguration.Routes.BuildMediumPicturePath(track.MediumPictureName), cancellationToken);
-            await RemoveFileAsync(trackConfiguration.Routes.BuildLargePicturePath(track.LargePictureName), cancellationToken);
-        }
-
-        async Task RemoveAudiosAsync(Track track, Guid userId, CancellationToken cancellationToken)
-        {
-            await RemoveFileAsync(trackConfiguration.Routes.BuildOriginalAudioPath(userId, track.OriginalAudioName), cancellationToken);
-
-            if (!track.IsAudioProcessed)
-            {
-                logger.LogInformation(
-                    "Track {TrackId} audio is not fully processed, skipping removal of processed audio",
-                    track.Id);
-                return;
-            }
-
-            await RemoveFileAsync(trackConfiguration.Routes.BuildProcessedAudioPath(track.AudioFolderName), cancellationToken);
-        }
-
-        async Task RemoveFileAsync(string key, CancellationToken cancellationToken)
-        {
-            try
-            {
-                logger.LogDebug("Removing file {Key} from bucket {Bucket}", key, storageConfiguration.Bucket);
-                await storageService.RemoveFileAsync(storageConfiguration.Bucket, key, cancellationToken);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(exception, "Failed to remove file {Key} from bucket {Bucket}", key, storageConfiguration.Bucket);
-                throw;
-            }
-        }
-    }
-}

Infrastructure/MassTransit/Activities/Tracks/DeleteTrackArguments.cs

@@ -1,6 +0,0 @@
-namespace Musify.Infrastructure.MassTransit.Activities.Tracks
-{
-    internal record DeleteTrackArguments(
-        Guid TrackId,
-        Guid UserId);
-}

Infrastructure/MassTransit/Activities/Tracks/DeleteTrackFromDbActivity.cs

@@ -0,0 +1,35 @@
+using MassTransit;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Abstractions.Infrastructure;
+
+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();
+        }
+    }
+}

Infrastructure/MassTransit/Activities/Tracks/DeleteTrackFromDbArguments.cs

@@ -0,0 +1,5 @@
+namespace Musify.Infrastructure.MassTransit.Activities.Tracks
+{
+    internal record DeleteTrackFromDbArguments(
+        Guid TrackId);
+}

Infrastructure/MassTransit/Activities/Tracks/MarkTrackAsRemovingActivity.cs

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

Infrastructure/MassTransit/Activities/Tracks/MarkTrackAsRemovingArguments.cs

@@ -0,0 +1,5 @@
+namespace Musify.Infrastructure.MassTransit.Activities.Tracks
+{
+    internal record MarkTrackAsRemovingArguments(
+        Guid TrackId);
+}

Infrastructure/MassTransit/Consumers/DeletePlayListConsumer.cs

@@ -0,0 +1,27 @@
+using MassTransit;
+using Musify.Application.Events;
+using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
+
+namespace Musify.Infrastructure.MassTransit.Consumers
+{
+    public class DeletePlayListConsumer(
+        IBus bus,
+        DeletePlayListRoutingSlipBuilder routingSlipBuilder)
+        : IConsumer<DeletePlayListEvent>
+    {
+        public const string QueueName = "delete-playList";
+
+        public async Task Consume(ConsumeContext<DeletePlayListEvent> consumeContext)
+        {
+            var routingSlip = (await routingSlipBuilder
+                    .BuildAsync(
+                        consumeContext.Message.PlayListId,
+                        consumeContext.Message.UserId,
+                        consumeContext.CorrelationId,
+                        consumeContext.CancellationToken))
+                .Build();
+
+            await bus.Execute(routingSlip);
+        }
+    }
+}

Infrastructure/MassTransit/Consumers/DeleteTrackConsumer.cs

@@ -13,8 +13,8 @@ namespace Musify.Infrastructure.MassTransit.Consumers
 
         public async Task Consume(ConsumeContext<DeleteTrackEvent> consumeContext)
         {
-            var routingSlip = routingSlipBuilder
-                .Build(consumeContext.Message.TrackId, consumeContext.Message.UserId, consumeContext.CorrelationId)
+            var routingSlip = (await routingSlipBuilder
+                    .BuildAsync(consumeContext.Message.TrackId, consumeContext.Message.UserId, consumeContext.CorrelationId, consumeContext.CancellationToken))
                 .Build();
 
             await bus.Execute(routingSlip);

Infrastructure/MassTransit/Consumers/RemoveFileConsumer.cs

@@ -1,40 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Abstractions.Infrastructure;
-using Musify.Application.Events;
-
-namespace Musify.Infrastructure.MassTransit.Consumers
-{
-    public class RemoveFileConsumer(
-        IStorageService storageService,
-        ILogger<RemoveFileConsumer> logger)
-        : IConsumer<RemoveFileEvent>
-    {
-        public const string QueueName = "remove-file";
-
-        public async Task Consume(ConsumeContext<RemoveFileEvent> consumeContext)
-        {
-            try
-            {
-                await storageService.RemoveFileAsync(
-                    consumeContext.Message.Bucket,
-                    consumeContext.Message.Key,
-                    consumeContext.CancellationToken);
-
-                logger.LogInformation(
-                    "Removed file {Key} from bucket {Bucket}",
-                    consumeContext.Message.Key,
-                    consumeContext.Message.Bucket);
-            }
-            catch (Exception exception)
-            {
-                logger.LogError(
-                    exception,
-                    "Failed to remove file {Key} from bucket {Bucket}",
-                    consumeContext.Message.Key,
-                    consumeContext.Message.Bucket);
-                throw;
-            }
-        }
-    }
-}

Infrastructure/MassTransit/DependencyInjection/MassTransitDependencyInjection.Registration.cs

@@ -6,6 +6,7 @@ using Musify.Infrastructure.MassTransit.Activities.Arguments;
 using Musify.Infrastructure.MassTransit.Activities.Audio;
 using Musify.Infrastructure.MassTransit.Activities.Files;
 using Musify.Infrastructure.MassTransit.Activities.Logs;
+using Musify.Infrastructure.MassTransit.Activities.PlayLists;
 using Musify.Infrastructure.MassTransit.Activities.Tracks;
 using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Consumers;
@@ -21,6 +22,7 @@ namespace Musify.Infrastructure.MassTransit
             services.AddScoped<AudioWorkflowRoutingSlipBuilder>();
             services.AddScoped<PictureWorkflowRoutingSlipBuilder>();
             services.AddScoped<DeleteTrackRoutingSlipBuilder>();
+            services.AddScoped<DeletePlayListRoutingSlipBuilder>();
         }
 
         static void RegisterConsumersAndActivities(IBusRegistrationConfigurator options)
@@ -30,12 +32,15 @@ namespace Musify.Infrastructure.MassTransit
             options.AddConsumer<RoutingSlipCleanUpConsumer>();
             options.AddConsumer<UpdateTrackAudioConsumer>();
             options.AddConsumer<DeleteTrackConsumer>();
-            options.AddConsumer<RemoveFileConsumer>();
+            options.AddConsumer<DeletePlayListConsumer>();
 
             options.AddExecuteActivity<RemoveFileFromBucketActivity, RemoveFileFromBucketArguments>();
             options.AddExecuteActivity<GenerateAudioWorkflowPathsActivity, GenerateAudioWorkflowPathsArguments>();
             options.AddExecuteActivity<GeneratePictureWorkflowPathsActivity, GeneratePictureWorkflowPathsArguments>();
-            options.AddExecuteActivity<DeleteTrackActivity, DeleteTrackArguments>();
+            options.AddExecuteActivity<MarkTrackAsRemovingActivity, MarkTrackAsRemovingArguments>();
+            options.AddExecuteActivity<DeleteTrackFromDbActivity, DeleteTrackFromDbArguments>();
+            options.AddExecuteActivity<MarkPlayListAsRemovingActivity, MarkPlayListAsRemovingArguments>();
+            options.AddExecuteActivity<DeletePlayListFromDbActivity, DeletePlayListFromDbArguments>();
 
             options.AddActivity<ResizePictureActivity, ResizePictureLocalArguments, ResizePictureLog>();
             options.AddActivity<UpdatePlayListPictureActivity, UpdatePlayListPictureArguments, UpdatePlayListPictureLog>();
@@ -75,10 +80,10 @@ namespace Musify.Infrastructure.MassTransit
                 busRegistrationContext,
                 DeleteTrackConsumer.QueueName);
 
-            ConfigureConsumerEndpoint<RemoveFileConsumer>(
+            ConfigureConsumerEndpoint<DeletePlayListConsumer>(
                 busFactoryConfigurator,
                 busRegistrationContext,
-                RemoveFileConsumer.QueueName);
+                DeletePlayListConsumer.QueueName);
 
             ConfigureConsumerEndpoint<RoutingSlipCleanUpConsumer>(
                 busFactoryConfigurator,
@@ -100,6 +105,26 @@ namespace Musify.Infrastructure.MassTransit
                 busRegistrationContext,
                 GeneratePictureWorkflowPathsActivity.ExecuteEndpointName);
 
+            ConfigureExecuteActivityEndpoint<MarkTrackAsRemovingActivity, MarkTrackAsRemovingArguments>(
+                busFactoryConfigurator,
+                busRegistrationContext,
+                MarkTrackAsRemovingActivity.ExecuteEndpointName);
+
+            ConfigureExecuteActivityEndpoint<DeleteTrackFromDbActivity, DeleteTrackFromDbArguments>(
+                busFactoryConfigurator,
+                busRegistrationContext,
+                DeleteTrackFromDbActivity.ExecuteEndpointName);
+
+            ConfigureExecuteActivityEndpoint<MarkPlayListAsRemovingActivity, MarkPlayListAsRemovingArguments>(
+                busFactoryConfigurator,
+                busRegistrationContext,
+                MarkPlayListAsRemovingActivity.ExecuteEndpointName);
+
+            ConfigureExecuteActivityEndpoint<DeletePlayListFromDbActivity, DeletePlayListFromDbArguments>(
+                busFactoryConfigurator,
+                busRegistrationContext,
+                DeletePlayListFromDbActivity.ExecuteEndpointName);
+
             ConfigureActivityEndpoint<ResizePictureActivity, ResizePictureLocalArguments, ResizePictureLog>(
                 busFactoryConfigurator,
                 busRegistrationContext,

Infrastructure/MassTransit/RoutingSlip/ActivityNames.cs

@@ -3,6 +3,10 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip
     internal static class ActivityNames
     {
         internal const string DeleteTrack = "DeleteTrack";
+        internal const string MarkTrackAsRemoving = "MarkTrackAsRemoving";
+        internal const string DeleteTrackFromDb = "DeleteTrackFromDb";
+        internal const string MarkPlayListAsRemoving = "MarkPlayListAsRemoving";
+        internal const string DeletePlayListFromDb = "DeletePlayListFromDb";
         internal const string GenerateAudioWorkflowPaths = "GenerateAudioWorkflowPaths";
         internal const string GeneratePictureWorkflowPaths = "GeneratePictureWorkflowPaths";
         internal const string DownloadFile = "DownloadFile";

Infrastructure/MassTransit/RoutingSlip/Builders/DeletePlayListRoutingSlipBuilder.cs

@@ -0,0 +1,94 @@
+using MassTransit;
+using MassTransit.Courier.Contracts;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Abstractions.Infrastructure;
+using Musify.Application.Configuration;
+using Musify.Infrastructure.MassTransit.Activities.Files;
+using Musify.Infrastructure.MassTransit.Activities.Arguments;
+using Musify.Infrastructure.MassTransit.Activities.PlayLists;
+using Musify.Infrastructure.MassTransit.Consumers;
+
+namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
+{
+    public class DeletePlayListRoutingSlipBuilder(
+        IDatabase database,
+        PlayListConfiguration playListConfiguration,
+        ApplicationStorageConfiguration storageConfiguration)
+    {
+        public async Task<RoutingSlipBuilder> BuildAsync(
+            Guid playListId,
+            Guid userId,
+            Guid? correlationId,
+            CancellationToken cancellationToken)
+        {
+            var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
+            routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.CorrelationId, correlationId ?? Guid.Empty);
+
+            routingSlipBuilder.AddSubscription(
+                EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
+                RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
+
+            var playList = await database.PlayLists
+                .AsNoTracking()
+                .SingleOrDefaultAsync(p => p.Id == playListId, cancellationToken);
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.MarkPlayListAsRemoving,
+                EndpointHelper.BuildExecuteActivityUri(MarkPlayListAsRemovingActivity.ExecuteEndpointName),
+                new MarkPlayListAsRemovingArguments(playListId));
+
+            if (playList is not null)
+            {
+                var bucket = storageConfiguration.Bucket;
+                var routes = playListConfiguration.Routes;
+
+                if (playList.OriginalPictureName != routes.PresetOriginalPicture)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemovePlayListOriginalPicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            routes.BuildOriginalPicturePath(userId, playList.OriginalPictureName)));
+                }
+
+                if (playList.SmallPictureName != routes.PresetSmallPicture)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemovePlayListSmallPicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            routes.BuildSmallPicturePath(playList.SmallPictureName)));
+                }
+
+                if (playList.MediumPictureName != routes.PresetMediumPicture)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemovePlayListMediumPicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            routes.BuildMediumPicturePath(playList.MediumPictureName)));
+                }
+
+                if (playList.LargePictureName != routes.PresetLargePicture)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemovePlayListLargePicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            routes.BuildLargePicturePath(playList.LargePictureName)));
+                }
+            }
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.DeletePlayListFromDb,
+                EndpointHelper.BuildExecuteActivityUri(DeletePlayListFromDbActivity.ExecuteEndpointName),
+                new DeletePlayListFromDbArguments(playListId));
+
+            return routingSlipBuilder;
+        }
+    }
+}

Infrastructure/MassTransit/RoutingSlip/Builders/DeleteTrackRoutingSlipBuilder.cs

@@ -1,13 +1,25 @@
 using MassTransit;
 using MassTransit.Courier.Contracts;
+using Microsoft.EntityFrameworkCore;
+using Musify.Application.Abstractions.Infrastructure;
+using Musify.Application.Configuration;
+using Musify.Infrastructure.MassTransit.Activities.Files;
+using Musify.Infrastructure.MassTransit.Activities.Arguments;
 using Musify.Infrastructure.MassTransit.Activities.Tracks;
 using Musify.Infrastructure.MassTransit.Consumers;
 
 namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
 {
-    public class DeleteTrackRoutingSlipBuilder
+    public class DeleteTrackRoutingSlipBuilder(
+        IDatabase database,
+        TrackConfiguration trackConfiguration,
+        ApplicationStorageConfiguration storageConfiguration)
     {
-        public RoutingSlipBuilder Build(Guid trackId, Guid userId, Guid? correlationId)
+        public async Task<RoutingSlipBuilder> BuildAsync(
+            Guid trackId,
+            Guid userId,
+            Guid? correlationId,
+            CancellationToken cancellationToken)
         {
             var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
             routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.CorrelationId, correlationId ?? Guid.Empty);
@@ -16,10 +28,72 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
                 EndpointHelper.BuildConsumerUri(RoutingSlipCleanUpConsumer.QueueName),
                 RoutingSlipEvents.Completed | RoutingSlipEvents.Faulted);
 
+            var track = await database.Tracks
+                .AsNoTracking()
+                .SingleOrDefaultAsync(t => t.Id == trackId, cancellationToken);
+
             routingSlipBuilder.AddActivity(
-                ActivityNames.DeleteTrack,
-                EndpointHelper.BuildExecuteActivityUri(DeleteTrackActivity.ExecuteEndpointName),
-                new DeleteTrackArguments(trackId, userId));
+                ActivityNames.MarkTrackAsRemoving,
+                EndpointHelper.BuildExecuteActivityUri(MarkTrackAsRemovingActivity.ExecuteEndpointName),
+                new MarkTrackAsRemovingArguments(trackId));
+
+            if (track is not null)
+            {
+                var bucket = storageConfiguration.Bucket;
+
+                routingSlipBuilder.AddActivity(
+                    "RemoveTrackOriginalPicture",
+                    EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                    new RemoveFileFromBucketArguments(
+                        bucket,
+                        trackConfiguration.Routes.BuildOriginalPicturePath(userId, track.OriginalPictureName)));
+
+                if (track.IsPicturesProcessed)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemoveTrackSmallPicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            trackConfiguration.Routes.BuildSmallPicturePath(track.SmallPictureName)));
+
+                    routingSlipBuilder.AddActivity(
+                        "RemoveTrackMediumPicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            trackConfiguration.Routes.BuildMediumPicturePath(track.MediumPictureName)));
+
+                    routingSlipBuilder.AddActivity(
+                        "RemoveTrackLargePicture",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            trackConfiguration.Routes.BuildLargePicturePath(track.LargePictureName)));
+                }
+
+                routingSlipBuilder.AddActivity(
+                    "RemoveTrackOriginalAudio",
+                    EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                    new RemoveFileFromBucketArguments(
+                        bucket,
+                        trackConfiguration.Routes.BuildOriginalAudioPath(userId, track.OriginalAudioName)));
+
+                if (track.IsAudioProcessed)
+                {
+                    routingSlipBuilder.AddActivity(
+                        "RemoveTrackProcessedAudio",
+                        EndpointHelper.BuildExecuteActivityUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                        new RemoveFileFromBucketArguments(
+                            bucket,
+                            trackConfiguration.Routes.BuildProcessedAudioPath(track.AudioFolderName)));
+                }
+            }
+
+            routingSlipBuilder.AddActivity(
+                ActivityNames.DeleteTrackFromDb,
+                EndpointHelper.BuildExecuteActivityUri(DeleteTrackFromDbActivity.ExecuteEndpointName),
+                new DeleteTrackFromDbArguments(trackId));
 
             return routingSlipBuilder;
         }