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