private bool ValidateGeneralFields(AddDoctorRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(request.FirstName))
{
errors.Add(ValidationErrorMessages.ShouldBePopulated(nameof(request.FirstName)));
}
if (string.IsNullOrEmpty(request.LastName))
{
errors.Add(ValidationErrorMessages.ShouldBePopulated(nameof(request.LastName)));
}
if (string.IsNullOrEmpty(request.Email))
{
errors.Add(ValidationErrorMessages.ShouldBePopulated(nameof(request.Email)));
}
else if (!Regex.IsMatch(request.Email, RegexValidation.EmailValidationRegexpPattern))
{
errors.Add(ValidationErrorMessages.ProvideValidEmail);
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
public string ValidateTypeRange(string type)
{
var isParsable = EnumUtils.TryParseWithMemberName <ContentType>(type, out _);
var types = Enum.GetNames(typeof(ContentType));
return((!isParsable) ? ValidationErrorMessages.InvalidTypeRange(type, types) : string.Empty);
}
public bool MissingRequiredFields(AddBookingRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (request.PatientId == default)
{
errors.Add(ValidationErrorMessages.EntityMustBeSet(nameof(request.PatientId)));
}
if (request.DoctorId == default)
{
errors.Add(ValidationErrorMessages.EntityMustBeSet(nameof(request.DoctorId)));
}
if (request.StartTime == default)
{
errors.Add(ValidationErrorMessages.EntityMustBeSet(nameof(request.StartTime)));
}
if (request.EndTime == default)
{
errors.Add(ValidationErrorMessages.EntityMustBeSet(nameof(request.EndTime)));
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
// TODO EES-919 - return ActionResults rather than ValidationResults - as this work is done,
// rename this to "ValidationResult"
public static ActionResult ValidationActionResult(ValidationErrorMessages message)
{
ModelStateDictionary errors = new ModelStateDictionary();
errors.AddModelError(string.Empty, message.ToString().ScreamingSnakeCase());
return(new BadRequestObjectResult(new ValidationProblemDetails(errors)));
}
public void ValidateRequest_PatientAlreadyHaveBooking_ReturnsFailedValidationResult()
{
//arrange
var request = GetValidRequest();
var now = _clockMock.Object.UtcNow.UtcDateTime;
var order = _fixture.Create <Order>();
order.DoctorId = request.DoctorId;
order.Doctor = null;
order.PatientId = request.PatientId;
order.Patient = null;
order.StartTime = now.AddMinutes(30);
order.EndTime = now.AddHours(2);
order.IsCancelled = false;
_context.Order.Add(order);
_context.SaveChanges();
//act
var res = _addBookingRequestValidator.ValidateRequest(request);
//assert
res.PassedValidation.Should().BeFalse();
res.Errors.Should().Contain(ValidationErrorMessages.IsAlreadyBooked(nameof(Patient)));
}
public static ValidationProblemDetails AssertValidationProblem(ActionResult result,
ValidationErrorMessages message)
{
var validationProblem = AssertValidationProblemIsBadDetails(result);
return(AssertValidationProblemDetails(validationProblem, message));
}
private static ValidationProblemDetails AssertValidationProblemDetails(
ValidationProblemDetails validationProblem, ValidationErrorMessages message)
{
Assert.True(validationProblem.Errors.ContainsKey(string.Empty));
Assert.Contains(ValidationResult(message).ErrorMessage, validationProblem.Errors[string.Empty]);
return(validationProblem);
}
public static ValidationProblemDetails AssertValidationProblem <T>(ActionResult <T> result,
ValidationErrorMessages message) where T : class
{
var validationProblem = AssertValidationProblemIsBadDetails(result);
return(AssertValidationProblemDetails(validationProblem, message));
}
public string ValidateIfIdsAreSame(Guid idFromRoute, Guid idFromBody)
{
return((idFromRoute != idFromBody)
?
ValidationErrorMessages.UnmatchingIds(idFromRoute, idFromBody)
:
string.Empty);
}
public string ValidateUniqueTitleOfItsType(Content contentWithUniqueTitle)
{
return((contentWithUniqueTitle != null)
?
ValidationErrorMessages.InvalidTitleForThisType(contentWithUniqueTitle.Title, contentWithUniqueTitle.Type.ToString())
:
string.Empty);
}
public string ValidateAgainstDuplicates(ICollection <AuthorDto> authorDtos)
{
var duplicates = authorDtos.GroupBy(a => a.Id)
.Where(g => g.Count() > 1)
.SelectMany(g => g);
return(duplicates.Any() ? ValidationErrorMessages.DuplicateAuthors() : string.Empty);
}
public CreateBlogCommandValidator(IAppContext context)
{
RuleFor(x => x.Title)
.NotEmpty().WithMessage(ValidationErrorMessages.NotEmpty);
RuleFor(x => x.AuthorId)
.Must(context.Exists <User, int>)
.WithMessage(ValidationErrorMessages.NotExistsInDatabase(typeof(User)));
}
private bool DoctorAlreadyInDb(AddDoctorRequest request, ref PdrValidationResult result)
{
if (_context.Doctor.Any(x => x.Email == request.Email))
{
result.PassedValidation = false;
result.Errors.Add(ValidationErrorMessages.EntityWithEmailAlreadyExists(nameof(Doctor)));
return(true);
}
return(false);
}
public string ValidateMatchingAuthors(IEnumerable <Author> authors, ICollection <AuthorDto> authorDtos)
{
if (authors.Count() != authorDtos.Count())
{
var ids = string.Join(", ", authorDtos.Select(a => a.Id));
var names = string.Join(", ", authorDtos.Select(a => a.Name));
return(authorDtos != null?ValidationErrorMessages.AuthorNotFound(ids, names) : string.Empty);
}
return(string.Empty);
}
public UpdatePostCommandValidator(IAppContext context)
{
RuleFor(x => x.Id)
.Must(context.Exists <Post, int>)
.WithMessage(ValidationErrorMessages.NotExistsInDatabase(typeof(Post)));
RuleFor(x => x.Content)
.NotEmpty().WithMessage(ValidationErrorMessages.NotEmpty);
RuleFor(x => x.Title)
.NotEmpty().WithMessage(ValidationErrorMessages.NotEmpty);
}
private bool ValidateBookingDateTimeAvailability(AddBookingRequest request, ref PdrValidationResult result)
{
var now = _systemClock.UtcNow;
if (request.EndTime <= request.StartTime)
{
result.Errors.Add(ValidationErrorMessages.BookingEndDateShouldBeGreaterThenStartDate);
}
if (request.StartTime <= now)
{
result.Errors.Add(ValidationErrorMessages.BookingIsNotAllowedAtPast);
}
//add custom time to let doctor prepare for an appointment/complete booking
if (request.StartTime <= now.AddMinutes(DomainConstants.MinutesForDoctorPreparation))
{
result.Errors.Add(ValidationErrorMessages.DoctorRequiresAdditionalTime);
}
if (result.Errors.Any())
{
result.PassedValidation = false;
return(true);
}
var patientOverlappingAppointments = _context.Order.Where(o => !o.IsCancelled &&
o.PatientId == request.PatientId &&
request.StartTime < o.EndTime &&
o.StartTime < request.EndTime);
if (patientOverlappingAppointments.Any())
{
result.PassedValidation = false;
result.Errors.Add(ValidationErrorMessages.IsAlreadyBooked(nameof(Patient)));
return(true);
}
var doctorOverLappingAppointments = _context.Order.Where(o => !o.IsCancelled &&
o.DoctorId == request.DoctorId &&
request.StartTime < o.EndTime &&
o.StartTime < request.EndTime);
if (doctorOverLappingAppointments.Any())
{
result.PassedValidation = false;
result.Errors.Add(ValidationErrorMessages.IsAlreadyBooked(nameof(Doctor)));
return(true);
}
return(false);
}
public void ValidateRequest_EmailNullOrEmpty_ReturnsFailedValidationResult(string email)
{
//arrange
var request = GetValidRequest();
request.Email = email;
//act
var res = _addPatientRequestValidator.ValidateRequest(request);
//assert
res.PassedValidation.Should().BeFalse();
res.Errors.Should().BeEquivalentTo(ValidationErrorMessages.ShouldBePopulated(nameof(request.Email)));
}
public void ValidateRequest_DoctorIdNullOrEmpty_ReturnsFailedValidationResult()
{
//arrange
var request = GetValidRequest();
request.DoctorId = 0;
//act
var res = _addBookingRequestValidator.ValidateRequest(request);
//assert
res.PassedValidation.Should().BeFalse();
res.Errors.Should().BeEquivalentTo(ValidationErrorMessages.EntityMustBeSet(nameof(request.DoctorId)));
}
public void ValidateRequest_DoctorIdNotInDb_ReturnsFailedValidationResult()
{
//arrange
var request = GetValidRequest();
request.DoctorId = 111;
//act
var res = _addBookingRequestValidator.ValidateRequest(request);
//assert
res.PassedValidation.Should().BeFalse();
res.Errors.Should().BeEquivalentTo(ValidationErrorMessages.EntityMustExistInDb(nameof(Doctor), request.DoctorId.ToString()));
}
public string this[string columnName]
{
get
{
string errorMessage = String.Empty;
if (columnName == nameof(Name))
{
if (StringUtils.IsNullOrEmptyOrWhiteSpace(Name))
{
errorMessage = "Имя должно быть непустой строкой и содержать только символы a-z, A-Z, _ и пробелы";
}
}
else if (columnName == nameof(BirthDay))
{
if (StringUtils.IsNullOrEmptyOrWhiteSpace(BirthDay) == false)
{
bool isDateTime = DateTime.TryParseExact(
BirthDay,
"dd.MM.yyyy",
CultureInfo.InvariantCulture,
DateTimeStyles.AssumeLocal,
out var birthDayDateTime);
if (isDateTime == false)
{
errorMessage = "День Рождения должен иметь формат дд.мм.гггг";
}
else if (birthDayDateTime < new DateTime(1900, 1, 1) || birthDayDateTime > DateTime.Now)
{
errorMessage = "День рождения может быть после 1900г. и до сегодняшнего дня";
}
}
}
if (errorMessage == "")
{
ValidationErrorMessages.Remove(columnName);
}
else if (errorMessage != null)
{
ValidationErrorMessages[columnName] = errorMessage;
}
IsActionEnabled = ValidationErrorMessages.Count == 0;
return(errorMessage);
}
}
public void ValidateRequest_PatientWithEmailAddressAlreadyExists_ReturnsFailedValidationResult()
{
//arrange
var request = GetValidRequest();
var existingPatient = _fixture
.Build <Patient>()
.With(x => x.Email, request.Email)
.Create();
_context.Add(existingPatient);
_context.SaveChanges();
//act
var res = _addPatientRequestValidator.ValidateRequest(request);
//assert
res.PassedValidation.Should().BeFalse();
res.Errors.Should().Contain(ValidationErrorMessages.EntityWithEmailAlreadyExists(nameof(Patient)));
}
private bool ValidateRelatedEntities(AddBookingRequest request, ref PdrValidationResult result)
{
var patient = _context.Patient.FirstOrDefault(p => p.Id == request.PatientId);
if (patient == null)
{
result.Errors.Add(ValidationErrorMessages.EntityMustExistInDb(nameof(Patient), request.PatientId.ToString()));
}
var doctor = _context.Doctor.FirstOrDefault(p => p.Id == request.DoctorId);
if (doctor == null)
{
result.Errors.Add(ValidationErrorMessages.EntityMustExistInDb(nameof(Doctor), request.DoctorId.ToString()));
}
if (result.Errors.Any())
{
result.PassedValidation = false;
return(true);
}
return(false);
}
public string ValidateUniqueAuthorName(Author authorWithUniqueName)
{
return(authorWithUniqueName != null?ValidationErrorMessages.AuthorExists(authorWithUniqueName.Name) : string.Empty);
}
public DeleteBlogCommandValidator(IAppContext context)
{
RuleFor(x => x.Id)
.Must(context.Exists <Blog, int>)
.WithMessage(ValidationErrorMessages.NotExistsInDatabase(typeof(Blog)));
}
public static ActionResult ValidationActionResult(ValidationErrorMessages message)
{
return(Common.Validators.ValidationUtils.ValidationResult(message));
}
public static ValidationResult ValidationResult(ValidationErrorMessages message)
{
return(new ValidationResult(message.ToString()));
}
public GetPostByIdQueryValidator(IAppContext context)
{
RuleFor(x => x.Id)
.Must(context.Exists <Post, int>)
.WithMessage(ValidationErrorMessages.NotExistsInDatabase(typeof(Post)));
}
public string ValidateUniqueAuthorId(Author authorWithUniqueId)
{
return((authorWithUniqueId != null) ? ValidationErrorMessages.EntityWithIdExists <Author>(authorWithUniqueId.Id) : string.Empty);
}
public string ValidateContentWasFound(Guid id, Content content)
{
return((content == null) ? ValidationErrorMessages.EntityNotFound <Content>(id) : string.Empty);
}
public string ValidateUniqueContentId(Content contentWithUniqueId)
{
return((contentWithUniqueId != null) ? ValidationErrorMessages.EntityWithIdExists <Content>(contentWithUniqueId.Id) : string.Empty);
}
