Initial commit

MetaCourse.Api/Validators/Courses/CreateCourseDtoValidator.cs

@@ -0,0 +1,23 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Courses;
+
+namespace MetaCourse.Api.Validators.Courses;
+
+public class CreateCourseDtoValidator : Validator<CreateCourseDto>
+{
+    public CreateCourseDtoValidator()
+    {
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(3).WithMessage("Le titre doit contenir au moins 3 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        RuleFor(x => x.Description)
+            .NotEmpty().WithMessage("La description est requise.")
+            .MaximumLength(2000).WithMessage("La description ne peut pas dépasser 2000 caractères.");
+
+        RuleFor(x => x.CreatorId)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant du créateur est invalide.");
+    }
+}

MetaCourse.Api/Validators/Courses/UpdateCourseDtoValidator.cs

@@ -0,0 +1,23 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Courses;
+
+namespace MetaCourse.Api.Validators.Courses;
+
+public class UpdateCourseDtoValidator : Validator<UpdateCourseDto>
+{
+    public UpdateCourseDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant est invalide.");
+
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(3).WithMessage("Le titre doit contenir au moins 3 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        RuleFor(x => x.Description)
+            .NotEmpty().WithMessage("La description est requise.")
+            .MaximumLength(2000).WithMessage("La description ne peut pas dépasser 2000 caractères.");
+    }
+}

MetaCourse.Api/Validators/Resources/CreateResourceDtoValidator.cs

@@ -0,0 +1,30 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Resources;
+using MetaCourse.Api.Entities;
+
+namespace MetaCourse.Api.Validators.Resources;
+
+public class CreateResourceDtoValidator : Validator<CreateResourceDto>
+{
+    public CreateResourceDtoValidator()
+    {
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(2).WithMessage("Le titre doit contenir au moins 2 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        RuleFor(x => x.Content)
+            .NotEmpty().WithMessage("Le contenu est requis.");
+
+        RuleFor(x => x.Type)
+            .IsInEnum().WithMessage("Le type de ressource est invalide.");
+
+        When(x => x.Type == ResourceType.Url || x.Type == ResourceType.Video, () =>
+        {
+            RuleFor(x => x.Content)
+                .Must(c => Uri.TryCreate(c, UriKind.Absolute, out _))
+                .WithMessage("Le contenu doit être une URL valide pour ce type de ressource.");
+        });
+    }
+}

MetaCourse.Api/Validators/Resources/UpdateResourceDtoValidator.cs

@@ -0,0 +1,33 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Resources;
+using MetaCourse.Api.Entities;
+
+namespace MetaCourse.Api.Validators.Resources;
+
+public class UpdateResourceDtoValidator : Validator<UpdateResourceDto>
+{
+    public UpdateResourceDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant est invalide.");
+
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(2).WithMessage("Le titre doit contenir au moins 2 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        RuleFor(x => x.Content)
+            .NotEmpty().WithMessage("Le contenu est requis.");
+
+        RuleFor(x => x.Type)
+            .IsInEnum().WithMessage("Le type de ressource est invalide.");
+
+        When(x => x.Type == ResourceType.Url || x.Type == ResourceType.Video, () =>
+        {
+            RuleFor(x => x.Content)
+                .Must(c => Uri.TryCreate(c, UriKind.Absolute, out _))
+                .WithMessage("Le contenu doit être une URL valide pour ce type de ressource.");
+        });
+    }
+}

MetaCourse.Api/Validators/Topics/CreateTopicDtoValidator.cs

@@ -0,0 +1,28 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Topics;
+
+namespace MetaCourse.Api.Validators.Topics;
+
+public class CreateTopicDtoValidator : Validator<CreateTopicDto>
+{
+    public CreateTopicDtoValidator()
+    {
+        RuleFor(x => x.CourseId)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant du cours est invalide.");
+
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(2).WithMessage("Le titre doit contenir au moins 2 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        When(x => x.Description != null, () =>
+        {
+            RuleFor(x => x.Description)
+                .MaximumLength(1000).WithMessage("La description ne peut pas dépasser 1000 caractères.");
+        });
+
+        RuleFor(x => x.Position)
+            .GreaterThan(0).WithMessage("La position doit être supérieure à 0.");
+    }
+}

MetaCourse.Api/Validators/Topics/UpdateTopicDtoValidator.cs

@@ -0,0 +1,28 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Topics;
+
+namespace MetaCourse.Api.Validators.Topics;
+
+public class UpdateTopicDtoValidator : Validator<UpdateTopicDto>
+{
+    public UpdateTopicDtoValidator()
+    {
+        RuleFor(x => x.Id)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant est invalide.");
+
+        RuleFor(x => x.Title)
+            .NotEmpty().WithMessage("Le titre est requis.")
+            .MinimumLength(2).WithMessage("Le titre doit contenir au moins 2 caractères.")
+            .MaximumLength(200).WithMessage("Le titre ne peut pas dépasser 200 caractères.");
+
+        When(x => x.Description != null, () =>
+        {
+            RuleFor(x => x.Description)
+                .MaximumLength(1000).WithMessage("La description ne peut pas dépasser 1000 caractères.");
+        });
+
+        RuleFor(x => x.Position)
+            .GreaterThan(0).WithMessage("La position doit être supérieure à 0.");
+    }
+}

MetaCourse.Api/Validators/UserCourses/EnrollDtoValidator.cs

@@ -0,0 +1,17 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.UserCourses;
+
+namespace MetaCourse.Api.Validators.UserCourses;
+
+public class EnrollDtoValidator : Validator<EnrollDto>
+{
+    public EnrollDtoValidator()
+    {
+        RuleFor(x => x.UserId)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant de l'utilisateur est invalide.");
+
+        RuleFor(x => x.CourseId)
+            .NotEqual(Guid.Empty).WithMessage("L'identifiant du cours est invalide.");
+    }
+}

MetaCourse.Api/Validators/Users/LoginUserDtoValidator.cs

@@ -0,0 +1,18 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Users;
+
+namespace MetaCourse.Api.Validators.Users;
+
+public class LoginUserDtoValidator : Validator<LoginUserDto>
+{
+    public LoginUserDtoValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("L'email est requis.")
+            .EmailAddress().WithMessage("Le format de l'email est invalide.");
+
+        RuleFor(x => x.Password)
+            .NotEmpty().WithMessage("Le mot de passe est requis.");
+    }
+}

MetaCourse.Api/Validators/Users/RegisterUserDtoValidator.cs

@@ -0,0 +1,27 @@
+using FastEndpoints;
+using FluentValidation;
+using MetaCourse.Api.DTOs.Users;
+
+namespace MetaCourse.Api.Validators.Users;
+
+public class RegisterUserDtoValidator : Validator<RegisterUserDto>
+{
+    public RegisterUserDtoValidator()
+    {
+        RuleFor(x => x.Name)
+            .NotEmpty().WithMessage("Le nom est requis.")
+            .MinimumLength(2).WithMessage("Le nom doit contenir au moins 2 caractères.")
+            .MaximumLength(100).WithMessage("Le nom ne peut pas dépasser 100 caractères.");
+
+        RuleFor(x => x.Email)
+            .NotEmpty().WithMessage("L'email est requis.")
+            .EmailAddress().WithMessage("Le format de l'email est invalide.")
+            .MaximumLength(255).WithMessage("L'email ne peut pas dépasser 255 caractères.");
+
+        RuleFor(x => x.Password)
+            .NotEmpty().WithMessage("Le mot de passe est requis.")
+            .MinimumLength(8).WithMessage("Le mot de passe doit contenir au moins 8 caractères.")
+            .Matches(@"[A-Z]").WithMessage("Le mot de passe doit contenir au moins une majuscule.")
+            .Matches(@"[0-9]").WithMessage("Le mot de passe doit contenir au moins un chiffre.");
+    }
+}