public async Task <Unit> Handle(CreateBookingRequestCommand request, CancellationToken cancellationToken) { var customerId = new CustomerId(request.CustomerId); var facilityId = new FacilityId(request.FacilityId); var offerIds = request.BookedRecords.Select(r => new OfferId(r.OfferId)); var offers = await offerRepository.GetByIdsAsync(offerIds); var bookedRecords = MappBookedRecords(request, offers); var booking = Booking.CreateRequested( customerId, facilityId, bookedRecords ); await bookingRepository.AddAsync(booking); await unitOfWork.CommitAsync(); var sendEndpoint = await sendEndpointProvider.GetSendEndpoint(new Uri($"exchange:{request.EventBusExchanges[EventBusExchange.BookingRequests]}")); await sendEndpoint.Send(new BookingRequested( facilityId, booking.Id) ); return(Unit.Value); }
public async Task Booking(BookingDto booking) { if (booking == null) { throw new ArgumentNullException(ErrorMessage.BookingDetailsIsEmpty); } var employeeId = await GetEmployeeDetails(booking); var roombookings = AutoMapper.Mapper.Map <IEnumerable <BookingDto> >(await _bookingRepository.GetAsync(booking.RoomId)); var isAvailable = _bookingValidation.IsRoomAvailable(roombookings, booking.StartDateTime, booking.EndDateTime); if (!isAvailable) { throw new Exception(ErrorMessage.RoomNotAvailable); } var bookingEntity = new Booking { EmployeeId = employeeId, RoomId = booking.RoomId, StartTime = booking.StartDateTime, EndTime = booking.EndDateTime }; await _bookingRepository.AddAsync(bookingEntity); await _bookingRepository.SaveAsync(); }
public async Task <IActionResult> PostBooking([FromRoute] int venueId, [FromRoute] int sportId, [FromBody] Booking booking) { booking.FacilityId = getFacility(venueId, sportId, booking); if (DateTime.Compare(booking.BookingDateTime, DateTime.Now) <= 0) { ModelState.AddModelError("BookingDateTime", "Date/Time is in the past. Please enter future Date/Time."); } if (booking.FacilityId == -1) { ModelState.AddModelError("BookingDateTime", "Date/Time is no longer available. Please try again."); } if (!ModelState.IsValid) { return(BadRequest(ModelState)); } booking.EndBookingDateTime = booking.BookingDateTime.AddHours(1); await bookingRepository.AddAsync(booking); var newBooking = await bookingRepository.GetAllAsync().Include(b => b.Facility.Sport) .Include(b => b.Facility.Venue) .Include(b => b.Facility) .FirstOrDefaultAsync(b => b.BookingId.Equals(booking.BookingId)); return(CreatedAtAction("GetBooking", new { id = booking.BookingId }, newBooking)); }
public async Task <BookingResponse> SaveAsync(Booking booking) { int inexistentRoomID = await RoomsExist(booking.Rooms); if (inexistentRoomID != int.MinValue) { return(new BookingResponse($"Room ID:{ inexistentRoomID } does not exist")); } try { await _bookingRepository.AddAsync(booking); await _unitOfWork.CompleteAsync(); booking.Rooms = await _bookingRoomRepository.ListByBookingID(booking.ID); return(new BookingResponse(booking)); } catch (Exception e) { //TODO - Log the exception return(new BookingResponse("An error ocurred while saving the Booking: " + $"{ e.Message } { e.InnerException?.Message }")); } }
public async Task <IActionResult> Create(BookingCreateViewModel model) { if (ModelState.IsValid) { var booking = new Booking { FirstName = model.FirstName, LastName = model.LastName, Mobile = model.Mobile, DateBooked = model.DateBooked, TimeBooked = model.TimeBooked, NumberinParty = model.NumberinParty, Status = model.Status, Method = model.Method, TableNo = model.TableNo, DateCreated = DateTime.Now, }; await repository.AddAsync(booking); await unitOfWork.CompleteAsync(); return(RedirectToAction("details", new { id = booking.Id })); } return(View()); }
public async Task <BookingResponseModel> AddBooking(BookingRequestModel bookingRequest) { var booking = _mapper.Map <Booking>(bookingRequest); booking.Status = "pending"; var response = await _bookingRepository.AddAsync(booking); return(_mapper.Map <BookingResponseModel>(response)); }
private async Task <IActionResult> MakeBook(int?id, DateTime dateFrom, DateTime dateTo) { var userId = _userRepository.FindByNameAsync(HttpContext.User.Identity.Name).Result.Id; var dto = new BookingDTO { RoomId = id.Value, UserId = userId, DateFrom = dateFrom, DateTo = dateTo }; await _bookingRepository.AddAsync(dto); return(RedirectToAction("Index", "Booking")); }
public async Task <IActionResult> CreateBlockFacility([Bind("BookingId,FacilityId,BookingDateTime,UserId,EndBookingDateTime")] Booking booking, [Bind("VenueId")] int VenueId, [Bind("SportId")] int SportId) { booking.IsBlock = true; booking.UserId = GetUserId(); var bookings = bookingRepository.GetAllAsync().Where(b => b.FacilityId.Equals(booking.FacilityId)); if (DateTime.Compare(booking.BookingDateTime, DateTime.Now) <= 0) { ModelState.AddModelError("BookingDateTime", "Date/Time is in the past. Please enter future Date/Time."); } if (DateTime.Compare(booking.EndBookingDateTime, booking.BookingDateTime) <= 0) { ModelState.AddModelError("EndBookingDateTime", "End Date/Time should be after the start Date/Time. Please re-enter Date/Time."); } if (ModelState.IsValid) { foreach (Booking b in bookings) { //true if (new booking start time is before old booking start time) AND if (new booking end time is after old booking end time) if (DateTime.Compare(booking.BookingDateTime, b.BookingDateTime) <= 0 && DateTime.Compare(b.BookingDateTime, booking.EndBookingDateTime.AddHours(-1)) <= 0 && !b.IsBlock) { bookingRepository.DeleteAsync(b); await auditLogger.log(GetUserId(), $"Deleted booking: {b.BookingId} owned by {b.UserId}"); } } booking = await bookingRepository.AddAsync(booking); await auditLogger.log(GetUserId(), $"created blocking: {booking.BookingId}"); return(RedirectToAction(nameof(Index))); } ViewData["VenueId"] = new SelectList(venueRepository.GetAllAsync(), "VenueId", "VenueName"); ViewData["FacilityId"] = new SelectList(facilityRepository.GetAllAsync(), "FacilityId", "FacilityName"); ViewData["SportId"] = new SelectList(sportRepository.GetAllAsync(), "SportId", "SportName"); return(View(booking)); }
public async Task <ActionResult <BookingDTO> > CreateBooking(BookingDTO bookingDTO) { var booking = _mapper.Map <BookingDTO, Booking>(bookingDTO); booking.Status = BookingStatus.Booked; booking.BookingDate = DateTime.Now; await _bookingRepo.AddAsync(booking); bookingDTO = _mapper.Map <Booking, BookingDTO>(booking); CreateBookingMessage message = _mapper.Map <Booking, CreateBookingMessage>(booking); await _bus.Publish(message); return(CreatedAtAction(nameof(GetBooking), new { id = booking.BookingId }, bookingDTO)); }
public async Task CreateAsync(Booking booking) { try { if (booking.Id == null) { booking.Id = Guid.NewGuid().ToString(); await _bookingRepository.AddAsync(booking); await _hubContext.Clients.All.SendAsync("CreateProduct", booking); } } catch (Exception ex) { _logger.LogError(ex.ToString()); } }
public async Task Consume(ConsumeContext <ProcessBookingOrder> context) { var booking = Booking.Domain.Bookings.Booking.CreateBooked( context.Message.CustomerId, context.Message.FacilityId, context.Message.BookedRecords.Select(r => new BookedRecordData( r.EmployeeId, r.OfferId, Money.Of(50, "PLN"), r.Date, 60 )).ToList() ); await repository.AddAsync(booking); await unitOfWork.CommitAsync(); }
public async Task <Guid> Handle(BookAccommodationCommand request, CancellationToken cancellationToken) { var accommodation = await facilityDataSource.FindAccommodationAsync(request.AccommodationId); if (accommodation == null) { throw new AccommodationNotFoundException(request.AccommodationId); } var facility = await facilityDataSource.FindFacilityAsync(accommodation.FacilityId); var bookingRecord = BookingRecord.NewBooking(accommodation, facility, request.FromDate, request.ToDate, securityContext); await bookingRepository.AddAsync(bookingRecord); await bookingRepository.SaveChangesAsync(bookingRecord, commandContext); return(bookingRecord.Id); }
public async Task <BookingResponse> SaveAsync(BookingSaveResource bookingSaveResource) { try { BookingResponse bookingResponse = await CommonValidations(bookingSaveResource); if (bookingResponse != null) { return(bookingResponse); } var item = _mapper.Map <BookingSaveResource, Booking>(bookingSaveResource); await _bookingRepository.AddAsync(item); var responseResource = _mapper.Map <Booking, BookingResource>(item); return(new BookingResponse(responseResource)); } catch (Exception ex) { return(new BookingResponse(400, "Unexpected error", "Error", ex.Message)); } }
public async Task <BookingResponseModel> AdminBookTable(BookingRequestModel bookingRequest) { if (bookingRequest == null) { return(new BookingResponseModel { Success = false, ErrorMessage = "Bad request" }); } if (bookingRequest.Seats <= 0 || bookingRequest.Seats > 9) { return(new BookingResponseModel { Success = false, ErrorMessage = "Bad number of seats" }); } var nameGreaterThan1 = bookingRequest.CustomerName.Length <= 1 ? true : false; var nameNotLongerThan50 = bookingRequest.CustomerName.Length > 50 ? true : false; var phoneNotShorterThan6 = bookingRequest.PhoneNumber.Length < 6 ? true : false; var phoneNotLongerThan25 = bookingRequest.PhoneNumber.Length > 25 ? true : false; if (nameGreaterThan1 || nameNotLongerThan50 || phoneNotShorterThan6 || phoneNotLongerThan25) { return(new BookingResponseModel { Success = false, ErrorMessage = "Invalid name or phone number" }); } bookingRequest.Time = bookingRequest.Time.AddMilliseconds(-bookingRequest.Time.Millisecond); bookingRequest.Time = bookingRequest.Time.AddSeconds(-bookingRequest.Time.Second); var now = DateTime.Now.AddMinutes(-5); now = now.AddMilliseconds(-now.Millisecond); now = now.AddSeconds(-now.Second - 1); if (bookingRequest.Time < now) { return(new BookingResponseModel { Success = false, ErrorMessage = "Can't make a booking in the past" }); } List <Booking> bookingsOnDate; List <Table> tables; try { bookingsOnDate = await _bookingRepository.GetByDate(bookingRequest.Time); tables = await _tableRepository.GetAll(); } catch (Exception) { // logg error return(new BookingResponseModel { Success = false, ErrorMessage = "Error connecting to database" }); } List <Table> freeTables = new List <Table>(); List <Booking> bookingsDuring2hInterval = new List <Booking>(); foreach (var oldBooking in bookingsOnDate) { var newBookingStart = bookingRequest.Time.AddMinutes(1); var newBookingEnd = bookingRequest.Time.AddHours(2).AddMinutes(-1); var oldBookingStart = oldBooking.Time.AddMinutes(1); var oldBookingEnd = oldBooking.Time.AddHours(2).AddMinutes(-1); var sameTimeHour = bookingRequest.Time.Hour == oldBooking.Time.Hour; var sameTimeMinute = bookingRequest.Time.Minute == oldBooking.Time.Minute; // if these are true add to interval var overlapOldBookingFirst = newBookingStart <oldBookingEnd && newBookingStart> oldBookingStart; var overlapNewBookingFirst = newBookingEnd > oldBookingStart && newBookingEnd < oldBookingEnd; if (overlapNewBookingFirst || overlapOldBookingFirst || (sameTimeHour && sameTimeMinute)) { bookingsDuring2hInterval.Add(oldBooking); } } foreach (var table in tables) { if (!bookingsDuring2hInterval.Any(b => b.Table.Id == table.Id)) { freeTables.Add(table); } } freeTables.Sort((x, y) => x.Seats.CompareTo(y.Seats)); Table selectedTable = null; if (!freeTables.Any()) { return(new BookingResponseModel { Success = false, ErrorMessage = "No table available" }); } ; foreach (var table in freeTables) { if (bookingRequest.Seats <= table.Seats) { selectedTable = table; break; } } if (selectedTable == null) { return(new BookingResponseModel { Success = false, ErrorMessage = "No table available with correct amount of seats" }); } Booking booking = new Booking { Seats = bookingRequest.Seats, PhoneNumber = bookingRequest.PhoneNumber, CustomerName = bookingRequest.CustomerName, Time = bookingRequest.Time, Email = bookingRequest.Email, Table = selectedTable }; try { await _bookingRepository.AddAsync(booking); } catch (Exception) { // log error and method return(new BookingResponseModel { Success = false, ErrorMessage = "Error connecting to database" }); } return(new BookingResponseModel { Success = true }); }
public async Task <int> Book(Booking booking) { return(await _bookingRepository.AddAsync(booking)); }
public async Task <int> AddBooking(ApplicationDbContext dbContext, Booking booking) { booking.ID = Guid.NewGuid(); return(await BookingRepository.AddAsync(dbContext, booking)); }
public async Task <ServiceResponse <BookingInfo> > CreateAsync(BookingRequest request, bool isProduction = true) { Log.Information("BookingService processing request for CreateAsync {@request}", request); if (request.CheckInDate.Date < DateTime.Now.Date) { return(new ServiceResponse <BookingInfo>("Check in date cannot be set earlier than today.")); } if (request.CheckOutDate.Date <= DateTime.Now.Date) { return(new ServiceResponse <BookingInfo>("Check out date cannot be set earlier than today.")); } if (request.CheckInDate.Date >= request.CheckOutDate.Date) { return(new ServiceResponse <BookingInfo>("Check out date cannot occur before or same date as Check in date.")); } var query = repo.GetUnavailableRoomIds(new RoomAvailabilityRequest { CheckInDate = request.CheckInDate, CheckOutDate = request.CheckOutDate }); var availableroom = repo.GetAvailableRooms(query) .Where(e => e.Beds == request.Beds && e.DoubleBeds == request.DoubleBeds).FirstOrDefault(); if (availableroom == null) { return(new ServiceResponse <BookingInfo>("Found no room with requested specifications.")); } var entity = request.ToDomain(); entity.Room = availableroom; try { await repo.AddAsync(entity); await repo.Complete(); } catch (Exception ex) { Log.Error("Could not create new Booking {@Message}", ex.Message); return(new ServiceResponse <BookingInfo>($"Could not create new Booking: {ex.Message}")); } if (!isProduction) { return(new ServiceResponse <BookingInfo>(entity.ToDto())); } try { emailService.SendMessage(entity); } catch (Exception e) { string msg = "Mail cannot be sent"; msg += e.Message; Log.Debug("Error: Inside catch block of Mail sending"); Log.Error("Error msg:" + e); Log.Error("Stack trace:" + e.StackTrace); } return(new ServiceResponse <BookingInfo>(entity.ToDto())); }