public ActionResult Create([FromBody] CreateReservationRequest request)
{
var newReservation = new Reservation();
try {
var screening = _dbContext.Screenings.Single(s => s.ScreeningId == request.screeningId);
newReservation.Screening = screening;
} catch (System.InvalidOperationException e) {
return(NotFound(new { error = "Screening cannot be found." }));
}
try {
var seat = _dbContext.Seats.Single(s => s.SeatId == request.seatId);
newReservation.Seat = seat;
} catch (System.InvalidOperationException e) {
return(NotFound(new { error = "Seat cannot be found." }));
}
try {
var entity = _dbContext.Reservations.Add(newReservation);
var validationContext = new ValidationContext(entity);
Validator.ValidateObject(entity, validationContext, validateAllProperties: true);
_dbContext.SaveChanges();
} catch (ValidationException e) {
return(BadRequest(new { error = "Reservation cannot be created." }));
}
catch (ArgumentException e) {
return(Conflict(new { error = "Reservation for this seat already exists." }));
}
return(Created(new Uri("http://localhost:8080/"), newReservation));
}
public async Task GetReservation_Success()
{
try
{
// Arrange
var now = DateTime.UtcNow;
var request = new CreateReservationRequest()
{
DeployType = DeployType.DevelopmentStaging.NumericValue(),
ServerType = ServerType.AccountApi.NumericValue(),
BranchName = Generator.RandomString(10),
UserId = Generator.RandomString(32),
Start = now.ToApiDate(),
End = now.AddDays(1).ToApiDate(),
};
var httpResponse = await Client.PostAsync("/api/reservation", request.ToRequestBody());
var id = (await httpResponse.Content.ReadAsStringAsync()).DeserializeJson <CreateReservationResponse>().Id;
// Act
httpResponse = await Client.GetAsync($"/api/reservation/{id}");
var stringResponse = await httpResponse.Content.ReadAsStringAsync();
// Assert
httpResponse.EnsureSuccessStatusCode();
var reservation = stringResponse.DeserializeJson <GetReservationResponse>();
request.ToExpectedObject().ShouldEqual(reservation);
}
finally
{
await CleanUpReservationsAsync();
}
}
public void Handle_NoReservationsShouldThrow()
{
var request = new CreateReservationRequest(Enumerable.Empty <SeatReservation>());
Action act = () => _handler.Handle(request).Wait();
act.ShouldThrow <ArgumentException>();
}
public async Task <IActionResult> Post([FromBody] CreateReservationRequest request)
{
Log.Debug("POST reservation");
var reservation = await _reservationsFactory.Create(request);
await reservation.Save();
return(Ok(new { id = reservation.Id }));
}
public async Task <Reservation> Create(CreateReservationRequest createReservationRequest)
{
var reservation = new Reservation(createReservationRequest);
if (await _eventStore.StreamExists(reservation.Id))
{
throw new ConflictException("Reservation already exists");
}
reservation.OnSave = async x => { await _eventStore.AddEvents(x.Id, x.Events); };
return(reservation);
}
public async Task <string> CreateReservationAsync(CreateReservationRequest request)
{
var newId = Generator.RandomString(32);
await Db.Reservation.AddAsync(request.ToReservation(newId));
await Db.SaveChangesAsync();
var res = await Db.Reservation.FindAsync(newId);
return(newId);
}
public async Task Create(CreateReservationRequest request)
{
using (var httpClient = new HttpClient())
{
var uri = new Uri(_baseUri, "api/v1/reservations");
var content = JsonConvert.SerializeObject(request);
var response = await httpClient.PostAsync(uri, new StringContent(content, Encoding.Default, "application/json"));
if (!response.IsSuccessStatusCode)
{
throw new UnexpectedResponseException(response.StatusCode);
}
}
}
public Reservation(CreateReservationRequest createReservationRequest)
{
var streamId = $"reservation-{createReservationRequest.SessionId}-{createReservationRequest.MemberId}";
var reservationCreatedEvent = new ReservationCreatedEvent
{
StreamId = streamId,
ReservationId = streamId,
SessionId = createReservationRequest.SessionId,
MemberId = createReservationRequest.MemberId,
SessionLocation = createReservationRequest.SessionLocation,
};
_AddEvent(reservationCreatedEvent);
}
/// <summary>Snippet for CreateReservation</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void CreateReservationRequestObject()
{
// Create client
ReservationServiceClient reservationServiceClient = ReservationServiceClient.Create();
// Initialize request argument(s)
CreateReservationRequest request = new CreateReservationRequest
{
ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
ReservationId = "",
Reservation = new Reservation(),
};
// Make the request
Reservation response = reservationServiceClient.CreateReservation(request);
}
public async Task Handle_IfRequestIsInvalidDoNotCreateReservation()
{
var req = new CreateReservationRequest(new []
{
new SeatReservation {
EmailAddress = "*****@*****.**", SeatId = 1
}
});
_validator.Setup(o => o.Validate(req)).Returns(false);
await _handler.Handle(req);
_db.Verify(o => o.Reservations.AddAsync(It.IsAny <Reservation>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task AddAsync(CreateReservationRequest request)
{
if (await _animalRepository.GetById(request.AnimalId) == null)
{
throw new BadRequestException("Dane zwierzę nie istnieje");
}
await _reservationRepository.AddAsync(new Reservation()
{
StartDate = request.StartDate,
EndDate = request.EndDate,
AnimalId = request.AnimalId,
Comments = request.Comments,
Cost = request.Cost
});
}
public IActionResult CreateReservation(int customerId, [FromBody] CreateReservationRequest request)
{
var customer = _hotelDbContext.Customers.Where(c => c.CustomerId == customerId).FirstOrDefault();
if (customer == null)
{
return(NotFound());
}
var rooms = _hotelDbContext.Rooms.Where(r => r.DoubleBed >= request.DoubleBeds && r.SingleBed >= request.SingleBeds).ToList();
if (rooms.Count < 1)
{
return(NotFound());
}
var reservations = _hotelDbContext.Reservations
.Where(r => request.StartDate < r.EndDate && r.StartDate < request.EndDate)
.Include(r => r.Room)
.ToList();
var reservedRooms = reservations.Select(r => r.Room).ToList();
RoomComparer comparer = new RoomComparer((r1, r2) => r1.RoomNumber == r2.RoomNumber);
IEnumerable <Room> difference = rooms.Except(reservedRooms, comparer);
var availableRoom = difference.FirstOrDefault();
if (availableRoom == null)
{
return(BadRequest());
}
var reservation = new Reservation
{
Customer = customer,
Room = availableRoom,
StartDate = request.StartDate,
EndDate = request.EndDate,
};
_hotelDbContext.Reservations.Add(reservation);
_hotelDbContext.SaveChanges();
return(Ok(_hotelDbContext.Reservations.Where(r => r.Customer.CustomerId == customerId).ToList()));
}
public async Task <IActionResult> Post([FromBody] CreateReservationRequest request)
{
var reservation = new Reservation
{
FlightId = request.FlightId,
Flight = await _flightService.GetFlightByIdAsync(request.FlightId),
UserId = request.UserId,
User = await _userService.GetUserByIdAsync(request.UserId)
};
await _reservationService.CreateReservationAsync(reservation);
var url = String.Format(
"{0}://{1}{2}",
HttpContext.Request.Scheme,
HttpContext.Request.Host.ToUriComponent(),
ApiRoutes.Reservation.Get.Replace("{id}", reservation.Id.ToString())
);
var response = new ReservationResponse
{
Id = reservation.Id,
Flight = new FlightResponse
{
Id = reservation.Flight.Id,
Departure = reservation.Flight.Departure,
From = new CountryResponse
{
Id = reservation.Flight.From.Id,
Name = reservation.Flight.From.Name
},
To = new CountryResponse
{
Id = reservation.Flight.To.Id,
Name = reservation.Flight.To.Name
}
},
User = new UserResponse
{
Id = reservation.User.Id,
Name = reservation.User.Name,
TgUid = reservation.User.TgUid
}
};
return(Created(url, response));
}
public async Task CreateReservation()
{
using (var testApi = new TestApi())
{
await testApi.Start();
var testConfig = new TestConfig();
var reservationClient = new ReservationsClient(testConfig.BaseUri);
var createReservation = new CreateReservationRequest
{
SessionId = "sessionId123",
MemberId = "memberId123",
};
await reservationClient.Create(createReservation);
await testApi.Stop();
}
}
public void Create()
{
var request = new CreateReservationRequest
{
MemberId = "memberId1",
SessionId = "sessionId1",
SessionLocation = "sessionLocation",
};
var reservation = new Reservation(request);
reservation.Id.Should().Be("reservation-sessionId1-memberId1");
reservation.Events.Count.Should().Be(1, "should create an event on created");
var firstEvent = reservation.Events.First() as ReservationCreatedEvent;
firstEvent.Should().NotBeNull("should create reservation created event");
// ReSharper disable once PossibleNullReferenceException
firstEvent.ReservationId.Should().Be(reservation.Id);
firstEvent.MemberId.Should().Be(request.MemberId, "should have correct memberId");
firstEvent.SessionId.Should().Be(request.SessionId, "should have correct sessionId");
firstEvent.SessionLocation.Should().Be(request.SessionLocation, "should have correct session location");
}
public IActionResult AddNewReservation([FromBody] CreateReservationRequest newReservation)
{
List <int> reservedSeats = newReservation.SeatNumbers;
List <Seat> reservedSeatsModel = new List <Seat>();
DateTime localDate = DateTime.Now;
StringBuilder uniqueUUID = new StringBuilder();
uniqueUUID.Append(localDate.ToString() + "ID:" + newReservation.UserId + "SCH:" + newReservation.ScheduleId);
Schedule infoSchedule = scheduleRepository.GetScheduleById(newReservation.ScheduleId);
User infoUser = userRepository.GetUserById(newReservation.UserId);
ReservationInfo reservationInfo = new ReservationInfo(reservedSeatsModel, uniqueUUID.ToString(), infoUser, infoSchedule, newReservation.Paid);
foreach (int element in reservedSeats)
{
if (reservationRepository.FindExistingReservation(newReservation.ScheduleId, element))
{
return(Conflict("Seat with number " + element + " is not available!"));
}
else
{
reservedSeatsModel.Add(seatRepository.Get(element));
var reservation = new Reservation {
ReservationUUID = uniqueUUID.ToString(),
Paid = newReservation.Paid,
ScheduleId = newReservation.ScheduleId,
SeatId = element,
UserId = newReservation.UserId,
};
reservationRepository.Create(reservation);
}
}
ApiResponse response = new ApiResponse("Added records to database!");
MailModel.sendMessage(reservationInfo, "ADD");
return(Ok(response));
}
private async Task <string> CreateReservationAsync(
DateTime start,
DeployType deploy,
ServerType server,
DateTime?end = null
)
{
var request = new CreateReservationRequest()
{
DeployType = deploy.NumericValue(),
ServerType = server.NumericValue(),
BranchName = Generator.RandomString(10),
UserId = Generator.RandomString(32),
Start = start.ToApiDate(),
End = (end ?? start.AddDays(1)).ToApiDate(),
};
var httpResponse = await Client.PostAsync("/api/reservation", request.ToRequestBody());
httpResponse.EnsureSuccessStatusCode();
var responseBody = await httpResponse.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <CreateReservationResponse>(responseBody).Id);
}
public async Task <ActionResult <CreateReservationResponse> > CreateReservationAsync([FromBody] CreateReservationRequest request)
{
var id = await Service.CreateReservationAsync(request);
return(new CreateReservationResponse()
{
Id = id
});
}
public async Task <IActionResult> Create([FromBody] CreateReservationRequest request)
{
await _reservationService.AddAsync(request);
return(Ok());
}
public async Task <IActionResult> Create([FromBody] CreateReservationRequest request)
{
var response = await _mediator.Send(request);
return(Ok(response));
}
