Change editor rule

backend/Hosts/Musify.Api/Validators/Tracks/CreateTrackRequestValidator.cs

@@ -2,33 +2,34 @@ using FluentValidation;
 using Musify.Api.DataTransferObjects.Tracks;
 using Musify.Domain.ValueObjects;
 
-namespace Musify.Api.Validators.Tracks;
-
-public sealed class CreateTrackRequestValidator : AbstractValidator<CreateTrackRequest>
+namespace Musify.Api.Validators.Tracks
 {
-    public CreateTrackRequestValidator()
+    public sealed class CreateTrackRequestValidator : AbstractValidator<CreateTrackRequest>
     {
-        RuleFor(x => x.Title)
-            .NotEmpty()
-            .MaximumLength(Limits.TrackTitle);
+        public CreateTrackRequestValidator()
+        {
+            RuleFor(x => x.Title)
+                .NotEmpty()
+                .MaximumLength(Limits.TrackTitle);
 
-        RuleFor(x => x.PictureIntentId)
-            .NotEmpty();
+            RuleFor(x => x.PictureIntentId)
+                .NotEmpty();
 
-        RuleFor(x => x.AudioIntentId)
-            .NotEmpty();
+            RuleFor(x => x.AudioIntentId)
+                .NotEmpty();
 
-        RuleFor(x => x.Tags)
-            .NotEmpty()
-            .WithMessage("At least one tag is required.");
+            RuleFor(x => x.Tags)
+                .NotEmpty()
+                .WithMessage("At least one tag is required.");
 
-        RuleFor(x => x.Tags)
-            .Must(tags => GenreCompatibility.FindConflicts(tags).Count == 0)
-            .When(x => x.Tags is { Count: > 0 })
-            .WithMessage(x =>
-            {
-                var conflict = GenreCompatibility.FindConflicts(x.Tags).First();
-                return $"Tags '{conflict.First}' and '{conflict.Second}' are not compatible.";
-            });
+            RuleFor(x => x.Tags)
+                .Must(tags => GenreCompatibility.FindConflicts(tags).Count == 0)
+                .When(x => x.Tags is { Count: > 0 })
+                .WithMessage(x =>
+                {
+                    var conflict = GenreCompatibility.FindConflicts(x.Tags).First();
+                    return $"Tags '{conflict.First}' and '{conflict.Second}' are not compatible.";
+                });
+        }
     }
 }

backend/Hosts/Musify.Api/Validators/Tracks/RecordListeningProgressRequestValidator.cs

@@ -1,14 +1,15 @@
 using FluentValidation;
 using Musify.Api.DataTransferObjects.Tracks;
 
-namespace Musify.Api.Validators.Tracks;
-
-public sealed class RecordListeningProgressRequestValidator : AbstractValidator<RecordListeningProgressRequest>
+namespace Musify.Api.Validators.Tracks
 {
-    public RecordListeningProgressRequestValidator()
+    public sealed class RecordListeningProgressRequestValidator : AbstractValidator<RecordListeningProgressRequest>
     {
-        RuleFor(x => x.PlayedSeconds)
-            .Must(seconds => double.IsFinite(seconds) && seconds >= 0)
-            .WithMessage("'Played Seconds' must be a non-negative number.");
+        public RecordListeningProgressRequestValidator()
+        {
+            RuleFor(x => x.PlayedSeconds)
+                .Must(seconds => double.IsFinite(seconds) && seconds >= 0)
+                .WithMessage("'Played Seconds' must be a non-negative number.");
+        }
     }
 }

backend/Hosts/Musify.Api/Validators/Tracks/RequestTrackUploadUrlsRequestValidator.cs

@@ -2,28 +2,29 @@ using FluentValidation;
 using Musify.Api.DataTransferObjects.Tracks;
 using Musify.Application.Configuration;
 
-namespace Musify.Api.Validators.Tracks;
-
-public sealed class RequestTrackUploadUrlsRequestValidator : AbstractValidator<RequestTrackUploadUrlsRequest>
+namespace Musify.Api.Validators.Tracks
 {
-    public RequestTrackUploadUrlsRequestValidator(UploadIntentConfiguration uploadConfiguration)
+    public sealed class RequestTrackUploadUrlsRequestValidator : AbstractValidator<RequestTrackUploadUrlsRequest>
     {
-        RuleFor(x => x.PictureFileType)
-            .MustBeFileType(Uploads.PictureFileTypes);
+        public RequestTrackUploadUrlsRequestValidator(UploadIntentConfiguration uploadConfiguration)
+        {
+            RuleFor(x => x.PictureFileType)
+                .MustBeFileType(Uploads.PictureFileTypes);
 
-        RuleFor(x => x.PictureContentType)
-            .MustBeContentType(Uploads.PictureContentTypes);
+            RuleFor(x => x.PictureContentType)
+                .MustBeContentType(Uploads.PictureContentTypes);
 
-        RuleFor(x => x.AudioFileType)
-            .MustBeFileType(Uploads.AudioFileTypes);
+            RuleFor(x => x.AudioFileType)
+                .MustBeFileType(Uploads.AudioFileTypes);
 
-        RuleFor(x => x.AudioContentType)
-            .MustBeContentType(Uploads.AudioContentTypes);
+            RuleFor(x => x.AudioContentType)
+                .MustBeContentType(Uploads.AudioContentTypes);
 
-        RuleFor(x => x.ExpectedPictureSizeBytes)
-            .MustBeValidUploadSize(uploadConfiguration.MaxUploadBytes);
+            RuleFor(x => x.ExpectedPictureSizeBytes)
+                .MustBeValidUploadSize(uploadConfiguration.MaxUploadBytes);
 
-        RuleFor(x => x.ExpectedAudioSizeBytes)
-            .MustBeValidUploadSize(uploadConfiguration.MaxUploadBytes);
+            RuleFor(x => x.ExpectedAudioSizeBytes)
+                .MustBeValidUploadSize(uploadConfiguration.MaxUploadBytes);
+        }
     }
 }