public override async Task <ActionResult <CreateAppointmentResponse> > HandleAsync(CreateAppointmentRequest request, CancellationToken cancellationToken)
{
var response = new CreateAppointmentResponse(request.CorrelationId());
var spec = new ScheduleByIdWithAppointmentsSpec(request.ScheduleId); // TODO: Just get that day's appointments
var schedule = await _scheduleReadRepository.GetBySpecAsync(spec);
var appointmentType = await _appointmentTypeRepository.GetByIdAsync(request.AppointmentTypeId);
var appointmentStart = request.DateOfAppointment;
var timeRange = new DateTimeOffsetRange(appointmentStart, TimeSpan.FromMinutes(appointmentType.Duration));
var newAppointment = new Appointment(request.AppointmentTypeId, request.ScheduleId, request.ClientId, request.SelectedDoctor, request.PatientId, request.RoomId, timeRange, request.Title);
schedule.AddNewAppointment(newAppointment);
int conflictedAppointmentsCount = schedule.Appointments
.Count(a => a.IsPotentiallyConflicting);
_logger.LogInformation($"There are now {conflictedAppointmentsCount} conflicted appointments.");
_logger.LogDebug($"Adding appointment to schedule. Total appointments: {schedule.Appointments.Count()}");
await _scheduleRepository.UpdateAsync(schedule);
_logger.LogInformation($"Appointment created for patient {request.PatientId} with Id {newAppointment.Id}");
var dto = _mapper.Map <AppointmentDto>(newAppointment);
_logger.LogInformation(dto.ToString());
response.Appointment = dto;
return(Ok(response));
}
public void AddsAppointmentScheduledEvent()
{
var schedule = new Schedule(_scheduleId, _dateRange, _clinicId);
var appointmentType = 1;
var doctorId = 2;
var patientId = 3;
var roomId = 4;
DateTime lisaStartTime = new DateTime(2021, 01, 01, 10, 00, 00);
DateTime lisaEndTime = new DateTime(2021, 01, 01, 11, 00, 00);
var lisaDateRange = new DateTimeOffsetRange(lisaStartTime, lisaEndTime);
var lisaTitle = "Lisa Appointment";
var lisaAppointment = new Appointment(Guid.NewGuid(), appointmentType, _scheduleId, _clinicId, doctorId, patientId, roomId, lisaDateRange, lisaTitle);
schedule.AddNewAppointment(lisaAppointment);
DateTime mimiStartTime = new DateTime(2021, 01, 01, 12, 00, 00);
DateTime mimiEndTime = new DateTime(2021, 01, 01, 14, 00, 00);
var mimiDateRange = new DateTimeOffsetRange(mimiStartTime, mimiEndTime);
var mimiTitle = "Mimi Appointment";
var mimiAppointment = new Appointment(Guid.NewGuid(), appointmentType, _scheduleId, _clinicId, doctorId, patientId, roomId, mimiDateRange, mimiTitle);
schedule.AddNewAppointment(mimiAppointment);
Assert.Equal(2, schedule.Appointments.Count());
Assert.False(lisaAppointment.IsPotentiallyConflicting);
Assert.False(mimiAppointment.IsPotentiallyConflicting);
}
public void ConstructorCreatedAndIdSetToEmptyGuid()
{
const int appointmentTypeId = 1;
var scheduleId = Guid.NewGuid();
var appointmentId = Guid.NewGuid();
const int clientId = 2;
const int doctorId = 3;
const int patientId = 4;
const int roomId = 5;
const string title = "Title Test";
var startTime = new DateTimeOffset(2021, 01, 01, 10, 00, 00, new TimeSpan(-4, 0, 0));
var endTime = startTime.AddHours(3);
var range = new DateTimeOffsetRange(startTime, endTime);
const int threeHours = 3 * 60;
var appointment = new Appointment(appointmentId, appointmentTypeId, scheduleId, clientId, doctorId, patientId, roomId, range, title);
Assert.Null(appointment.DateTimeConfirmed);
Assert.Equal(appointmentTypeId, appointment.AppointmentTypeId);
Assert.Equal(scheduleId, appointment.ScheduleId);
Assert.Equal(clientId, appointment.ClientId);
Assert.Equal(doctorId, appointment.DoctorId);
Assert.Equal(patientId, appointment.PatientId);
Assert.Equal(roomId, appointment.RoomId);
Assert.Equal(threeHours, appointment.TimeRange.DurationInMinutes());
Assert.Equal(title, appointment.Title);
Assert.Equal(appointmentId, appointment.Id);
}
public void Should_Happen_During()
{
var d = new DateTimeOffsetRange(Now, OneDayAfterNow);
d.HappenedDuring(Now.AddHours(1)).Should().BeTrue();
d.HappenedDuring(Now).Should().BeTrue(); // date at begin of range is included
d.HappenedDuring(OneDayAfterNow).Should().BeTrue(); // date at end of range is included
}
public Appointment_Confirm()
{
_appointmentRange = new DateTimeOffsetRange(DateTime.Today.AddHours(12),
DateTime.Today.AddHours(13));
_fixture.Register(() => _appointmentRange);
_confirmedDate = DateTime.Today.AddHours(16);
}
public void Should_Intersection()
{
var d = new DateTimeOffsetRange(Now, OneDayAfterNow);
d.Intersection(new DateTimeOffsetRange(Now, OneDayAfterNow)).Should().Be(new DateTimeOffsetRange(Now, OneDayAfterNow));
d.Intersection(new DateTimeOffsetRange(Now.AddHours(1), OneDayAfterNow.AddHours(-1))).Should().Be(new DateTimeOffsetRange(Now.AddHours(1), OneDayAfterNow.AddHours(-1)));
d.Intersection(new DateTimeOffsetRange(Now.AddHours(-1), OneDayAfterNow.AddHours(1))).Should().Be(new DateTimeOffsetRange(Now, OneDayAfterNow));
}
public Schedule(Guid id,
DateTimeOffsetRange dateRange,
int clinicId)
{
Id = Guard.Against.Default(id, nameof(id));
DateRange = dateRange;
ClinicId = Guard.Against.NegativeOrZero(clinicId, nameof(clinicId));
}
/// <summary>
/// Evaluates if the datetime instance, did happen before the given period.
/// </summary>
public static bool HappenedBefore(this DateTimeOffset @this, DateTimeOffsetRange period)
{
if (period == null)
{
throw new ArgumentNullException(nameof(period));
}
return(period.HappenedBefore(@this));
}
public void Should_BeEqual()
{
var d1 = new DateTimeOffsetRange(Now, Now.AddDays(1));
var d2 = new DateTimeOffsetRange(Now, Now.AddDays(1));
var d3 = new DateTimeOffsetRange(Now, Now.AddDays(2));
d1.Equals(d2).Should().BeTrue();
d1.Equals(d3).Should().BeFalse();
}
public async Task ListDeployments(IEnumerable <string> arguments, IEnumerable <IParameter> parameters, CancellationToken cancellationToken)
{
var parametersDictionary = parameters.ToDictionary();
bool?GetBoolean(string key)
{
if (parametersDictionary.TryGetValue(key, out var completedParameter))
{
if (string.IsNullOrEmpty(completedParameter))
{
return(true);
}
else if (bool.TryParse(completedParameter, out var isCompletedValue))
{
return(isCompletedValue);
}
}
return(null);
}
bool?isCompleted = GetBoolean("completed");
bool?isScheduled = GetBoolean("scheduled");
async Task <DateTimeOffsetRange> GetDateRangeByOptionalCondition(bool?optionalCondition)
{
var dateRange = new DateTimeOffsetRange(null, null);
if (optionalCondition.HasValue && optionalCondition.Value)
{
var utcNow = systemClock.UtcNow;
var durationInDays = applicationSettings.DefaultDurationInDays;
if (parametersDictionary.TryGetValue("duration", out var value) &&
int.TryParse(value, out durationInDays))
{
await consoleWrapper.WriteLineAsync("Duration not supplied", LogLevel.Warning);
}
dateRange = new DateTimeOffsetRange(utcNow.AddDays(-durationInDays), utcNow);
}
return(dateRange);
}
var completedDateRange = await GetDateRangeByOptionalCondition(isCompleted);
var scheduledDateRange = await GetDateRangeByOptionalCondition(isScheduled);
var deployments = await deploymentService.GetDeploymentsAsync(cancellationToken, scheduledDateRange, completedDateRange);
foreach (var deployment in deployments)
{
await DisplayDeployment(deployment);
}
}
public Schedule(Guid id,
DateTimeOffsetRange dateRange,
int clinicId,
IEnumerable <Appointment> appointments)
{
Id = id;
DateRange = dateRange;
ClinicId = clinicId;
_appointments.AddRange(appointments ?? new List <Appointment>());
MarkConflictingAppointments();
}
public void UpdateStartTime(DateTimeOffset newStartTime)
{
if (newStartTime == TimeRange.Start)
{
return;
}
TimeRange = new DateTimeOffsetRange(newStartTime, TimeSpan.FromMinutes(TimeRange.DurationInMinutes()));
var appointmentUpdatedEvent = new AppointmentUpdatedEvent(this);
Events.Add(appointmentUpdatedEvent);
}
public AppointmentBuilder WithDefaultValues()
{
_appointmentTypeId = TEST_APPOINTMENT_TYPE_ID;
_scheduleId = TEST_SCHEDULE_ID;
_clientId = TEST_CLIENT_ID;
_doctorId = TEST_DOCTOR_ID;
_patientId = TEST_PATIENT_ID;
_roomId = TEST_ROOM_ID;
var startTime = new DateTime(2021, 01, 01, 10, 00, 00);
var endTime = new DateTime(2021, 01, 01, 12, 00, 00);
_dateTimeOffsetRange = new DateTimeOffsetRange(startTime, endTime);
_title = TEST_TITLE;
return(this);
}
private Schedule CreateScheduleWithAppointment()
{
var schedule = new Schedule(_scheduleId, _dateRange, _clinicId, null);
var appointmentType = 1;
var doctorId = 2;
var patientId = 3;
var roomId = 4;
DateTime lisaStartTime = new DateTime(2021, 01, 01, 10, 00, 00);
DateTime lisaEndTime = new DateTime(2021, 01, 01, 11, 00, 00);
var lisaDateRange = new DateTimeOffsetRange(lisaStartTime, lisaEndTime);
var lisaTitle = "Lisa Appointment";
var lisaAppointment = new Appointment(appointmentType, _scheduleId, _clinicId, doctorId, patientId, roomId,
lisaDateRange, lisaTitle);
schedule.AddNewAppointment(lisaAppointment);
return(schedule);
}
public AppointmentBuilder WithDefaultValues()
{
var appointmentTypeId = 1;
var scheduleId = Guid.Parse("f9369039-9d11-4442-9738-ed65d8a8ad52");
var clientId = 1;
var doctorId = 1;
var patientId = 1;
var roomId = 1;
var startTime = new DateTime(2021, 01, 01, 10, 00, 00);
var endTime = new DateTime(2021, 01, 01, 12, 00, 00);
var timeRange = new DateTimeOffsetRange(startTime, endTime);
var title = "Test Title";
_appointment = new Appointment(appointmentTypeId, scheduleId, clientId, doctorId, patientId, roomId, timeRange, title);
return(this);
}
public Appointment(int appointmentTypeId,
Guid scheduleId,
int clientId,
int doctorId,
int patientId,
int roomId,
DateTimeOffsetRange timeRange, // EF Core 5 cannot provide this type
string title,
DateTime?dateTimeConfirmed = null)
{
AppointmentTypeId = Guard.Against.NegativeOrZero(appointmentTypeId, nameof(appointmentTypeId));
ScheduleId = Guard.Against.Default(scheduleId, nameof(scheduleId));
ClientId = Guard.Against.NegativeOrZero(clientId, nameof(clientId));
DoctorId = Guard.Against.NegativeOrZero(doctorId, nameof(doctorId));
PatientId = Guard.Against.NegativeOrZero(patientId, nameof(patientId));
RoomId = Guard.Against.NegativeOrZero(roomId, nameof(roomId));
TimeRange = Guard.Against.Null(timeRange, nameof(timeRange));
Title = Guard.Against.NullOrEmpty(title, nameof(title));
DateTimeConfirmed = dateTimeConfirmed;
}
public void UpdatesTimeRange()
{
var scheduleId = Guid.NewGuid();
const int clientId = 1;
const int patientId = 2;
const int roomId = 3;
const int appointmentTypeId = 4;
const int doctorId = 5;
const string title = "Title Test";
var dateTimeRange = new DateTimeOffsetRange(_startTime, _endTime);
var appointment = new Appointment(appointmentTypeId, scheduleId, clientId, doctorId, patientId, roomId, dateTimeRange, title, null);
var newStartTime = new DateTime(2021, 01, 01, 11, 00, 00);
appointment.UpdateStartTime(newStartTime);
Assert.Equal(dateTimeRange.DurationInMinutes(), appointment.TimeRange.DurationInMinutes());
Assert.Equal(newStartTime, appointment.TimeRange.Start);
}
public Schedule_Constructor()
{
_dateRange = new DateTimeOffsetRange(_startTime, _endTime);
}
public Schedule_MarkConflictingAppointments()
{
_dateRange = new DateTimeOffsetRange(_startTime, _endTime);
}
public Appointment_UpdateStartTime()
{
_newDateTimeOffsetRange = new DateTimeOffsetRange(_startTime, _endTime);
}
public DateTimeOffsetExtensionsTests()
{
Now24HRange = new DateTimeOffsetRange(DateTimeOffset.Now, DateTimeOffset.Now.AddDays(1));
}
public AppointmentBuilder WithDateTimeOffsetRange(DateTimeOffsetRange dateTimeOffsetRange)
{
_dateTimeOffsetRange = dateTimeOffsetRange;
return(this);
}
public void Should_Happen_Before_Range()
{
var d = new DateTimeOffsetRange(Now, OneDayAfterNow);
d.HappenedBefore(OneDayBeforeNow).Should().BeTrue();
}
public void Should_Happen_After_Range()
{
var d = new DateTimeOffsetRange(Now, OneDayAfterNow);
d.HappenedAfter(OneDayAfterNow.AddHours(1)).Should().BeTrue();
}
public void Should_Have_Duration()
{
var d = new DateTimeOffsetRange(Now, OneDayAfterNow);
d.Duration.Should().Be(TimeSpan.FromDays(1));
}
public void When_Duration_Is_Positive_Should_Construct()
{
var d = new DateTimeOffsetRange(Now, duration: TimeSpan.FromDays(1));
d.Duration.Should().BeCloseTo(TimeSpan.FromDays(1), TimeSpan.FromMilliseconds(1));
}
public void When_Start_Occurs_At_End_Should_Construct()
{
var d = new DateTimeOffsetRange(startsAt: Now, endsAt: Now);
d.Duration.Should().Be(TimeSpan.Zero);
}
public void Should_Construct()
{
var d = new DateTimeOffsetRange(Now, Now.AddDays(1));
d.Duration.Should().BeCloseTo(TimeSpan.FromDays(1), TimeSpan.FromMilliseconds(1));
}
public Appointment_Create()
{
_endTime = _startTime.AddHours(3);
_range = new DateTimeOffsetRange(_startTime, _endTime);
}
