public async Task <ActionResult> AddAReservation([FromBody] PostReservationRequest request) { // Decide if this thing is WORTHY of being part of my collection. GetReservationsSummaryResponseItem response = await _reservationCommands.AddReservationAsync(request); return(CreatedAtRoute("reservations#getbyid", new { Id = response.Id }, response)); }
public async Task <ActionResult> AddRegistration(int eventId, [FromBody] PostReservationRequest request) { var savedEvent = await _context.Events.SingleOrDefaultAsync(e => e.Id == eventId); if (savedEvent == null) { return(NotFound()); } EventRegistration registration = new() { EmployeedId = request.Id, Name = request.FirstName + " " + request.LastName, Email = request.Email, Phone = request.Phone, Status = EventRegistrationStatus.Pending }; savedEvent.Registrations.Add(registration); await _context.SaveChangesAsync(); var worked = await _channel.AddRegistration(new EventRegistrationChannelRequest(registration.Id)); return(CreatedAtRoute("get-event-registration", new { eventId = savedEvent.Id, registrationId = registration.Id }, registration)); }
public async Task <ActionResult> AddRegistration(int eventId, [FromBody] PostReservationRequest request) { // check to see if there is an event with that id. var savedEvent = await _context.Events.SingleOrDefaultAsync(e => e.Id == eventId); if (savedEvent == null) { return(NotFound()); } // add this registration as a pending registration. EventRegistration registration = new() { EmployeeId = request.Id, Name = request.FirstName + " " + request.LastName, EMail = request.Email, Phone = request.Phone, Status = EventRegistrationStatus.Pending }; savedEvent.Registrations.Add(registration); await _context.SaveChangesAsync(); // Magic! -- tell the background worker to process this thing. // return a 201 Created with a link to the get/id method, with a copy of that registration // which will say status "pending". return(CreatedAtRoute("get-event-reservation", new { eventId = savedEvent.Id, registrationId = registration.Id }, registration)); }
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest reqest) { var reservation = _mapper.Map <Reservation>(reqest); reservation.Status = ReservationStatus.Pending; _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); var response = _mapper.Map <ReservationDetailsResponse>(reservation); await _reservationLogger.WriteAsync(reservation); return(CreatedAtRoute("reservations#getbyid", new { id = response.Id }, response)); }
public async Task <ActionResult> CreateReservationAsync([FromBody] PostReservationRequest request) { var reservation = _mapper.Map <Reservation>(request); reservation.Status = ReservationStatus.Pending; _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); await _reservationProcessor.ProcessReservation(reservation); var response = _mapper.Map <GetReservationDetailsResponse>(reservation); return(CreatedAtRoute("reservations#getareservation", new { id = response.Id }, response)); }
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest request) { var reservation = _mapper.Map <Reservation>(request); reservation.Status = ReservationStatus.Pending; _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); var response = _mapper.Map <ReservationDetailsResponse>(reservation); await _reservationsLogger.WriteAsync(reservation); //await Task.Delay(response.Items.Split(',').Count() * 1000); //response.AvailableOn = DateTime.Now.AddDays(1); return(CreatedAtRoute("reservations#getbyid", new { id = response.Id }, response)); }
public async Task <GetReservationsSummaryResponseItem> AddReservationAsync(PostReservationRequest request) { var reservation = new BookReservation { For = request.For, BookIds = request.Books, Status = ReservationStatus.Pending }; _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); await _reservationProcessor.AddWorkAsync(reservation); return(_mapper.Map <GetReservationsSummaryResponseItem>(reservation)); }
public async Task CreateReservation() { try { await Task.Run(async() => { //UserResponse user = await _userService.GetUserByEmail(path, _persistenceService.GetPersistenceValueWithKey("email").ToString(), new CancellationToken()); UserResponse user = await _userService.GetUserByEmail(path, "*****@*****.**", new CancellationToken()); _persistenceService.SetPersistenceValueAndKey("id", user.userId.ToString()); if (_userReservationTime != null && _userReservationDate != null && _direction != null) { //set userReservation private variable _userReservation = new Reservation(); _userReservation.Time = _userReservationTime; _userReservation.Date = _userReservationDate; _userReservation.Email = _persistenceService.GetPersistenceValueWithKey("email").ToString(); _userReservation.Directions = _direction; //cast userReservation object to Treq object PostReservationRequest Treq = new PostReservationRequest(); CastReservationToPostRequestReservation(Treq, user); PostReservationRequestContainer TreqCont = new PostReservationRequestContainer(); TreqCont.reservation = Treq; //call API var token = new CancellationToken(); var response = await _reservationService.CreateReservation(path, Treq, token); } else { throw new NullReferenceException("Une donnée est manquante à la complétion de la réservation."); } }); //reset variables CancelReservation(); await _pageService.DisplayAlert("Confirmation", "Réservation créée avec succès!", "OK"); await _masterNavigationService.NavigateToPage(new HomePage(false)); } catch (Exception e) { await _pageService.DisplayAlert("Erreur", e.Message, "OK"); } }
public async Task <ActionResult> AddAReservation([FromBody] PostReservationRequest reservation) { var reservationToSave = new Reservation { For = reservation.For, Books = string.Join(',', reservation.Books), ReservactionCreated = DateTime.Now, Status = ReservationStatus.Pending }; Context.Reservations.Add(reservationToSave); await Context.SaveChangesAsync(); var response = MapIt(reservationToSave); Processor.SendReservationForProcessing(response); return(Ok(response)); //TODO: Make it a 201 with a location header }
public async Task <ActionResult> AddAReservation([FromBody] PostReservationRequest request) { var reservation = new Reservation { For = request.For, Books = string.Join(',', request.Books), ReservationCreated = DateTime.Now, Status = ReservationStatus.Pending }; Context.Reservations.Add(reservation); await Context.SaveChangesAsync(); GetReservationItemResponse response = MapIt(reservation); reservationProcessor.SendForProcessing(response); return(CreatedAtRoute("reservations#getbyid", new { id = response.Id }, response)); }
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest request) { //Validate the model //Add it to the database var reservation = new Reservation { For = request.For, Books = string.Join(",", request.Books), ReservationCreated = DateTime.Now, Satus = ReservationStatus.Pending }; Context.Reservations.Add(reservation); await Context.SaveChangesAsync(); // write a message to the queue // TODO: RabbitMQ // return a response (201) return(Ok(reservation)); }
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest request) { //validate //add it to db var reservation = new Reservation { For = request.For, Books = string.Join(',', request.Books), ReservationCreated = DateTime.Now, Status = ReservationStatus.Pending }; Context.Reservations.Add(reservation); await Context.SaveChangesAsync(); //write message to the queue await ReservationQueue.Write(reservation); //return response (201) return(Ok(reservation)); }
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 <ActionResult> CreateReservation([FromBody] PostReservationRequest request) { // Update the domain (POST is unsafe - it does work. What work will we do?) // -- Create and Process a new Reservation (in our synch model) // -- Save it to the database. var reservation = _mapper.Map <Reservation>(request); // Tell something else - somehow - to work on this outside the Request/Response cycle. reservation.Status = ReservationStatus.Pending; // the reservation has an Id of zero because it hasn't been saved yet. _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); // like "magic" it now has a non-zero id (it's database id) await _reservationProcessor.ProcessReservation(reservation); var response = _mapper.Map <GetReservationDetailsResponse>(reservation); return(CreatedAtRoute("reservations#getareservation", new { id = response.Id }, response)); }
public void CastReservationToPostRequestReservation(PostReservationRequest Treq, UserResponse user) { Treq.user = StaticValues.currentUser; if (Treq.user == null) { Treq.user = new User(); Treq.user.email = user.email; Treq.user.firstName = user.firstName; Treq.user.lastName = user.lastName; Treq.user.userId = user.userId; object t = _persistenceService.GetPersistenceValueWithKey("id"); Treq.user.userId = Int32.Parse(t.ToString()); } if (_userReservation.Directions == DIRECTION_UDES) { Treq.directionName = "UdeS"; } else { Treq.directionName = _userReservation.Directions; } Treq.endDateTime = new DateTime(2019, 10, 18, 9, 0, 0); //cast string date to Date DateTime dt = new DateTime(); dt = Convert.ToDateTime(_userReservation.Date); string[] reservationTimeSplit = _userReservationTime.Split(':'); int hours = Int32.Parse(reservationTimeSplit[0]); int minutes = Int32.Parse(reservationTimeSplit[1]); dt = dt.Date.AddHours(hours).AddMinutes(minutes); Treq.startDateTime = dt; }
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest request) { // validate // add it to the database var reservation = new Reservation { For = request.For, Books = string.Join(',', request.Books), ReservationCreated = DateTime.Now, Status = ReservationStatus.Pending }; _context.Reservations.Add(reservation); await _context.SaveChangesAsync(); // write a message to the queue // TODO: RabbitMQ // Write the code you wish you had. await _reservationQueue.Write(reservation); // return a response (201) return(Ok(reservation)); }
public async Task <ActionResult> AddAReservation([FromBody] PostReservationRequest request) { // 1. Map It to a Reservation var reservation = new Reservation { For = request.For, Books = string.Join(',', request.Books), ReservationCreated = DateTime.Now, Status = ReservationStatus.Pending }; // 2. Add it to the database Context.Reservations.Add(reservation); await Context.SaveChangesAsync(); // 3. That that reservation and map it to a reservation response. // 4. return a 201 with a location and attach a GetReservationItemResponse var response = MapIt(reservation); reservationProcessor.SendForProcessing(response); return(CreatedAtRoute("reservations#getbyid", new { id = response.Id }, response)); }
public async Task <ActionResult <ReservationItem> > AddReservation([FromBody] PostReservationRequest item) { var reservation = new Reservation { For = item.For, Books = item.Books, Status = ReservationStatus.Pending }; Context.Reservations.Add(reservation); await Context.SaveChangesAsync(); var response = new ReservationItem { Id = reservation.Id, For = reservation.For, Books = reservation.Books, Status = reservation.Status }; // Write it to the Queue for the background worker (Coming Soon!) to process! Queue.SendReservation(response); return(Ok(response)); }
public async Task <BaseResponse> CreateReservation(string path, PostReservationRequest Treq, CancellationToken token) { var response = await _networkService.PostAsync <PostReservationRequest, BaseResponse>($"reservations/", Treq, token); return(response); }