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