public JsonResult AddBookingFromSearch(SearchModel searchModel)
{
HotelViewModel hotelModel = repository.GetAllHotels().SingleOrDefault(x => x.Id == searchModel.HotelId);
BookingModel bookingModel = new BookingModel();
bookingModel.HotelId = hotelModel.Id;
bookingModel.InvoiceNumber = "HMB" + new Guid();
bookingModel.FromDate = searchModel.FromDate;
bookingModel.ToDate = searchModel.ToDate;
bookingModel.Adult = searchModel.Adult;
bookingModel.Children = searchModel.Children;
bookingModel.BuyingCurrency = hotelModel.DefaultCurrency;
bookingModel.BookingDate = DateTime.Now.ToString("dd/mm/yyyy");
if (searchModel.CalculatedNight > 0)
{
bookingModel.BuyingPrice = hotelModel.PricePerNight * searchModel.CalculatedNight;
}
else
{
bookingModel.BuyingPrice = hotelModel.PricePerNight;
}
string data = repository.AddBooking(bookingModel);
return(Json(data, JsonRequestBehavior.AllowGet));
}
public JsonResult Post([FromBody] Booking vm)
{
try
{
if (ModelState.IsValid)
{
_logger.LogInformation("Trying to save a new booking.");
if (_repository.AddBooking(vm))
{
Response.StatusCode = (int)HttpStatusCode.Created;
return(Json("Success"));
}
}
}
catch (Exception ex)
{
_logger.LogError("Failed to confirm the event.", ex);
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { Message = ex.Message }));
}
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json(new { Message = "Failed", ModelState = ModelState }));
}
public async Task <int> AddBooking(BookingRequest bookingRequest)
{
if (bookingRequest.Participants == null)
{
throw new ArgumentNullException();
}
var tourGuests = bookingRequest.Participants.Select(participant => new TourGuest()
{
ExistingUserId = participant.Id,
FirstName = participant.FirstName,
LastName = participant.LastName,
Email = participant.Email,
Phone = participant.Phone,
Address = participant.Address,
EmergencyContact = participant.EmergencyContact
}).ToList();
var firstOrDefault = tourGuests.FirstOrDefault();
if (firstOrDefault != null)
{
firstOrDefault.IsPrimary = true;
}
var booking = new Booking
{
ListingId = bookingRequest.ListingId,
BookingDate = bookingRequest.BookingDate,
StartTime = bookingRequest.Time,
};
return(await _bookingRepository.AddBooking(booking, tourGuests));
}
public async Task <IActionResult> CreateBookingCollection(
[FromBody] IEnumerable <BookingForCreation> model)
{
if (ModelState.IsValid)
{
//map the model to list of bookings
var bookingCollection = _mapper.Map <IEnumerable <Entities.Booking> >(model);
//traverse collection and add each booking to dbset
foreach (var booking in bookingCollection)
{
//add the individual booking to dbset
_bookingRepository.AddBooking(booking);
}
//save bookings to database
await _bookingRepository.SaveChangesAsync();
//get all bookings that were stored
var bookingsToReturn = await _bookingRepository
.GetBookingsAsync(bookingCollection.Select(b => b.BookingId).ToList());
//build string of booking id's
var bookingIds = string.Join(",", bookingsToReturn.Select(b => b.BookingId));
return(CreatedAtRoute("GetBookingsCollection", new { bookingIds }, bookingsToReturn));
}
return(BadRequest());
}
public IActionResult AddBooking(Booking booking)
{
if (ModelState.IsValid)
{
var BookingId = _BookingRepository.AddBooking(booking);
if (BookingId > 0)
{
//configuration
var emailLog = _Configuration.GetValue<string>("EmailLogsService:EmailServiceProvider");
if(emailLog == "SendGrid")
{
_EmailLogRepository.EmailLog("This email is Sent By SendGrid", DateTime.Today, BookingId);
}
else if (emailLog == "SMTP")
{
_EmailLogRepository.EmailLog("This email is Sent By SMTP", DateTime.Today, BookingId);
}
return Ok(BookingId);
}
else
{
return NotFound();
}
}
return BadRequest();
}
public bool CreateBooking(Booking booking)
{
if ((_bookingData.GetBookingsByUserIdAndRideId(booking).Count() > 0) || GetAvailableSeatAtSource(booking) < 1)
{
return(false);
}
_bookingData.AddBooking(booking);
UpdateAvailableSeat(booking, false);
return(true);
}
public int AddBooking(BookingEntities be)
{
var config = new MapperConfiguration(cfg => cfg.CreateMap <BookingEntities, tblBooking>());
IMapper mapper = config.CreateMapper();
tblBooking ba = mapper.Map <BookingEntities, tblBooking>(be);
int BookingId = bookingRepository.AddBooking(ba);
return(BookingId);
}
public Bookings BookSlot(string customerId, string barberId, DateTimeOffset time,
List <BarberServices> bookedServices, out bool result)
{
Dictionary <DateTimeOffset, Scheduler> schedulers = GetSchedulers(barberId, new List <DateTimeOffset> {
time.GetDate()
});
int totalTimeInMinute = GetTotalServingTime(bookedServices);
if (schedulers.Count == 0)
{
result = false;
return(null);
}
var slot = new Slot(new TimePoint(time), totalTimeInMinute);
var bookResult = schedulers.Values.First().Book(slot);
if (bookResult)
{
PaymentMethods customerPaymentMethod =
_paymentMethodRepository.GetDefaultPaymentMethod(customerId);
Bookings booking = new Bookings
{
BarberId = barberId,
CustomerId = customerId,
BookedTime = time,
DurationMinute = totalTimeInMinute,
State = BookingConstants.Booked,
CustomerPaymentType = customerPaymentMethod.PaymentType
};
_bookingRepository.AddBooking(booking);
bookedServices.ForEach(service =>
{
var bookedService = new BookingServices
{
BookingId = booking.Id,
ServiceId = service.Id
};
_bookingServiceRepository.Add(bookedService);
});
result = true;
return(booking);
}
result = false;
return(null);
}
public async Task <ActionResult> Post([FromBody] Booking booking)
{
try
{
_log4net.Info("Adding new hotel booking with booking id : " + booking.BookingId);
var obj = await repository.AddBooking(booking);
//await availabilityRepository.Reduce(booking.HotelId);
return(Ok(obj));
}
catch
{
_log4net.Error("Error in adding Booking with booking Id : " + booking.BookingId);
return(new BadRequestObjectResult("Not added to bookings"));
}
}
public async Task <IActionResult> Create([Bind("BookingId,CustomerId,CarId,StartDate")] Booking booking)
{
booking.ReturnDate = booking.StartDate.AddDays(1);
booking.OnGoing = true;
//Hämtar bilen vi har att göra med och sätter den till bokad. Om den redan är bokad så berättar vi det
booking.Car = _carRepository.GetCarById(booking.CarId);
if (booking.Car.Booked == false)
{
booking.Car.Booked = true;
}
else
{
ViewBag.Message = "Bilen är redan bokad, vänligen välj en annan";
BookingVm error_bookingVm = new BookingVm();
error_bookingVm.Cars = FillCarListOfSelectListItems();
error_bookingVm.Customers = FillCustomerListOfSelectListItems();
return(View(error_bookingVm));
}
if (ModelState.IsValid)
{
//Lägger till bokningen i systemet
booking.BookingId = Guid.NewGuid();
_bookingRepository.AddBooking(booking);
//Uppdaterar bilen till bokad
_carRepository.UpdateCar(booking.Car);
_entityFrameworkRepository.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
BookingVm bookingVm = new BookingVm();
//Om det misslyckas så hämtar vi bilarna på nytt
bookingVm.Cars = FillCarListOfSelectListItems();
////Om det misslyckas så hämtar vi kunderna på nytt
bookingVm.Customers = FillCustomerListOfSelectListItems();
return(View(bookingVm));
}
public async Task <ActionResult <Booking> > CreateBooking([FromBody] Booking Booking)
{
try {
var result = await _repository.AddBooking(Booking);
if (result)
{
}
return(Ok());
}
catch (Exception exc)
{
_logger.LogError($"Error: {exc}");
// transaction.Rollback();
return(NotFound());
}
}
public async Task <IActionResult> Patch([FromQuery] string id, [FromBody] AppointmentDto booking)
{
//PracticeInformation practice = new PracticeInformation();
ObjectId p1 = ObjectId.Parse(id);
if (booking == null)
{
return(new NotFoundResult());
}
bool response = await _bookingRepository.AddBooking(p1, booking);
Debug.WriteLine(" Booking Creation Response =>[" + response + "]");
if (response == true)
{
return(StatusCode(201));
}
return(StatusCode(400));
}
public async Task <IActionResult> CreatePOST([Bind("Id,CustomerId,CarId,StartDate")] Booking booking)
{
booking.BookingTime = booking.BookingTime.AddDays(1);
booking.IsActive = true;
booking.Car = _carRepository.GetCarById(booking.CarId);
if (booking.Car.Available == true)
{
booking.Car.Available = false;
}
else
{
ViewBag.Message = "Bilen är tyvärr redan bokad.";
BookingViewModel error_bookingVm = new BookingViewModel();
error_bookingVm.Car = FillCarListOfSelectListItems();
error_bookingVm.Customer = FillCustomerListOfSelectListItems();
return(View(error_bookingVm));
}
if (ModelState.IsValid)
{
booking.Id = Guid.NewGuid();
_bookingRepository.AddBooking(booking);
_carRepository.UpdateCar(booking.Car);
return(RedirectToAction(nameof(Index)));
}
BookingViewModel bookingVM = new BookingViewModel();
bookingVM.Car = FillCarListOfSelectListItems();
bookingVM.Customer = FillCustomerListOfSelectListItems();
return(View(bookingVM));
}
public async Task <IActionResult> CreateBooking([FromBody] BookingForCreation model)
{
if (ModelState.IsValid)
{
//map object
var booking = _mapper.Map <Entities.Booking>(model);
//add to dbset
_bookingRepository.AddBooking(booking);
//save to database
if (await _bookingRepository.SaveChangesAsync())
{
//refecth the book
await _bookingRepository.GetBookingAsync(booking.BookingId);
return(CreatedAtRoute("GetBooking",
new { bookingId = booking.BookingId },
booking));
}
}
return(BadRequest());
}
public async Task <bool> AddBooking(Bookings bookings, short roomID)
{
return(await _bookingRepository.AddBooking(bookings, roomID));
}
public void AddBooking(string name, BookingView booking)
{
_bookingRepository.AddBooking(name, booking);
}
public bool AddBooking(BookingModel booking)
{
return(BookingRepository.AddBooking(ModelMapperService.Map <BookingModel, Booking>(booking)));
}
/// <inheritdoc />
public Task <Guid> AddBooking(BookingContract bookingContract)
{
var confirmation = await _bookingRepository.AddBooking(bookingContract);
return(confirmation);
}
public async Task <BookingResponseModel> AddBooking(BookingRequestModel model)
{
return(await _bookingRepository.AddBooking(model));
}
public async Task <IActionResult> AddBooking(BookingForCreationDto bookingForCreationDto)
{
await _bookingRepository.AddBooking(bookingForCreationDto);
return(Ok());
}
