private bool IncorrectBooking(CancelBookingRequest request, ref PdrValidationResult result)
{
if (!_context.Order.Any(x => x.Id == request.BookingId && x.Status == OrderStatus.Unserved))
{
result.PassedValidation = false;
result.Errors.Add("Selected booking can not be canceled.");
return(true);
}
return(false);
}
private bool DoctorIsAlreadyBooked(AddBookingRequest request, ref PdrValidationResult result)
{
if (_context.Doctor.First(x => x.Id == request.DoctorId)
.Orders.Any(x => x.StartTime >= request.StartTime && x.EndTime <= request.EndTime))
{
result.PassedValidation = false;
result.Errors.Add("Requested Doctor is already booked");
return(true);
}
return(false);
}
public void CancelBooking_ValidatorFails_ThrowsArgumentException()
{
//arrange
var failedValidationResult = new PdrValidationResult(false, _fixture.Create <string>());
_cancelBookingRequestValidation.Setup(x => x.ValidateRequest(It.IsAny <CancelBookingRequest>())).Returns(failedValidationResult);
//act
var exception = Assert.Throws <ArgumentException>(() => _bookingService.CancelBooking(_fixture.Create <CancelBookingRequest>()));
//assert
exception.Message.Should().Be(failedValidationResult.Errors.First());
}
private bool SlotIsBooked(AddBookingRequest request, ref PdrValidationResult result)
{
if (_context.Order.Any(o => o.DoctorId == request.DoctorId &&
(request.StartTime >= o.StartTime && request.StartTime < o.EndTime ||
request.EndTime > o.StartTime && request.EndTime <= o.EndTime)))
{
result.PassedValidation = false;
result.Errors.Add("This time slot is already booked");
return(true);
}
return(false);
}
private bool InvalidEmail(string email, ref PdrValidationResult result)
{
var reg = new Regex("^[\\w-+\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$");
if (!reg.IsMatch(email))
{
result.PassedValidation = false;
result.Errors.Add("Email must be a valid email address");
return(true);
}
return(false);
}
public async Task AddBooking_ValidatorFails_ThrowsArgumentException()
{
//arrange
var failedValidationResult = new PdrValidationResult(false, _fixture.Create <string>());
_validator.Setup(x => x.ValidateRequest(It.IsAny <AddBookingRequest>())).Returns(failedValidationResult);
//act
var exception = Assert.ThrowsAsync <ArgumentException>(() => _bookingService.AddBooking(_fixture.Create <AddBookingRequest>(), CancellationToken.None));
//assert
exception.Message.Should().Be(failedValidationResult.Errors.First());
}
private bool EmailNotValid(AddPatientRequest request, ref PdrValidationResult result)
{
if (!_emailValidator.EmailAddressIsValid(request.Email, out var failureReason))
{
result.PassedValidation = false;
result.Errors.Add(failureReason);
return(true);
}
else
{
return(false);
}
}
public void AddOrder_ValidatorFails_ThrowsArgumentException()
{
//arrange
var failedValidationResult = new PdrValidationResult(false, _fixture.Create <string>());
_validator.Setup(x => x.ValidateRequest(It.IsAny <AddOrderRequest>())).Returns(failedValidationResult);
//act
var exception = Assert.Throws <ArgumentException>(() => _orderService.AddOrder(_fixture.Create <AddOrderRequest>()));
//assert
exception.Message.Should().Be(failedValidationResult.Errors.First());
}
public void GetPatientNextAppointment_ValidatorFails_ThrowsObjectNotFoundException()
{
//arrange
var failedValidationResult = new PdrValidationResult(false, _fixture.Create <string>());
_getPatientNextAppointmentRequestValidator.Setup(x => x.ValidateRequest(It.IsAny <GetPatientNextAppointmentRequest>())).Returns(failedValidationResult);
//act
var exception = Assert.Throws <ObjectNotFoundException>(() => _bookingService.GetPatientNextAppointment(_fixture.Create <GetPatientNextAppointmentRequest>()));
//assert
exception.Message.Should().Be(failedValidationResult.Errors.First());
}
public bool EmailAddressInvalid(AddPatientRequest request, ref PdrValidationResult result)
{
var emailAddressAttribute = new System.ComponentModel.DataAnnotations.EmailAddressAttribute();
if (!emailAddressAttribute.IsValid(request.Email))
{
result.PassedValidation = false;
result.Errors.Add("Email must be a valid email address");
return(false);
}
return(true);
}
private bool DoctorIsAlreadyScheduled(AddOrderRequest request, ref PdrValidationResult result)
{
if (_context.Order.Any(x => x.DoctorId == request.DoctorId &&
!x.IsCancelled &&
!((request.StartTime < x.StartTime && request.EndTime < x.StartTime) ||
(request.StartTime > x.EndTime && request.EndTime > x.EndTime))))
{
result.PassedValidation = false;
result.Errors.Add("A doctor is already scheduled for this time");
return(true);
}
return(false);
}
private bool ValidateEmailAddress(AddPatientRequest request, ref PdrValidationResult result)
{
try
{
MailAddress m = new MailAddress(request.Email);
return(true);
}
catch (FormatException)
{
result.PassedValidation = false;
result.Errors.Add("Email must be a valid email address");
return(false);
}
}
private bool EmailAddressInvalid(AddDoctorRequest request, ref PdrValidationResult result)
{
if (!Regex.IsMatch(request.Email,
@"^(?("")("".+?(?<!\\)""@)|(([0-9a-z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-z])@))" +
@"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-z][-0-9a-z]*[0-9a-z]*\.)+[a-z0-9][\-a-z0-9]{0,22}[a-z0-9]))$",
RegexOptions.IgnoreCase, System.TimeSpan.FromMilliseconds(250)))
{
result.PassedValidation = false;
result.Errors.Add("Email must be a valid email address");
return(true);
}
return(false);
}
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);
}
/// <summary>
/// A helper method to test an email is valid.
/// </summary>
/// <see cref="https://docs.microsoft.com/en-us/dotnet/standard/base-types/how-to-verify-that-strings-are-in-valid-email-format"/>>
/// <param name="email">An email as a unit of check.</param>
/// <param name="result">A validation result.</param>
/// <returns></returns>
public static void CheckEmailIsValid(string email, ref PdrValidationResult result)
{
if (string.IsNullOrWhiteSpace(email))
{
EnrichFailedResult(ref result);
return;
}
try
{
// Normalize the domain
email = Regex.Replace(email !, @"(@)(.+)$", DomainMapper,
RegexOptions.None, TimeSpan.FromMilliseconds(200));
// Examines the domain part of the email and normalizes it.
string DomainMapper(Match match)
{
// Use IdnMapping class to convert Unicode domain names.
var idn = new IdnMapping();
// Pull out and process domain name (throws ArgumentException on invalid)
string domainName = idn.GetAscii(match.Groups[2].Value);
return(match.Groups[1].Value + domainName);
}
}
catch (RegexMatchTimeoutException)
{
EnrichFailedResult(ref result);
}
catch (ArgumentException)
{
EnrichFailedResult(ref result);
}
try
{
if (!Regex.IsMatch(email !,
@"^[^@\s]+@[^@\s]+\.[^@\s]+$",
RegexOptions.IgnoreCase, TimeSpan.FromMilliseconds(250)))
{
EnrichFailedResult(ref result);
}
}
catch (RegexMatchTimeoutException)
{
EnrichFailedResult(ref result);
}
}
private bool DoctorIsBusy(AddBookingRequest request, ref PdrValidationResult result)
{
if (_context.Order.Any(o =>
o.DoctorId == request.DoctorId &&
(request.StartTime > o.StartTime && request.StartTime < o.EndTime ||
request.EndTime > o.StartTime && request.EndTime < o.EndTime ||
request.StartTime <= o.StartTime && request.EndTime >= o.EndTime)))
{
result.PassedValidation = false;
result.Errors.Add("The doctor is busy");
return(true);
}
return(false);
}
public PdrValidationResult ValidateRequest(AddBookingRequest request)
{
var result = new PdrValidationResult(true);
if (PastDate(request, ref result))
{
return(result);
}
if (BusyDate(request, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(NewBookingRequest request)
{
var result = new PdrValidationResult(true);
if (BookingTimeInvalid(request, ref result))
{
return(result);
}
if (DoctorIsNotAvailable(request, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(AddDoctorRequest request)
{
var result = new PdrValidationResult(true);
if (ValidateGeneralFields(request, ref result))
{
return(result);
}
if (DoctorAlreadyInDb(request, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(BookingRequest request)
{
var result = new PdrValidationResult(true);
if (IsAnAppointmentInPast(request, ref result))
{
return(result);
}
if (IsSlotAlreadyBooked(request, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(UpdateBookingRequest request)
{
var result = new PdrValidationResult(true);
if (MissingRequiredFields(request, ref result))
{
return(result);
}
if (OrderDoesNotExist(request, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(AddClinicRequest request)
{
var result = new PdrValidationResult(true);
if (MissingRequiredFields(request, ref result))
{
return(result);
}
if (ClinicAlreadyInDb(request, ref result))
{
return(result);
}
return(result);
}
private bool IsAnAppointmentInPast(BookingRequest request, ref PdrValidationResult result)
{
if (!_context.Order.Any())
{
return(false);
}
if (request.StartTime <= DateTime.UtcNow.AddHours(1))
{
result.PassedValidation = false;
result.Errors.Add("Appointment cannot be scheduled earlier than than current time plus 1 hour");
return(true);
}
return(false);
}
private bool DoctorAlreadyBooked(AddBookingRequest request, ref PdrValidationResult result)
{
if (_context.Order.Any(x =>
x.Cancelled != true &&
x.DoctorId == request.DoctorId &&
x.StartTime < request.EndTime &&
request.StartTime < x.EndTime)
)
{
result.PassedValidation = false;
result.Errors.Add("A booking with this doctor already exists during this time");
return(true);
}
return(false);
}
public PdrValidationResult ValidateRequest(Guid bookingId)
{
var result = new PdrValidationResult(true);
if (BookingNotFound(bookingId, ref result))
{
return(result);
}
if (BookingAlreadyCancelled(bookingId, ref result))
{
return(result);
}
return(result);
}
public PdrValidationResult ValidateRequest(NewBookingRequest request)
{
var result = new PdrValidationResult(true);
if (BookingInThePast(request, ref result))
{
return(result);
}
if (DoctorAlreadyBooked(request, ref result))
{
return(result);
}
return(result);
}
public bool DoctorIsNotAvailable(NewBookingRequest request, ref PdrValidationResult result)
{
var doctorsBookings = _context.Order.Where(o => o.DoctorId == request.DoctorId);
if (doctorsBookings.Any())
{
var bookedTime = doctorsBookings.Where(b => !(b.StartTime >= request.EndTime || request.StartTime >= b.EndTime));
if (bookedTime.Any())
{
result.PassedValidation = false;
result.Errors.Add("The Doctor is already booked in this time slot");
return(true);
}
}
return(false);
}
private bool MissingRequiredFields(UpdateBookingRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (request.Id == Guid.Empty)
{
errors.Add("Must be a valid Id");
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
public bool MissingRequiredFields(AddClinicRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (string.IsNullOrEmpty(request.Name))
{
errors.Add("Name must be populated");
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
private bool BookingInThePast(NewBookingRequest request, ref PdrValidationResult result)
{
var errors = new List <string>();
if (request.StartTime < DateTime.Now)
{
errors.Add("Bookings can not be in the past");
}
if (errors.Any())
{
result.PassedValidation = false;
result.Errors.AddRange(errors);
return(true);
}
return(false);
}
