Staged

Application/Configuration/TrackConfiguration.cs

@@ -38,6 +38,9 @@ namespace Musify.Application.Configuration
 
         [Required]
         public string PresetLargePicture { get; set; } = "PresetLargePicture.webp";
+
+        [Required]
+        public string Audios { get; set; } = "Audios";
     }
 
     public class TrackPicturesSizes

Application/Contracts/Infrastructure/IAudioTranscoder.cs

@@ -4,6 +4,6 @@ namespace Musify.Application.Contracts.Infrastructure
 {
     public interface IAudioTranscoder
     {
-        Task<Result> TranscodeToDash(Stream audioStream, string folderName, CancellationToken cancellationToken);
+        Task<Result> TranscodeToDashAsync(Stream audioStream, string destinationPath, TimeSpan timeOut, CancellationToken cancellationToken);
     }
 }

Application/Events/ProcessTrackEvent.cs

@@ -1,4 +0,0 @@
-namespace Musify.Application.Events
-{
-    public record ProcessTrackEvent();
-}

Application/Events/TranscodeAudioFromTrackEvent.cs

@@ -0,0 +1,8 @@
+namespace Musify.Application.Events
+{
+    public record TranscodeAudioFromTrackEvent(
+        string SourceBucketName,
+        string SourceKeyName,
+        string DestinationBucketName,
+        string DestinationKeyName);
+}

Application/Tracks/Handler/CreateTrackCommandHandler.cs

@@ -52,19 +52,37 @@ namespace Musify.Application.Tracks.Handler
                 return Result.Error($"Failed to publish resize picture event for Track with id {track.Id}.");
             }
 
+            var audioKeyName = Path.Combine(trackConfiguration.Routes.Audios, $"{Guid.NewGuid() }.{request.Audio.FileType}");
+            var audioUploadResult = await UploadFile(request.Audio, audioKeyName, cancellationToken);
+            if (!audioUploadResult.IsSuccess)
+            {
+                logger.LogError("Failed to upload audio for track {TrackTitle}", request.Title);
+                return Result.Error($"Failed to upload audio for track {request.Title}");
+            }
+
+            try
+            {
+                await PublishTranscodeEvent(track.Id, audioUploadResult, cancellationToken);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Failed to publish transcode audio event for Track with id={TrackId}.", track.Id);
+                return Result.Error($"An error occurred while processing the audio for Track with id {track.Id}.");
+            }
+
             await database.Tracks.AddAsync(track, cancellationToken);
             await database.SaveChangesAsync(cancellationToken);
 
             return Result.Success();
         }
 
-        async Task<Result<string>> UploadFile(IFileData fileData, string originalPictureKeyName, CancellationToken cancellationToken)
+        async Task<Result<string>> UploadFile(IFileData fileData, string keyName, CancellationToken cancellationToken)
         {
             var uploadFile = await storageHandler.UploadFileAsync(
                 fileData.FileStream,
                 fileData.ContentType,
                 storageConfiguration.BucketName,
-                originalPictureKeyName,
+                keyName,
                 cancellationToken);
 
             return uploadFile;
@@ -96,5 +114,18 @@ namespace Musify.Application.Tracks.Handler
                 trackConfiguration.PicturesSizes.LargePictureWidth,
                 trackConfiguration.PicturesSizes.LargePictureHeight), cancellationToken);
         }
+
+        async Task PublishTranscodeEvent(Guid trackId, string audioKeyName, CancellationToken cancellationToken)
+        {
+            var destinationAudioKeyName = Path.Combine(
+                trackConfiguration.Routes.Audios,
+                trackId.ToString());
+
+            await eventBus.PublishAsync(new TranscodeAudioFromTrackEvent(
+                storageConfiguration.BucketName,
+                audioKeyName,
+                storageConfiguration.BucketName,
+                destinationAudioKeyName), cancellationToken);
+        }
     }
 }