public async Task <IActionResult> Delete(ReservationsRouteModel routeModel)
{
var isProvider = routeModel.UkPrn.HasValue;
try
{
if (!routeModel.Id.HasValue)
{
_logger.LogInformation($"Reservation ID must be in URL, parameter [{nameof(routeModel.Id)}]");
var manageRoute = isProvider ? RouteNames.ProviderManage : RouteNames.EmployerManage;
return(RedirectToRoute(manageRoute, routeModel));
}
var query = new GetReservationQuery
{
Id = routeModel.Id.Value,
UkPrn = routeModel.UkPrn.GetValueOrDefault()
};
var queryResult = await _mediator.Send(query);
var viewName = isProvider ? ViewNames.ProviderDelete : ViewNames.EmployerDelete;
return(View(viewName, new DeleteViewModel(queryResult)));
}
catch (Exception e)
{
_logger.LogError(e, "Error preparing for the delete view");
throw;
}
}
public async Task <IActionResult> Completed(ReservationsRouteModel routeModel)
{
if (!routeModel.Id.HasValue)
{
throw new ArgumentException("Reservation ID must be in URL.", nameof(routeModel.Id));
}
var query = new GetReservationQuery
{
Id = routeModel.Id.Value,
UkPrn = routeModel.UkPrn.GetValueOrDefault()
};
var queryResult = await _mediator.Send(query);
//todo: null check on result, redirect to error
var model = new CompletedViewModel
{
AccountLegalEntityName = queryResult.AccountLegalEntityName,
TrainingDateDescription = new TrainingDateModel()
{
StartDate = queryResult.StartDate,
EndDate = queryResult.ExpiryDate
}.GetGDSDateString(),
CourseDescription = queryResult.Course.CourseDescription,
StartDate = queryResult.StartDate,
CourseId = queryResult.Course?.Id,
UkPrn = queryResult.UkPrn ?? routeModel.ProviderId,
CohortRef = routeModel.CohortReference
};
var viewName = routeModel.UkPrn.HasValue ? ViewNames.ProviderCompleted : ViewNames.EmployerCompleted;
return(View(viewName, model));
}
public async Task And_All_Fields_Valid_Then_Valid(
GetReservationQuery query,
GetReservationQueryValidator validator)
{
var result = await validator.ValidateAsync(query);
result.IsValid().Should().BeTrue();
result.ValidationDictionary.Count.Should().Be(0);
}
public async Task And_No_Id_Then_Invalid(
GetReservationQueryValidator validator)
{
var query = new GetReservationQuery();
var result = await validator.ValidateAsync(query);
result.IsValid().Should().BeFalse();
result.ValidationDictionary.Count.Should().Be(1);
result.ValidationDictionary
.Should().ContainKey(nameof(GetReservationQuery.Id))
.WhichValue.Should().Be($"{nameof(GetReservationQuery.Id)} has not been supplied");
}
public async Task Then_Will_Not_Check_For_Access_If_Employer()
{
//Arrange
var command = new GetReservationQuery
{
Id = _expectedReservationId
};
//Act + Assert
await _handler.Handle(command, new CancellationToken());
_reservationAuthorisationService.Verify(s => s.ProviderReservationAccessAllowed(It.IsAny <uint>(), It.IsAny <GetReservationResponse>()), Times.Never);
}
public void Arrange()
{
_query = new GetReservationQuery {
Id = _expectedReservationId
};
_validator = new Mock <IValidator <GetReservationQuery> >();
_validator.Setup(x => x.ValidateAsync(It.IsAny <GetReservationQuery>()))
.ReturnsAsync(new ValidationResult {
ValidationDictionary = new Dictionary <string, string>()
});
_cancellationToken = new CancellationToken();
_service = new Mock <IAccountReservationService>();
var reservation = new Reservation(Guid.Empty, 12345, DateTime.UtcNow, 1, "TestName");
_service.Setup(x => x.GetReservation(_expectedReservationId)).ReturnsAsync(reservation);
_handler = new GetReservationQueryHandler(_validator.Object, _service.Object);
}
public void Then_Will_Throw_Exception_If_Provider_Access_Denied()
{
//Arrange
_reservationAuthorisationService.Setup(s =>
s.ProviderReservationAccessAllowed(It.IsAny <uint>(), It.IsAny <GetReservationResponse>()))
.ReturnsAsync(false);
var command = new GetReservationQuery
{
Id = _expectedReservationId,
UkPrn = 12
};
//Act + Assert
Assert.ThrowsAsync <UnauthorizedAccessException>(() => _handler.Handle(command, new CancellationToken()));
_reservationAuthorisationService.Verify(s => s.ProviderReservationAccessAllowed(command.UkPrn, _response), Times.Once);
}
public async Task <ActionResult <ReservationDto> > GetReservation([FromRoute] Guid id)
{
try
{
var query = new GetReservationQuery()
{
Id = id
};
var result = await _mediator.Send(query);
return(Ok(result));
}
catch (EntityNotFoundException e)
{
logger.LogError(e.Message);
return(NotFound(e.Message));
}
}
public async Task Then_The_Reservation_Is_Returned_By_Id()
{
//Arrange
var command = new GetReservationQuery
{
Id = _expectedReservationId,
UkPrn = 12
};
//Act
var actual = await _handler.Handle(command, new CancellationToken());
//Assert
_reservationAuthorisationService.Verify(s => s.ProviderReservationAccessAllowed(command.UkPrn, _response), Times.Once);
Assert.AreEqual(_expectedReservationId, actual.ReservationId);
Assert.AreEqual(_expectedStartDate, actual.StartDate);
Assert.AreEqual(_expectedExpiryDate, actual.ExpiryDate);
Assert.AreEqual(ExpectedLegalEntityId, actual.AccountLegalEntityId);
Assert.AreEqual(ExpectedLegalEntityName, actual.AccountLegalEntityName);
Assert.AreEqual(ExpectedProviderId, actual.UkPrn);
}
public async Task <Reservation> Handle(GetReservationQuery request, CancellationToken cancellationToken)
{
return(await _repository.GetAsync(request.Id));
}
