public async Task UpdateBookingCommand_ShouldThrowNotFoundException_MissingExtraClass()
{
var userId = await RunAsDefaultUserAsync();
var subjectId = await SendAsync(new CreateSubjectCommand { Name = "Wizardry" });
var extraClassId = await SendAsync(new CreateExtraClassCommand
{
Name = "Gandalf's class",
SubjectId = subjectId,
Size = 1,
Price = 500,
Duration = TimeSpan.FromMinutes(60),
Date = DateTime.Now,
});
var command = new CreateBookingCommand {
ExtraClassId = extraClassId
};
var bookingId = await SendAsync(command);
var updateCommand = new UpdateBookingCommand {
Id = bookingId, ExtraClassId = 9999999999, Paid = true, Price = 100
};
//Assert
FluentActions.Invoking(() =>
SendAsync(updateCommand)).Should().Throw <NotFoundException>();
}
public async Task <IActionResult> OnPostUpdate(DateTime ViewBookTime,
int ViewPallets, int ViewPort, int ActualArrivalHour,
int ActualArrivalMinute, int startHour, int startMinute,
int endHour, int endMinute, Guid ViewBookingId)
{
var booking = new UpdateBookingCommand()
{
BookingTime = ViewBookTime,
TotalPallets = ViewPallets,
Port = ViewPort,
ActualArrival = GeneralUtil.TimeFromHourAndMinute(ActualArrivalHour, ActualArrivalMinute),
StartLoading = GeneralUtil.TimeFromHourAndMinute(startHour, startMinute),
EndLoading = GeneralUtil.TimeFromHourAndMinute(endHour, endMinute),
InternalId = ViewBookingId
};
var result = await bookingDataService.UpdateBooking(booking);
if (result.IsSuccesfull)
{
Message = "Bookingen er opdateret korrekt";
return(new RedirectToPageResult("BookingSingle", new { id = ViewBookingId }));
}
return(new RedirectToPageResult("Error"));
}
public void UpdateBookingCommand_ShouldThrowNotFoundException()
{
//Arrange
var command = new UpdateBookingCommand {
Id = 1, ExtraClassId = 1, Paid = true, Price = 100
};
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <NotFoundException>();
}
public async Task <ResponseBase> Handle(UpdateBookingCommand request, CancellationToken cancellationToken)
{
var input = new BookingUpdateInput
{
AggregateId = request.AggregateId,
ArriveDate = request.ArriveDate,
RoomName = request.RoomName
};
var result = await _bookingService.UpdateBooking(input);
return(result ? ResponseBase.Success : ResponseBase.Fail);
}
public async Task <IdResponse> HandleAsync(UpdateBookingCommand cmd, CancellationToken ct)
{
var result = _bookingRepository.Update(new Booking
{
Email = cmd.email,
ActualArrival = cmd.actualArrival,
BookingTime = cmd.bookingTime,
EndLoading = cmd.endLoading,
Port = cmd.port,
InternalId = cmd.internalId,
StartLoading = cmd.startLoading,
TotalPallets = cmd.totalPallets,
TransporterName = cmd.transporterName,
ExternalId = cmd.ExternalId
});
return(new IdResponse(cmd.Id));
}
public async Task <Response> UpdateBooking(UpdateBookingCommand booking)
{
var endpoint = baseurl;
var response = await PutAsync(endpoint, booking);
if (!response.IsSuccessStatusCode)
{
if (response.Content != null)
{
var errorMsg = await response.Content.ReadAsStringAsync();
return(Response.Unsuccesfull(response, errorMsg));
}
return(Response.Unsuccesfull(response, response.ReasonPhrase));
}
return(Response.Succes());
}
public async Task UpdateBookingCommand_ShouldThrowDoubleBookingException()
{
//Arrange
var userId = await RunAsDefaultUserAsync();
var subjectId = await SendAsync(new CreateSubjectCommand { Name = "Wizardry" });
var extraClassId1 = await SendAsync(new CreateExtraClassCommand
{
Name = "Gandalf's class",
SubjectId = subjectId,
Size = 2,
Price = 500,
Duration = TimeSpan.FromMinutes(60),
Date = DateTime.Now,
});
var extraClassId2 = await SendAsync(new CreateExtraClassCommand
{
Name = "Saruman's class",
SubjectId = subjectId,
Size = 2,
Price = 500,
Duration = TimeSpan.FromMinutes(60),
Date = DateTime.Now
});
var bookingId1 = await SendAsync(new CreateBookingCommand { ExtraClassId = extraClassId1 });
var bookingId2 = await SendAsync(new CreateBookingCommand { ExtraClassId = extraClassId2 });
var command = new UpdateBookingCommand {
Id = bookingId1, ExtraClassId = extraClassId2, Price = 500, Paid = false
};
//Assert
FluentActions.Invoking(() =>
SendAsync(command)).Should().Throw <DoubleBookingException>();
}
public async Task UpdateBookingCommand_ShouldUpdateBooking()
{
var userId = await RunAsDefaultUserAsync();
var subjectId = await SendAsync(new CreateSubjectCommand { Name = "Wizardry" });
var extraClassId = await SendAsync(new CreateExtraClassCommand
{
Name = "Gandalf's class",
SubjectId = subjectId,
Size = 1,
Price = 500,
Duration = TimeSpan.FromMinutes(60),
Date = DateTime.Now,
});
var bookingId = await SendAsync(new CreateBookingCommand { ExtraClassId = extraClassId });
var command = new UpdateBookingCommand
{
Id = bookingId,
ExtraClassId = extraClassId,
Paid = true,
Price = 100
};
await SendAsync(command);
var booking = await FindAsync <Booking>(bookingId);
booking.Paid.Should().BeTrue();
booking.BookingPrice.Should().Be(100);
booking.LastModifiedBy.Should().NotBeNull();
booking.LastModifiedBy.Should().Be(userId);
booking.LastModified.Should().NotBeNull();
booking.LastModified.Should().BeCloseTo(DateTime.Now, 10000);
}
public async Task <IActionResult> Update([FromBody] UpdateBookingCommand command)
{
await Mediator.Send(command);
return(NoContent());
}
public async Task <JsonResult> Post([FromQuery] int id, [FromBody] UpdateBookingCommand command)
{
command.BookingId = id;
return(await ApiResponseHelper.RunCommandAsync(command));
}
public Task UpdateAsync(Booking booking)
{
var command = new UpdateBookingCommand(booking);
return(command.ApplyAsync(context));
}
