Generator Changes at 9/27/2025 8:46:36 AM

src/CMSMicroservice.Protobuf/Validator/Package/CreateNewPackageRequestValidator.cs

@@ -0,0 +1,25 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Package;
+namespace CMSMicroservice.Protobuf.Validator.Package;
+
+public class CreateNewPackageRequestValidator : AbstractValidator<CreateNewPackageRequest>
+{
+    public CreateNewPackageRequestValidator()
+    {
+        RuleFor(model => model.Title)
+            .NotEmpty();
+        RuleFor(model => model.Description)
+            .NotEmpty();
+        RuleFor(model => model.ImagePath)
+            .NotEmpty();
+        RuleFor(model => model.Price)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewPackageRequest>.CreateWithOptions((CreateNewPackageRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Package/DeletePackageRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Package;
+namespace CMSMicroservice.Protobuf.Validator.Package;
+
+public class DeletePackageRequestValidator : AbstractValidator<DeletePackageRequest>
+{
+    public DeletePackageRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeletePackageRequest>.CreateWithOptions((DeletePackageRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Package/GetAllPackageByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Package;
+namespace CMSMicroservice.Protobuf.Validator.Package;
+
+public class GetAllPackageByFilterRequestValidator : AbstractValidator<GetAllPackageByFilterRequest>
+{
+    public GetAllPackageByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllPackageByFilterRequest>.CreateWithOptions((GetAllPackageByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Package/GetPackageRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Package;
+namespace CMSMicroservice.Protobuf.Validator.Package;
+
+public class GetPackageRequestValidator : AbstractValidator<GetPackageRequest>
+{
+    public GetPackageRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetPackageRequest>.CreateWithOptions((GetPackageRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Package/UpdatePackageRequestValidator.cs

@@ -0,0 +1,27 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Package;
+namespace CMSMicroservice.Protobuf.Validator.Package;
+
+public class UpdatePackageRequestValidator : AbstractValidator<UpdatePackageRequest>
+{
+    public UpdatePackageRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.Title)
+            .NotEmpty();
+        RuleFor(model => model.Description)
+            .NotEmpty();
+        RuleFor(model => model.ImagePath)
+            .NotEmpty();
+        RuleFor(model => model.Price)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdatePackageRequest>.CreateWithOptions((UpdatePackageRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Role/CreateNewRoleRequestValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Role;
+namespace CMSMicroservice.Protobuf.Validator.Role;
+
+public class CreateNewRoleRequestValidator : AbstractValidator<CreateNewRoleRequest>
+{
+    public CreateNewRoleRequestValidator()
+    {
+        RuleFor(model => model.Name)
+            .NotEmpty();
+        RuleFor(model => model.Title)
+            .NotEmpty();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewRoleRequest>.CreateWithOptions((CreateNewRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Role/DeleteRoleRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Role;
+namespace CMSMicroservice.Protobuf.Validator.Role;
+
+public class DeleteRoleRequestValidator : AbstractValidator<DeleteRoleRequest>
+{
+    public DeleteRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeleteRoleRequest>.CreateWithOptions((DeleteRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Role/GetAllRoleByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Role;
+namespace CMSMicroservice.Protobuf.Validator.Role;
+
+public class GetAllRoleByFilterRequestValidator : AbstractValidator<GetAllRoleByFilterRequest>
+{
+    public GetAllRoleByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllRoleByFilterRequest>.CreateWithOptions((GetAllRoleByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Role/GetRoleRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Role;
+namespace CMSMicroservice.Protobuf.Validator.Role;
+
+public class GetRoleRequestValidator : AbstractValidator<GetRoleRequest>
+{
+    public GetRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetRoleRequest>.CreateWithOptions((GetRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/Role/UpdateRoleRequestValidator.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.Role;
+namespace CMSMicroservice.Protobuf.Validator.Role;
+
+public class UpdateRoleRequestValidator : AbstractValidator<UpdateRoleRequest>
+{
+    public UpdateRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.Name)
+            .NotEmpty();
+        RuleFor(model => model.Title)
+            .NotEmpty();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdateRoleRequest>.CreateWithOptions((UpdateRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/User/CreateNewUserRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.User;
+namespace CMSMicroservice.Protobuf.Validator.User;
+
+public class CreateNewUserRequestValidator : AbstractValidator<CreateNewUserRequest>
+{
+    public CreateNewUserRequestValidator()
+    {
+        RuleFor(model => model.Mobile)
+            .NotEmpty();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewUserRequest>.CreateWithOptions((CreateNewUserRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/User/DeleteUserRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.User;
+namespace CMSMicroservice.Protobuf.Validator.User;
+
+public class DeleteUserRequestValidator : AbstractValidator<DeleteUserRequest>
+{
+    public DeleteUserRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeleteUserRequest>.CreateWithOptions((DeleteUserRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/User/GetAllUserByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.User;
+namespace CMSMicroservice.Protobuf.Validator.User;
+
+public class GetAllUserByFilterRequestValidator : AbstractValidator<GetAllUserByFilterRequest>
+{
+    public GetAllUserByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllUserByFilterRequest>.CreateWithOptions((GetAllUserByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/User/GetUserRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.User;
+namespace CMSMicroservice.Protobuf.Validator.User;
+
+public class GetUserRequestValidator : AbstractValidator<GetUserRequest>
+{
+    public GetUserRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetUserRequest>.CreateWithOptions((GetUserRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/User/UpdateUserRequestValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.User;
+namespace CMSMicroservice.Protobuf.Validator.User;
+
+public class UpdateUserRequestValidator : AbstractValidator<UpdateUserRequest>
+{
+    public UpdateUserRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.Mobile)
+            .NotEmpty();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdateUserRequest>.CreateWithOptions((UpdateUserRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserAddress/CreateNewUserAddressRequestValidator.cs

@@ -0,0 +1,29 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserAddress;
+namespace CMSMicroservice.Protobuf.Validator.UserAddress;
+
+public class CreateNewUserAddressRequestValidator : AbstractValidator<CreateNewUserAddressRequest>
+{
+    public CreateNewUserAddressRequestValidator()
+    {
+        RuleFor(model => model.UserId)
+            .NotNull();
+        RuleFor(model => model.Title)
+            .NotEmpty();
+        RuleFor(model => model.Address)
+            .NotEmpty();
+        RuleFor(model => model.PostalCode)
+            .NotEmpty();
+        RuleFor(model => model.IsDefault)
+            .NotNull();
+        RuleFor(model => model.CityId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewUserAddressRequest>.CreateWithOptions((CreateNewUserAddressRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserAddress/DeleteUserAddressRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserAddress;
+namespace CMSMicroservice.Protobuf.Validator.UserAddress;
+
+public class DeleteUserAddressRequestValidator : AbstractValidator<DeleteUserAddressRequest>
+{
+    public DeleteUserAddressRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeleteUserAddressRequest>.CreateWithOptions((DeleteUserAddressRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserAddress/GetAllUserAddressByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserAddress;
+namespace CMSMicroservice.Protobuf.Validator.UserAddress;
+
+public class GetAllUserAddressByFilterRequestValidator : AbstractValidator<GetAllUserAddressByFilterRequest>
+{
+    public GetAllUserAddressByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllUserAddressByFilterRequest>.CreateWithOptions((GetAllUserAddressByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserAddress/GetUserAddressRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserAddress;
+namespace CMSMicroservice.Protobuf.Validator.UserAddress;
+
+public class GetUserAddressRequestValidator : AbstractValidator<GetUserAddressRequest>
+{
+    public GetUserAddressRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetUserAddressRequest>.CreateWithOptions((GetUserAddressRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserAddress/UpdateUserAddressRequestValidator.cs

@@ -0,0 +1,31 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserAddress;
+namespace CMSMicroservice.Protobuf.Validator.UserAddress;
+
+public class UpdateUserAddressRequestValidator : AbstractValidator<UpdateUserAddressRequest>
+{
+    public UpdateUserAddressRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.UserId)
+            .NotNull();
+        RuleFor(model => model.Title)
+            .NotEmpty();
+        RuleFor(model => model.Address)
+            .NotEmpty();
+        RuleFor(model => model.PostalCode)
+            .NotEmpty();
+        RuleFor(model => model.IsDefault)
+            .NotNull();
+        RuleFor(model => model.CityId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdateUserAddressRequest>.CreateWithOptions((UpdateUserAddressRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserOrder/CreateNewUserOrderRequestValidator.cs

@@ -0,0 +1,25 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+namespace CMSMicroservice.Protobuf.Validator.UserOrder;
+
+public class CreateNewUserOrderRequestValidator : AbstractValidator<CreateNewUserOrderRequest>
+{
+    public CreateNewUserOrderRequestValidator()
+    {
+        RuleFor(model => model.Price)
+            .NotNull();
+        RuleFor(model => model.PackageId)
+            .NotNull();
+        RuleFor(model => model.PaymentStatus)
+            .NotNull();
+        RuleFor(model => model.UserId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewUserOrderRequest>.CreateWithOptions((CreateNewUserOrderRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserOrder/DeleteUserOrderRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+namespace CMSMicroservice.Protobuf.Validator.UserOrder;
+
+public class DeleteUserOrderRequestValidator : AbstractValidator<DeleteUserOrderRequest>
+{
+    public DeleteUserOrderRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeleteUserOrderRequest>.CreateWithOptions((DeleteUserOrderRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserOrder/GetAllUserOrderByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+namespace CMSMicroservice.Protobuf.Validator.UserOrder;
+
+public class GetAllUserOrderByFilterRequestValidator : AbstractValidator<GetAllUserOrderByFilterRequest>
+{
+    public GetAllUserOrderByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllUserOrderByFilterRequest>.CreateWithOptions((GetAllUserOrderByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserOrder/GetUserOrderRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+namespace CMSMicroservice.Protobuf.Validator.UserOrder;
+
+public class GetUserOrderRequestValidator : AbstractValidator<GetUserOrderRequest>
+{
+    public GetUserOrderRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetUserOrderRequest>.CreateWithOptions((GetUserOrderRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserOrder/UpdateUserOrderRequestValidator.cs

@@ -0,0 +1,27 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserOrder;
+namespace CMSMicroservice.Protobuf.Validator.UserOrder;
+
+public class UpdateUserOrderRequestValidator : AbstractValidator<UpdateUserOrderRequest>
+{
+    public UpdateUserOrderRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.Price)
+            .NotNull();
+        RuleFor(model => model.PackageId)
+            .NotNull();
+        RuleFor(model => model.PaymentStatus)
+            .NotNull();
+        RuleFor(model => model.UserId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdateUserOrderRequest>.CreateWithOptions((UpdateUserOrderRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserRole/CreateNewUserRoleRequestValidator.cs

@@ -0,0 +1,21 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserRole;
+namespace CMSMicroservice.Protobuf.Validator.UserRole;
+
+public class CreateNewUserRoleRequestValidator : AbstractValidator<CreateNewUserRoleRequest>
+{
+    public CreateNewUserRoleRequestValidator()
+    {
+        RuleFor(model => model.RoleId)
+            .NotNull();
+        RuleFor(model => model.UserId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<CreateNewUserRoleRequest>.CreateWithOptions((CreateNewUserRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserRole/DeleteUserRoleRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserRole;
+namespace CMSMicroservice.Protobuf.Validator.UserRole;
+
+public class DeleteUserRoleRequestValidator : AbstractValidator<DeleteUserRoleRequest>
+{
+    public DeleteUserRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<DeleteUserRoleRequest>.CreateWithOptions((DeleteUserRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserRole/GetAllUserRoleByFilterRequestValidator.cs

@@ -0,0 +1,17 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserRole;
+namespace CMSMicroservice.Protobuf.Validator.UserRole;
+
+public class GetAllUserRoleByFilterRequestValidator : AbstractValidator<GetAllUserRoleByFilterRequest>
+{
+    public GetAllUserRoleByFilterRequestValidator()
+    {
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetAllUserRoleByFilterRequest>.CreateWithOptions((GetAllUserRoleByFilterRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserRole/GetUserRoleRequestValidator.cs

@@ -0,0 +1,19 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserRole;
+namespace CMSMicroservice.Protobuf.Validator.UserRole;
+
+public class GetUserRoleRequestValidator : AbstractValidator<GetUserRoleRequest>
+{
+    public GetUserRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<GetUserRoleRequest>.CreateWithOptions((GetUserRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}

src/CMSMicroservice.Protobuf/Validator/UserRole/UpdateUserRoleRequestValidator.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+using CMSMicroservice.Protobuf.Protos.UserRole;
+namespace CMSMicroservice.Protobuf.Validator.UserRole;
+
+public class UpdateUserRoleRequestValidator : AbstractValidator<UpdateUserRoleRequest>
+{
+    public UpdateUserRoleRequestValidator()
+    {
+        RuleFor(model => model.Id)
+            .NotNull();
+        RuleFor(model => model.RoleId)
+            .NotNull();
+        RuleFor(model => model.UserId)
+            .NotNull();
+    }
+    public Func<object, string, Task<IEnumerable<string>>> ValidateValue => async (model, propertyName) =>
+    {
+        var result = await ValidateAsync(ValidationContext<UpdateUserRoleRequest>.CreateWithOptions((UpdateUserRoleRequest)model, x => x.IncludeProperties(propertyName)));
+        if (result.IsValid)
+            return Array.Empty<string>();
+        return result.Errors.Select(e => e.ErrorMessage);
+    };
+}