Validation fixes, finished application creation, added required char (*) for required fields

SchengenVisaApi/BlazorWebAssemblyVisaApiClient/Validation/Applicants/Validators/NameModelValidator.cs

@@ -10,16 +10,22 @@ public class NameModelValidator : AbstractValidator<NameModel>
         RuleFor(m => m.FirstName)
             .NotEmpty()
             .WithMessage("First Name can not be empty")
+            .Matches(Constants.EnglishWordRegex)
+            .WithMessage("First name must be in english characters")
             .MaximumLength(ConfigurationConstraints.NameLength)
             .WithMessage($"First Name length must be less than {ConfigurationConstraints.NameLength}");
 
         RuleFor(m => m.Surname)
             .NotEmpty()
             .WithMessage("Surname can not be empty")
+            .Matches(Constants.EnglishWordRegex)
+            .WithMessage("Surname must be in english characters")
             .MaximumLength(ConfigurationConstraints.NameLength)
             .WithMessage($"Surname length must be less than {ConfigurationConstraints.NameLength}");
 
         RuleFor(m => m.Patronymic)
+            .Matches(Constants.EnglishWordRegex)
+            .WithMessage("Patronymic must be in english characters")
             .MaximumLength(ConfigurationConstraints.NameLength)
             .WithMessage($"Patronymic length must be less than {ConfigurationConstraints.NameLength}");
     }

SchengenVisaApi/BlazorWebAssemblyVisaApiClient/Validation/Applicants/Validators/PassportModelValidator.cs

@@ -11,12 +11,16 @@ public class PassportModelValidator : AbstractValidator<PassportModel>
         RuleFor(r => r.Issuer)
             .NotEmpty()
             .WithMessage("Passport issuer can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Passport issuer field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.IssuerNameLength)
             .WithMessage($"Passport issuer length must be less than {ConfigurationConstraints.IssuerNameLength}");
 
         RuleFor(r => r.Number)
             .NotEmpty()
             .WithMessage("Passport number can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Passport number field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.PassportNumberLength)
             .WithMessage($"Passport number length must be less than {ConfigurationConstraints.PassportNumberLength}");
 

SchengenVisaApi/BlazorWebAssemblyVisaApiClient/Validation/Applicants/Validators/PlaceOfWorkModelValidator.cs

@@ -10,12 +10,16 @@ public class PlaceOfWorkModelValidator : AbstractValidator<PlaceOfWorkModel>
         RuleFor(p => p.Name)
             .NotEmpty()
             .WithMessage("Place of work name can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Place of work name field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.PlaceOfWorkNameLength)
             .WithMessage($"Place of work name length must be less than {ConfigurationConstraints.PlaceOfWorkNameLength}");
 
         RuleFor(p => p.PhoneNum)
             .NotEmpty()
             .WithMessage("Place of work phone number can not be empty")
+            .Matches(Constants.PhoneNumRegex)
+            .WithMessage("Place of work phone number field must be valid")
             .MaximumLength(ConfigurationConstraints.PhoneNumberLength)
             .WithMessage(
                 $"Phone number length must be in range from {ConfigurationConstraints.PhoneNumberMinLength} to {ConfigurationConstraints.PhoneNumberLength}")
@@ -23,27 +27,39 @@ public class PlaceOfWorkModelValidator : AbstractValidator<PlaceOfWorkModel>
             .WithMessage(
                 $"Phone number length must be in range from {ConfigurationConstraints.PhoneNumberMinLength} to {ConfigurationConstraints.PhoneNumberLength}");
 
+        RuleFor(p => p.Address)
+            .NotEmpty()
+            .WithMessage("Place of work address can not be empty");
+
         RuleFor(p => p.Address.Country)
             .NotEmpty()
             .WithMessage("Country name of place of work can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Place of work Country field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CountryNameLength)
             .WithMessage($"Country name of place of work length must be less than {ConfigurationConstraints.CountryNameLength}");
 
         RuleFor(p => p.Address.City)
             .NotEmpty()
             .WithMessage("City name of place of work can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Place of work City field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CityNameLength)
             .WithMessage($"City name of place of work length must be less than {ConfigurationConstraints.CityNameLength}");
 
         RuleFor(p => p.Address.Street)
             .NotEmpty()
             .WithMessage("Street name of place of work can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Place of work Street field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.StreetNameLength)
             .WithMessage($"Street name of place of work length must be less than {ConfigurationConstraints.StreetNameLength}");
 
         RuleFor(p => p.Address.Building)
             .NotEmpty()
             .WithMessage("Building of place of work can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Place of work building field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CountryNameLength)
             .WithMessage($"Building of place of work length must be less than {ConfigurationConstraints.BuildingNumberLength}");
     }

SchengenVisaApi/BlazorWebAssemblyVisaApiClient/Validation/Applicants/Validators/RegisterApplicantRequestValidator.cs

@@ -11,23 +11,28 @@ public class RegisterApplicantRequestValidator : AbstractValidator<RegisterAppli
     public RegisterApplicantRequestValidator(
         IDateTimeProvider dateTimeProvider,
         IValidator<NameModel> nameValidator,
-        IValidator<RegisterRequestModel> registerRequestModelValidator,
+        IValidator<RegisterRequestModel> registerRequestValidator,
         IValidator<PassportModel> passportValidator,
         IValidator<PlaceOfWorkModel> placeOfWorkModelValidator)
     {
         RuleFor(r => r.RegisterRequest)
-            .SetValidator(registerRequestModelValidator);
+            .NotEmpty()
+            .SetValidator(registerRequestValidator);
 
         RuleFor(r => r.ApplicantName)
+            .NotEmpty()
             .SetValidator(nameValidator);
 
         RuleFor(r => r.FatherName)
+            .NotEmpty()
             .SetValidator(nameValidator);
 
         RuleFor(r => r.MotherName)
+            .NotEmpty()
             .SetValidator(nameValidator);
 
         RuleFor(r => r.Passport)
+            .NotEmpty()
             .SetValidator(passportValidator);
 
         RuleFor(r => r.BirthDate)
@@ -39,38 +44,51 @@ public class RegisterApplicantRequestValidator : AbstractValidator<RegisterAppli
         RuleFor(r => r.CountryOfBirth)
             .NotEmpty()
             .WithMessage("Country of birth can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Country of birth field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CountryNameLength)
             .WithMessage($"Country of birth name length must be less than {ConfigurationConstraints.CountryNameLength}");
 
         RuleFor(r => r.CityOfBirth)
             .NotEmpty()
             .WithMessage("City of birth can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("City of birth field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CityNameLength)
             .WithMessage($"City of birth name length must be less than {ConfigurationConstraints.CityNameLength}");
 
         RuleFor(r => r.Citizenship)
             .NotEmpty()
             .WithMessage("Citizenship can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Citizenship field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CitizenshipLength)
             .WithMessage($"Citizenship length must be less than {ConfigurationConstraints.CitizenshipLength}");
 
         RuleFor(r => r.CitizenshipByBirth)
             .NotEmpty()
             .WithMessage("Citizenship by birth can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Citizenship by birth field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.CitizenshipLength)
             .WithMessage($"Citizenship by birth length must be less than {ConfigurationConstraints.CitizenshipLength}");
 
-        RuleFor(r => r.Gender).IsInEnum();
+        RuleFor(r => r.Gender)
+            .IsInEnum();
 
-        RuleFor(r => r.MaritalStatus).IsInEnum();
+        RuleFor(r => r.MaritalStatus)
+            .IsInEnum();
 
         RuleFor(r => r.JobTitle)
             .NotEmpty()
             .WithMessage("Title of job can not be empty")
+            .Matches(Constants.EnglishPhraseRegex)
+            .WithMessage("Title of job field can contain only english letters, digits and special symbols")
             .MaximumLength(ConfigurationConstraints.JobTitleLength)
             .WithMessage($"Title of job length must be less than {ConfigurationConstraints.JobTitleLength}");
 
         RuleFor(r => r.PlaceOfWork)
+            .NotEmpty()
             .SetValidator(placeOfWorkModelValidator);
     }
 }