private void ProcessBookingResponse(BookingResult response)
{
if (_ui?.CancellationToken.IsCancellationRequested == true)
{
CancelBooking().Forget();
return;
}
if (response == null)
{
BookingErrorMessage = "Cannot get any response";
return;
}
if (response.IsSuccessful)
{
StartTime = DateTime.Now + response.Left;
BookingErrorMessage = null;
IsBooked = response.IsSuccessful;
if (!_updating)
{
Update(UpdateMode.Lite, true, true).Forget();
}
}
else
{
BookingErrorMessage = response.ErrorMessage;
IsBooked = false;
}
_ui?.OnUpdate(response);
}
public async Task <IHttpActionResult> Solo(SoloBookingSource bookingSource)
{
try
{
Event evnt = await _eventRepository.GetActiveAsync();
if (null == evnt)
{
return(NotFound());
}
if (!evnt.HasOpened)
{
_log.Warn("An attempt was made to create a solo booking before the event is open.");
return(BadRequest());
}
BookingResult result = await _bookingRepository.CreateSoloAsync(evnt, bookingSource);
_log.Info("Created solo booking {0}.", result.Reference);
await SendBookingCreatedMailAsync(evnt, bookingSource, result);
return(Ok(result));
}
catch (Exception ex)
{
_log.Error(ex, "An unexpected exception occurred while creating a solo booking.");
throw;
}
}
public async Task <IHttpActionResult> ToBooking(string c)
{
try
{
Event evnt = await _eventRepository.GetActiveAsync();
if (null == evnt)
{
return(NotFound());
}
if (evnt.IsLocked)
{
return(BadRequest("The event is locked and can no longer accept bookings."));
}
Guid candidateId = ParseGuid(c);
BookingCandidate candidate;
int placeInQueue;
using (var db = DbUtil.Open())
{
candidate = await _candidateRepository.FindByIdAsync(db, candidateId);
if (null == candidate)
{
return(NotFound());
}
placeInQueue = await _candidateRepository.FindPlaceInQueueAsync(db, candidateId);
if (0 == placeInQueue)
{
_log.Warn($"An attempt was made to create a booking for candidate ID = {candidateId} with no place in the queue.");
return(NotFound());
}
}
BookingResult result = await _bookingRepository.CreateFromCandidateAsync(evnt, candidate, placeInQueue);
_log.Info("Created booking {0} from candidate {1} at position {2}.", result.Reference, candidate.Id, placeInQueue);
await SendBookingCreatedMailAsync(evnt, candidate, result);
return(Ok(result));
}
catch (BookingException)
{
// An attempt was made to create a second booking from the same candidate
return(Conflict());
}
catch (FormatException)
{
return(BadRequest());
}
catch (Exception ex)
{
_log.Error(ex, "An unexpected exception occurred while creating a booking.");
throw;
}
}
public ActionResult BookEventSuccess(BookingResult resultViewModel)
{
if (resultViewModel.SpecialRequests != null)
{
ViewBag.SpecialRequestLabel = "Special Request: ";
}
return(PartialView("BookEventSuccess", resultViewModel));
}
async Task SendBookingCreatedMailAsync(Event evnt, SoloBookingSource source, BookingResult result)
{
try
{
using (var emailSender = new EmailSender())
await emailSender.SendBookingCreatedMailAsync(evnt.Name, source.Email, result.Reference, result.Password);
}
catch (Exception ex)
{
_log.Error(ex, "Failed to send e-mail on created booking.");
}
}
public BookingResult Booking(BookInfo bookInfo)
{
BookingResult result = new BookingResult();
if (bookInfo==null)
{
result.isSucceed = false;
}
else
{
result.isSucceed = true;
}
return result;
}
public IActionResult Post([FromBody] BookingResult model)
{
if (ModelState.IsValid)
{
_repository.AddDoubleAppontment(model);
if (_context.DoubleAppointments.LastOrDefault().Id > 0)
{
return(Created($"api/DoubleBookingEntry/{model.SelectedAuthority.Name},", model));
}
}
return(BadRequest(ModelState));
}
public static RoomBookingDTO FromQueryResult(BookingResult booking)
{
return(new RoomBookingDTO
{
BookingId = booking.BookingId,
DateOfFirstNight = booking.DateOfFirstNight,
NumberOfNights = booking.NumberOfNights,
NumberOfGuests = booking.NumberOfGuests,
RoomType = booking.RoomType.ToString(),
Amount = Convert.ToString(booking.Price, CultureInfo.InvariantCulture),
AccountId = booking.AccountId
});
}
public void OnUpdate(BookingResult response)
{
if (response?.IsSuccessful != true)
{
return;
}
Car = ServerEntry.SelectedCarEntry?.CarObject;
Track = ServerEntry.Track;
try {
_ignoreSkinChange = true;
Skin = ServerEntry.GetSelectedCarSkin();
} finally {
_ignoreSkinChange = false;
}
}
public ActionResult BookRestaurant(RestaurantBooking booking)
{
// RestaurantName & ID are passed hidden
Restaurant restaurant = foodRepository.GetRestaurant(booking.RestaurantId);
Event selectedevent = eventRepository.GetEvent(booking.SelectedEvent);
if (ModelState.IsValid)
{
if (selectedevent.CurrentTickets != 0 &&
(booking.AdultTickets + booking.ChildTickets) <= selectedevent.CurrentTickets)
{
Ticket ticket = new Ticket();
ticket.Amount = booking.AdultTickets + booking.ChildTickets;
ticket.EventId = booking.SelectedEvent;
ticket.Event = eventRepository.GetEvent(ticket.EventId);
ticket.Price = (booking.AdultTickets * restaurant.PriceAdults) + (booking.ChildTickets * restaurant.PriceChildren);
ticket.SpecialRequest = booking.SpecialRequest;
// Create session if it doesn't exist or add ticket to existing session
if (Session["currentTickets"] == null)
{
List <Ticket> tickets = new List <Ticket>();
tickets.Add(ticket);
Session["CurrentTickets"] = tickets;
}
else
{
List <Ticket> sessionTickets = (List <Ticket>)Session["currentTickets"];
sessionTickets.Add(ticket);
}
BookingResult resultViewModel = new BookingResult(booking.RestaurantName, ticket.Event.StartTime, ticket.Event.EndTime, ticket.SpecialRequest);
return(RedirectToAction("BookEventSuccess", resultViewModel));
}
ModelState.AddModelError("", "There are only " + selectedevent.CurrentTickets + " tickets available");
}
// Validation failed, reload some data:
booking.Events = foodRepository.GetAllFoodEvents(restaurant.RestaurantID);
return(PartialView("BookEvent", booking));
}
public BookingResult BookHotel(Order item)
{
BookingResult res = new BookingResult();
int leftRooms = CalcLeftRooms(item);
if (item.RoomCount > leftRooms)
{
res.IsValid = false;
return(res);
}
res.ClientName = item.ClientName;
res.HotelName = item.HotelName;
res.BookingCount = item.RoomCount;
res.IsValid = true;
BookedList.Add(item);
return(res);
}
private static void DisplayResult(List <BookingResult> bookingRes)
{
if (bookingRes == null)
{
return;
}
BookingResult br = bookingRes.Where(r => !r.IsValid).FirstOrDefault();
if (br != null)
{
Console.WriteLine("Invalid");
}
else
{
foreach (BookingResult item in bookingRes)
{
Console.WriteLine(string.Format("{0} {1} {2}", item.ClientName, item.HotelName, item.BookingCount));
}
}
}
public async Task <IHttpActionResult> Update(BookingSource bookingSource)
{
try
{
Event evnt = await _eventRepository.GetActiveAsync();
if (null == evnt)
{
return(NotFound());
}
if (IsUnauthorized(bookingSource.Reference))
{
return(BadRequest("Request is unauthorized, or not logged in as the booking it's trying to update."));
}
if (!AuthContext.IsAdmin && evnt.IsLocked)
{
return(BadRequest("The event has been locked and the booking can no longer be edited."));
}
BookingResult result = await _bookingRepository.UpdateAsync(evnt, bookingSource, AuthContext.IsAdmin);
_log.Info("Updated booking {0}.", result.Reference);
return(Ok(result));
}
catch (BookingException ex)
{
_log.Warn(ex, "A validation error occurred while updating the booking.");
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
_log.Error(ex, "An unexpected exception occurred while updating the booking.");
throw;
}
}
