Enable more analyzers, drop log-and-rethrow in file activities and apply dotnet format

Use invariant culture when formatting ids, put cancellation tokens last in endpoint handlers, remove the
CS8618 pragmas and keep only the analyzer overrides that still apply.

backend/Core/Musify.Application/Configuration/Pictures.cs

@@ -1,4 +1,5 @@
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using Musify.Application.Shared;
 
 namespace Musify.Application.Configuration;
@@ -41,10 +42,10 @@ public class PictureRoutes
     public string BuildPicturePath(PictureSize size, string pictureName) => StorageKey.Combine(FolderPath(size), pictureName);
 
     public string BuildOriginalPicturePath(long userId, string pictureName) =>
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalPicturesFolder, pictureName);
+        StorageKey.Combine(UploadsFolder, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, OriginalPicturesFolder, pictureName);
 
     public string BuildTempPath(string tempRootPrefix, long userId, string objectName) =>
-        StorageKey.Combine(tempRootPrefix, userId.ToString(), ParentFolder, objectName);
+        StorageKey.Combine(tempRootPrefix, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, objectName);
 }
 
 public class PictureSizes

backend/Core/Musify.Application/Configuration/TrackConfiguration.cs

@@ -1,4 +1,5 @@
 using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using Musify.Application.Shared;
 
 namespace Musify.Application.Configuration;
@@ -48,7 +49,7 @@ public class TrackRoutes : PictureRoutes
     public string PresetLargePicturePath => StorageKey.Combine(ParentFolder, PresetLargePicture);
 
     public string BuildOriginalAudioPath(long userId, string audioName) =>
-        StorageKey.Combine(UploadsFolder, userId.ToString(), ParentFolder, OriginalAudiosFolder, audioName);
+        StorageKey.Combine(UploadsFolder, userId.ToString(CultureInfo.InvariantCulture), ParentFolder, OriginalAudiosFolder, audioName);
 
     public string BuildProcessedAudioPath(string folderName) =>
         StorageKey.Combine(ParentFolder, ProcessedAudiosFolder, folderName);

backend/Core/Musify.Application/Genres/GetAvailableGenres.cs

@@ -1,6 +1,6 @@
 using Mediator;
-using Musify.Domain.ValueObjects;
 using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Genres;
 

backend/Core/Musify.Application/Genres/GetGenres.cs

@@ -1,8 +1,8 @@
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
-using Musify.Domain.ValueObjects;
 using Musify.Application.Genres.Responses;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Application.Genres;
 

backend/Core/Musify.Application/Mixes/GenerateMixesForUser.cs

@@ -79,7 +79,7 @@ public class GenerateMixesForUserCommandHandler(
     private static List<Guid> Shuffle(IEnumerable<Guid> trackIds) =>
         [.. trackIds.OrderBy(_ => Guid.NewGuid())];
 
-    private static List<Guid> Interleave(IReadOnlyList<Guid> first, IReadOnlyList<Guid> second)
+    private static List<Guid> Interleave(List<Guid> first, List<Guid> second)
     {
         var merged = new List<Guid>(first.Count + second.Count);
         for (var index = 0; index < Math.Max(first.Count, second.Count); index++)

backend/Core/Musify.Application/Tracks/CreateTrack.cs

@@ -4,9 +4,9 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
-using Musify.Application.Shared;
 using Musify.Application.Events;
 using Musify.Application.Services;
+using Musify.Application.Shared;
 using Musify.Application.Tracks.Responses;
 using Musify.Domain.Entities;
 using Musify.Domain.ValueObjects;

backend/Core/Musify.Application/Tracks/StartListening.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
@@ -48,7 +49,7 @@ public class StartListeningCommandHandler(
             listenId = listen.Id;
         }
 
-        logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId?.ToString() ?? "(anonymous)");
+        logger.LogInformation("Issued stream ticket for track {TrackId} to user {UserId}", request.TrackId, request.UserId?.ToString(CultureInfo.InvariantCulture) ?? "(anonymous)");
 
         return streamIssuer.Issue(track.Audio.FolderName, request.UserId, listenId);
     }

backend/Core/Musify.Application/Users/GetUserById.cs

@@ -2,8 +2,8 @@ using ErrorOr;
 using Mediator;
 using Microsoft.EntityFrameworkCore;
 using Musify.Application.Contracts;
-using Musify.Application.Users.Responses;
 using Musify.Application.Shared;
+using Musify.Application.Users.Responses;
 
 namespace Musify.Application.Users;
 

backend/Core/Musify.Domain/Entities/Mix.cs

@@ -1,8 +1,7 @@
 using System.ComponentModel.DataAnnotations;
-using Musify.Domain.ValueObjects;
 using System.ComponentModel.DataAnnotations.Schema;
-
 using Musify.Domain.Abstractions;
+using Musify.Domain.ValueObjects;
 
 namespace Musify.Domain.Entities;
 

backend/Core/Musify.Domain/ValueObjects/TrackAudio.cs

@@ -2,7 +2,6 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace Musify.Domain.ValueObjects;
 
-#pragma warning disable CS8618
 public class TrackAudio
 {
     public string? OriginalName { get; set; }

backend/Core/Musify.Domain/ValueObjects/TrackPictures.cs

@@ -2,7 +2,6 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace Musify.Domain.ValueObjects;
 
-#pragma warning disable CS8618
 public class TrackPictures
 {
     public string? OriginalName { get; set; }

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

@@ -15,28 +15,16 @@ internal class CopyFileInBucketActivity(
 
     public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileInBucketArguments> executeContext)
     {
-        try
-        {
-            await storageService.CopyFileAsync(
-                executeContext.Arguments.SourceBucket,
-                executeContext.Arguments.SourceKey,
-                executeContext.Arguments.DestinationBucket,
-                executeContext.Arguments.DestinationKey,
-                executeContext.CancellationToken);
+        await storageService.CopyFileAsync(
+            executeContext.Arguments.SourceBucket,
+            executeContext.Arguments.SourceKey,
+            executeContext.Arguments.DestinationBucket,
+            executeContext.Arguments.DestinationKey,
+            executeContext.CancellationToken);
 
-            return executeContext.Completed(new CopyFileInBucketLog(
-                executeContext.Arguments.DestinationBucket,
-                executeContext.Arguments.DestinationKey));
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to copy {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}",
-                executeContext.Arguments.SourceBucket,
-                executeContext.Arguments.SourceKey,
-                executeContext.Arguments.DestinationBucket,
-                executeContext.Arguments.DestinationKey);
-            throw;
-        }
+        return executeContext.Completed(new CopyFileInBucketLog(
+            executeContext.Arguments.DestinationBucket,
+            executeContext.Arguments.DestinationKey));
     }
 
     public async Task<CompensationResult> Compensate(CompensateContext<CopyFileInBucketLog> compensateContext)

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

@@ -18,33 +18,25 @@ internal class DownloadFileFromBucketActivity(
         var destinationPath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
         ArgumentNullException.ThrowIfNull(destinationPath);
 
-        try
-        {
-            using var fileStream = await storageService.GetFileAsync(
-                executeContext.Arguments.Bucket,
-                executeContext.Arguments.Key,
-                executeContext.CancellationToken)
-                ?? throw new FileNotFoundException($"Object {executeContext.Arguments.Bucket}/{executeContext.Arguments.Key} was not found.");
+        using var fileStream = await storageService.GetFileAsync(
+            executeContext.Arguments.Bucket,
+            executeContext.Arguments.Key,
+            executeContext.CancellationToken)
+            ?? throw new FileNotFoundException($"Object {executeContext.Arguments.Bucket}/{executeContext.Arguments.Key} was not found.");
 
-            var destinationDirectory = Path.GetDirectoryName(destinationPath);
-            if (!string.IsNullOrWhiteSpace(destinationDirectory))
-                Directory.CreateDirectory(destinationDirectory);
+        var destinationDirectory = Path.GetDirectoryName(destinationPath);
+        if (!string.IsNullOrWhiteSpace(destinationDirectory))
+            Directory.CreateDirectory(destinationDirectory);
 
-            if (fileStream.CanSeek)
-                fileStream.Position = 0;
+        if (fileStream.CanSeek)
+            fileStream.Position = 0;
 
-            using var destinationStream = File.Create(destinationPath);
-            await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
-            return executeContext.Completed(new DownloadFileFromBucketLog(
-                executeContext.Arguments.Bucket,
-                executeContext.Arguments.Key,
-                destinationPath));
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to download file from bucket");
-            throw;
-        }
+        using var destinationStream = File.Create(destinationPath);
+        await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
+        return executeContext.Completed(new DownloadFileFromBucketLog(
+            executeContext.Arguments.Bucket,
+            executeContext.Arguments.Key,
+            destinationPath));
     }
 
     public Task<CompensationResult> Compensate(CompensateContext<DownloadFileFromBucketLog> compensateContext)

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

@@ -34,12 +34,5 @@ internal class RemoveFileFromBucketActivity(
                 executeContext.Arguments.Bucket);
             return executeContext.Completed();
         }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to remove {Key} from bucket {Bucket}",
-                executeContext.Arguments.Key,
-                executeContext.Arguments.Bucket);
-            throw;
-        }
     }
 }

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

@@ -20,25 +20,15 @@ internal class TransferFilesToBucketActivity(
         var destinationKey = executeContext.Arguments.DestinationKey;
         ArgumentNullException.ThrowIfNull(destinationKey);
 
-        try
-        {
-            var uploadedKeys = await storageService.TransferFilesAsync(
-                folderPath,
-                executeContext.Arguments.DestinationBucket,
-                destinationKey,
-                executeContext.CancellationToken);
+        var uploadedKeys = await storageService.TransferFilesAsync(
+            folderPath,
+            executeContext.Arguments.DestinationBucket,
+            destinationKey,
+            executeContext.CancellationToken);
 
-            return executeContext.Completed(new TransferFilesToBucketLog(
-                executeContext.Arguments.DestinationBucket,
-                uploadedKeys.ToArray()));
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to transfer files from {FolderPath} to {DestinationBucket}",
-                folderPath,
-                executeContext.Arguments.DestinationBucket);
-            throw;
-        }
+        return executeContext.Completed(new TransferFilesToBucketLog(
+            executeContext.Arguments.DestinationBucket,
+            uploadedKeys.ToArray()));
     }
 
     public async Task<CompensationResult> Compensate(CompensateContext<TransferFilesToBucketLog> compensateContext)

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

@@ -21,22 +21,14 @@ internal class UploadFileToBucketActivity(IStorageService storageService,
             .Where(static s => !string.IsNullOrWhiteSpace(s))
             .Select(static s => s.Trim().Trim('/', '\\')));
 
-        try
-        {
-            await storageService.UploadFileAsync(
-                sourceFilePath,
-                executeContext.Arguments.DestinationBucket,
-                destinationKey,
-                executeContext.CancellationToken);
-            return executeContext.CompletedWithVariables(new UploadFileToBucketLog(
-                executeContext.Arguments.DestinationBucket,
-                destinationKey));
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to upload file to bucket");
-            throw;
-        }
+        await storageService.UploadFileAsync(
+            sourceFilePath,
+            executeContext.Arguments.DestinationBucket,
+            destinationKey,
+            executeContext.CancellationToken);
+        return executeContext.CompletedWithVariables(new UploadFileToBucketLog(
+            executeContext.Arguments.DestinationBucket,
+            destinationKey));
     }
 
     public async Task<CompensationResult> Compensate(CompensateContext<UploadFileToBucketLog> compensateContext)

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

@@ -20,39 +20,31 @@ internal class ResizePictureActivity(
         var destinationFilePath = executeContext.GetVariable<string>(executeContext.Arguments.DestinationFilePathVariable);
         ArgumentNullException.ThrowIfNull(destinationFilePath);
 
-        try
+        if (!File.Exists(sourceFilePath))
         {
-            if (!File.Exists(sourceFilePath))
-            {
-                logger.LogWarning("Source file not found: {SourceFilePath}", sourceFilePath);
-                throw new FileNotFoundException($"Source file not found: {sourceFilePath}");
-            }
-
-            await using var fileStream = File.OpenRead(sourceFilePath);
-
-            await using var resizedPicture = await pictureHandler.ResizePictureAsWebpAsync(
-                fileStream,
-                executeContext.Arguments.Width,
-                executeContext.Arguments.Height,
-                executeContext.CancellationToken);
-
-            var destinationDirectory = Path.GetDirectoryName(destinationFilePath);
-            if (!string.IsNullOrEmpty(destinationDirectory))
-                Directory.CreateDirectory(destinationDirectory);
-
-            await using var destinationStream = File.Create(destinationFilePath);
-            await resizedPicture.CopyToAsync(destinationStream, executeContext.CancellationToken);
-
-            logger.LogDebug("Resized picture from {SourceFilePath} to {DestinationFilePath}",
-                sourceFilePath,
-                destinationFilePath);
-            return executeContext.Completed(new ResizePictureLog(destinationFilePath));
-        }
-        catch (Exception exception)
-        {
-            logger.LogError(exception, "Failed to resize picture {SourceFilePath}", sourceFilePath);
-            throw;
+            logger.LogWarning("Source file not found: {SourceFilePath}", sourceFilePath);
+            throw new FileNotFoundException($"Source file not found: {sourceFilePath}");
         }
+
+        await using var fileStream = File.OpenRead(sourceFilePath);
+
+        await using var resizedPicture = await pictureHandler.ResizePictureAsWebpAsync(
+            fileStream,
+            executeContext.Arguments.Width,
+            executeContext.Arguments.Height,
+            executeContext.CancellationToken);
+
+        var destinationDirectory = Path.GetDirectoryName(destinationFilePath);
+        if (!string.IsNullOrEmpty(destinationDirectory))
+            Directory.CreateDirectory(destinationDirectory);
+
+        await using var destinationStream = File.Create(destinationFilePath);
+        await resizedPicture.CopyToAsync(destinationStream, executeContext.CancellationToken);
+
+        logger.LogDebug("Resized picture from {SourceFilePath} to {DestinationFilePath}",
+            sourceFilePath,
+            destinationFilePath);
+        return executeContext.Completed(new ResizePictureLog(destinationFilePath));
     }
 
     public Task<CompensationResult> Compensate(CompensateContext<ResizePictureLog> compensateContext)

backend/Core/Musify.Infrastructure/MassTransit/Consumers/RoutingSlipCleanUpConsumer.cs

@@ -12,11 +12,11 @@ public class RoutingSlipCleanUpConsumer(
 {
     public const string QueueName = "routing-slip-clean-up";
 
-    public Task Consume(ConsumeContext<RoutingSlipCompleted> consumeContext)
-        => DeleteFolder(consumeContext.Message.Variables);
+    public Task Consume(ConsumeContext<RoutingSlipCompleted> context)
+        => DeleteFolder(context.Message.Variables);
 
-    public Task Consume(ConsumeContext<RoutingSlipFaulted> consumeContext)
-        => DeleteFolder(consumeContext.Message.Variables);
+    public Task Consume(ConsumeContext<RoutingSlipFaulted> context)
+        => DeleteFolder(context.Message.Variables);
 
     private Task DeleteFolder(IDictionary<string, object> variables)
     {

backend/Core/Musify.Infrastructure/MassTransit/DependencyInjection/MassTransitDependencyInjection.Registration.cs

@@ -3,6 +3,7 @@ using Microsoft.Extensions.DependencyInjection;
 using Musify.Infrastructure.MassTransit.Activities.Albums;
 using Musify.Infrastructure.MassTransit.Activities.Audio;
 using Musify.Infrastructure.MassTransit.Activities.Files;
+using Musify.Infrastructure.MassTransit.Activities.LifeCycle;
 using Musify.Infrastructure.MassTransit.Activities.Pictures;
 using Musify.Infrastructure.MassTransit.Activities.PlayLists;
 using Musify.Infrastructure.MassTransit.Activities.Tracks;
@@ -11,7 +12,6 @@ using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Consumers;
 using Musify.Infrastructure.MassTransit.Logs;
 using Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
-using Musify.Infrastructure.MassTransit.Activities.LifeCycle;
 
 namespace Musify.Infrastructure.MassTransit;
 

backend/Core/Musify.Infrastructure/MassTransit/DependencyInjection/MassTransitDependencyInjection.cs

@@ -1,11 +1,11 @@
 using MassTransit;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Infrastructure.Configuration;
 using Musify.Infrastructure.MassTransit.Sagas;
 using Musify.Infrastructure.Persistence;
-using Musify.Application.Configuration;
 
 namespace Musify.Infrastructure.MassTransit;
 

backend/Core/Musify.Infrastructure/MassTransit/RoutingSlip/Builders/DeleteRoutingSlipBuilder.cs

@@ -3,8 +3,8 @@ using Microsoft.EntityFrameworkCore;
 using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Domain.ValueObjects;
-using Musify.Infrastructure.MassTransit.Arguments;
 using Musify.Infrastructure.MassTransit.Activities.LifeCycle;
+using Musify.Infrastructure.MassTransit.Arguments;
 
 namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders;
 

backend/Core/Musify.Infrastructure/Observability/OpenTelemetryDependencyInjection.cs

@@ -1,12 +1,12 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Musify.Application.Configuration;
 using Musify.Infrastructure.Configuration;
 using OpenTelemetry.Exporter;
 using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
 using OpenTelemetry.Resources;
 using OpenTelemetry.Trace;
-using Musify.Application.Configuration;
 
 namespace Musify.Infrastructure.Observability;
 

backend/Core/Musify.Infrastructure/Persistence/DatabaseDependencyInjection.cs

@@ -1,8 +1,8 @@
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Musify.Application.Configuration;
 using Musify.Application.Contracts;
 using Musify.Infrastructure.Configuration;
-using Musify.Application.Configuration;
 
 namespace Musify.Infrastructure.Persistence;
 

backend/Core/Musify.Infrastructure/Services/StreamTicketService.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using System.Security.Cryptography;
 using Microsoft.IdentityModel.JsonWebTokens;
 using Microsoft.IdentityModel.Tokens;
@@ -30,9 +31,9 @@ public sealed class StreamTicketService : IStreamTicketService, IDisposable
 
         var claims = new Dictionary<string, object> { ["prefix"] = keyPrefix };
         if (userId != null)
-            claims["sub"] = userId.Value.ToString();
+            claims["sub"] = userId.Value.ToString(CultureInfo.InvariantCulture);
         if (maxBytes != null)
-            claims["maxBytes"] = maxBytes.Value.ToString();
+            claims["maxBytes"] = maxBytes.Value.ToString(CultureInfo.InvariantCulture);
 
         var descriptor = new SecurityTokenDescriptor
         {