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)); }