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