public GetReservationResponse GetReservation(GetReservationRequest request)
{
var response = new GetReservationResponse
{
IsSuccessful = false,
Message = ""
};
try
{
var customer = _context.Customers
.FirstOrDefault(x => x.Id == request.CustomerId);
var reservation = _context.TableReservations
.Include(x => x.Customer)
.Where(x => x.Customer.FirstName == customer.FirstName)
.Where(x => x.Customer.LastName == customer.LastName)
.Where(x => x.Customer.Id == customer.Id)
.FirstOrDefault(x => x.Id == request.ReservationId);
if (reservation != null)
{
response.TableReservation = reservation;
response.IsSuccessful = true;
response.Message = "Successfully found reservation.";
}
}
catch (Exception ex)
{
response.IsSuccessful = false;
response.Message = ex.ToString();
}
return(response);
}
public async Task <ActionResult> GetReservationById(int id)
{
// look up the book.
var book = await _context.Reservations.SingleOrDefaultAsync(r => r.Id == id);
// if no book, return 404
if (book == null)
{
return(NotFound());
}
else
{
// if a book
// --map it to our model
// -- return it with a 200
var response = new GetReservationResponse
{
Id = book.Id,
For = book.For,
BooksReserved = book.BooksReserved,
Status = book.Status
};
return(Ok(response));
}
}
public async Task <bool> ProviderReservationAccessAllowed(uint ukPrn, GetReservationResponse reservation)
{
if (reservation == null || reservation.ProviderId == default(uint))
{
throw new ArgumentException("GetReservationResponse is null", nameof(reservation));
}
if (ukPrn == default(uint))
{
throw new ArgumentException("ukPrn is not set", nameof(ukPrn));
}
if (ukPrn != reservation.ProviderId)
{
return(false);
}
var trustedList = await _providerPermissionsService.GetTrustedEmployers(ukPrn);
if (trustedList.All(e => e.AccountLegalEntityId != reservation.AccountLegalEntityId))
{
throw new UnauthorizedAccessException();
}
return(true);
}
public async Task <ActionResult> DenyReservation([FromBody] GetReservationResponse request)
{
var savedReservation = await _context.Reservations
.SingleOrDefaultAsync(b => b.Id == request.Id);
if (savedReservation == null)
{
return(BadRequest("Could not find that reservation"));
}
else
{
savedReservation.Status = BookReservationStatus.Denied;
await _context.SaveChangesAsync();
return(Ok());
}
}
public void Arrange()
{
var fixture = new Fixture()
.Customize(new AutoMoqCustomization {
ConfigureMembers = true
});
_reservation = fixture.Create <GetReservationResponse>();
_employer = fixture.Create <Employer>();
_providerPermissionService = new Mock <IProviderPermissionsService>();
_service = new ReservationAuthorisationService(_providerPermissionService.Object);
_reservation.AccountLegalEntityId = _employer.AccountLegalEntityId;
_providerPermissionService.Setup(s => s.GetTrustedEmployers(It.IsAny <uint>()))
.ReturnsAsync(new List <Employer> {
_employer
});
}
public void Arrange()
{
_accountReservationsResult = new GetReservationResponse
{
Reservation = new Domain.Reservations.Reservation(null, _expectedReservationId, ExpectedAccountId, false, DateTime.UtcNow, DateTime.UtcNow, DateTime.UtcNow, ReservationStatus.Pending, null, 0, 0, "", 0, null)
};
_mediator = new Mock <IMediator>();
_mediator.Setup(x => x.Send(It.Is <GetReservationQuery>(c => c.Id.Equals(_expectedReservationId)),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_accountReservationsResult);
_httpContext = new Mock <HttpContext>();
_reservationsController = new ReservationsController(Mock.Of <ILogger <ReservationsController> >(), _mediator.Object)
{
ControllerContext = { HttpContext = _httpContext.Object,
ActionDescriptor = new ControllerActionDescriptor
{
ControllerName = "reservations"
} }
};
}
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest request)
{
// 1. Validate - Done.
// 2. Map the Model to an Entity (PostReservationRequest -> BookReservation)
// await Task.Delay(1000 * request.Books.Length);
var book = new BookReservation
{
For = request.For,
BooksReserved = String.Join(",", request.Books),
Status = BookReservationStatus.Pending
};
// 3. Add that to the DataContext
_context.Reservations.Add(book);
// 4. Save it.
await _context.SaveChangesAsync();
// 5. Return:
// a) 201 Created status code "I created a new resource for you"
// b) A Location header with the URL of the new thingy.
// c) Attach a copy of whatever they would get if they did a get request to the location.
// d) Consider adding a cache-control header. We won't do this now.
var response = new GetReservationResponse
{
Id = book.Id,
For = book.For,
BooksReserved = book.BooksReserved,
Status = book.Status
};
// tell "someone" else to do this offline.
await _orderProcessor.LogOrder(response);
return(CreatedAtRoute("bookreservations#get-byid", new { id = book.Id }, response));
}
public async Task <GetReservationResponse> GetReservationAsync(GetReservationRequest reservationNumber)
{
var reservationEntity = await _context.Reservations
.SingleOrDefaultAsync(r => r.ReservationNumber == reservationNumber.reservationNumber);
if (reservationEntity == null)
{
return(null);
}
reservationEntity.ReservationDetails = _context.ReservationDetails.Where(c => c.ReservationNumber == reservationNumber.reservationNumber).ToList();
GetReservationResponse result = _mapper.Map <GetReservationResponse>(reservationEntity);
string flightItemOld = "";
foreach (var flightItem in reservationEntity.ReservationDetails)
{
if (string.Compare(flightItem.FlightKey, flightItemOld) != 0)
{
var flightToInsert = new ReservationFlightResponse
{
key = flightItem.FlightKey,
passengers = new List <PassengersReservationDetailsResponse>()
};
result.flights.Add(flightToInsert);
}
var passengerToInsert = new PassengersReservationDetailsResponse
{
name = flightItem.Name,
bags = flightItem.NumberOfBags,
seat = flightItem.Seat
};
result.flights.Where(c => c.key == flightItem.FlightKey).FirstOrDefault().passengers.Add(passengerToInsert);
flightItemOld = flightItem.FlightKey;
}
return(result);
}
public void Arrange()
{
_validator = new Mock <IValidator <IReservationQuery> >();
_validator.Setup(x => x.ValidateAsync(It.Is <GetReservationQuery>(c =>
c.Id.Equals(_expectedReservationId))))
.ReturnsAsync(new ValidationResult());
_response = new GetReservationResponse
{
Id = _expectedReservationId,
StartDate = _expectedStartDate,
ExpiryDate = _expectedExpiryDate,
AccountLegalEntityId = ExpectedLegalEntityId,
AccountLegalEntityName = ExpectedLegalEntityName,
ProviderId = ExpectedProviderId
};
_apiClient = new Mock <IApiClient>();
_apiClient.Setup(x =>
x.Get <GetReservationResponse>(
It.Is <ReservationApiRequest>(c =>
c.GetUrl.Equals(
$"{ExpectedBaseUrl}api/reservations/{_expectedReservationId}"))))
.ReturnsAsync(_response);
_options = new Mock <IOptions <ReservationsApiConfiguration> >();
_options.Setup(x => x.Value.Url).Returns(ExpectedBaseUrl);
_reservationAuthorisationService = new Mock <IReservationAuthorisationService>();
_reservationAuthorisationService.Setup(s =>
s.ProviderReservationAccessAllowed(It.IsAny <uint>(), It.IsAny <GetReservationResponse>()))
.ReturnsAsync(true);
_handler = new GetReservationQueryHandler(_validator.Object, _apiClient.Object, _options.Object, _reservationAuthorisationService.Object);
}
public Task LogOrder(GetReservationResponse request)
{
_manager.Publish(request, "", "direct", "reservations");
return(Task.CompletedTask);
}
