public IActionResult Create([FromBody] CreateBookingModel model)
{
Booking booking = CreateBooking(model);
try
{
var parkingSetting = _parkingSettingService.GetAll().First();
for (var i = model.From; i <= model.To; i = i.AddDays(1))
{
var usedSpaces = _bookingService.GetAll(i.Date, i.Date).Count();
if (usedSpaces == parkingSetting.Spaces)
{
return(BadRequest(new { message = "No Available Spaces" }));
}
}
var response = _bookingService.Create(booking);
var responseBooking = _mapper.Map <BookingModel>(booking);
return(Ok(responseBooking));
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public Booking MakeBooking(CreateBookingModel createBookingModel)
{
var table = _tablesManager.GetFreeTable(createBookingModel.NumberOfGuests, createBookingModel.Date, createBookingModel.Hour);
if (table == null)
{
return(null);
}
Booking booking = new Booking
{
FirstName = createBookingModel.FirstName,
LastName = createBookingModel.LastName,
Email = createBookingModel.Email,
NumberOfGuests = createBookingModel.NumberOfGuests,
PhoneNumber = createBookingModel.PhoneNumber,
DateTime = createBookingModel.Date,
Table = table,
Hour = createBookingModel.Hour
};
_unitOfWork.Bookings.Add(booking);
_unitOfWork.SaveChanges();
return(booking);
}
public async Task <BookingModel> PostAsync([FromBody] CreateBookingModel model)
{
var item = await _bookingsQuery.Create(model);
var resultModel = _mapper.Map <BookingModel>(item);
return(resultModel);
}
public Booking CreateBooking(Member bookMember, Room bookedRoom,
CreateBookingModel model, List <string> usingMemberIds)
{
var entity = model.ToDest();
entity.BookMemberId = bookMember.UserId;
entity.UsingMemberIds = string.Join("\n", usingMemberIds);
PrepareCreate(entity, bookMember, bookedRoom);
return(context.Booking.Add(entity).Entity);
}
public async Task <IActionResult> CreateBooking(CreateBookingModel model)
{
model.BookingName = string.Empty;
this._webApiManager.HttpMethod = HttpMethod.Post;
this._webApiManager.BodyContent = JsonConvert.SerializeObject(model);
this._webApiManager.EndPoint = "bookings";
var response = await this._webApiManager.SendRequestAsync <BookingModel>();
return(this.Json(new { response }));
}
public async Task <IActionResult> CreateBooking(CreateBookingModel model)
{
try
{
await this.hotelBookings.CreateBooking(model.Rooms, model.NumberOfOccupents, model.DaysBooked, model.CheckInDate, this.User.Identity.Name ?? "TempUser");
return(Ok());
}
catch (Exception ex)
{
throw;
}
}
public IActionResult Check([FromBody] CreateBookingModel model)
{
try
{
Booking booking = CreateBooking(model);
var responseBooking = _mapper.Map <CheckBookingModel>(booking);
return(Ok(responseBooking));
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public CreateBookingModel CreateBookingModelWithoutInfoQuestions(CreateBookingModel createBookingModel)
{
var bookingQuestions = new List <QuestionAnswer>();
foreach (var bookingQuestion in createBookingModel.BookingQuestions)
{
if (!IsNonAnswerQuestionType(bookingQuestion))
{
bookingQuestions.Add(bookingQuestion);
}
}
createBookingModel.BookingQuestions = bookingQuestions;
return(createBookingModel);
}
public JsonResult CreateBooking(CreateBookingModel model)
{
var result = _bookingService.Create(model.AircraftAvailabilityId, model.Direction, model.BookingType,
model.DepartureId, model.ArrivalId, model.DepartureDate, model.ReturnDate, model.PassengersNum,
model.PaymentMethodId,
model.Travelers.Select(t => new CreateBookingTravelerDto()
{
Email = t.Email,
FirstName = t.FirstName,
LastName = t.LastName
}).ToList(),
model.BookingPax);
return(new JsonResult(new {
bookingNo = result.Number
}));
}
public IActionResult Create(CreateBookingModel createBookingModel)
{
if (ModelState.IsValid)
{
var booking = _bookingsManager.MakeBooking(createBookingModel);
if (booking != null)
{
return(RedirectToAction("Check", new { id = booking.Id }));
}
else
{
ModelState.AddModelError("", "Couldnt find a free table for that configuration! Try other date/hour/number of persons");
return(View(createBookingModel));
}
}
return(View(createBookingModel));
}
public async Task Handle_ReturnBooking()
{
var bookingModel = new CreateBookingModel
{
Customer = 1, Number = "WO-291471", Flight = 1, Passengers = new[] { 1 }
};
var mock = new Mock <IMediator>();
mock.Setup(m => m.Send(It.Is <GetFlightRequest>(request => request.Id == bookingModel.Flight),
default(CancellationToken)))
.ReturnsAsync(new Flight {
Id = bookingModel.Flight
});
mock.Setup(m => m.Send(It.Is <GetPersonRequest>(request => request.Id == bookingModel.Customer),
default(CancellationToken)))
.ReturnsAsync(new Person {
Id = bookingModel.Customer
});
mock.Setup(m =>
m.Send(
It.Is <GetPersonsRequest>(request =>
request.Ids.Count() == bookingModel.Passengers.Count() &&
request.Ids.All(id => bookingModel.Passengers.Contains(id))), default(CancellationToken)))
.ReturnsAsync(bookingModel.Passengers.Select(p => new Person {
Id = p
}));
var result = await new CreateBookingRequestHandler(new BookingRepository(), mock.Object,
new TestValidator <CreateBookingRequest>())
.Handle(new CreateBookingRequest(bookingModel), new CancellationToken());
Assert.Equal(bookingModel.Customer, result.Customer.Id);
Assert.Equal(bookingModel.Number, result.Number, ignoreCase: true);
Assert.Equal(bookingModel.Flight, result.Flight.Id);
Assert.Equal(bookingModel.Passengers, result.Passengers.Select(p => p.Id));
mock.Verify(m => m.Send(It.IsAny <GetFlightRequest>(), default(CancellationToken)), Times.Once);
mock.Verify(m => m.Send(It.IsAny <GetPersonRequest>(), default(CancellationToken)), Times.Once);
mock.Verify(m => m.Send(It.IsAny <GetPersonsRequest>(), default(CancellationToken)), Times.Once);
}
public async Task CreateShouldSaveNewBookingAsync()
{
// arrange
var model = new CreateBookingModel
{
BookingStatusCode = "testBooking",
SelfBooked = true,
DateOfBooking = DateTime.UtcNow.ToLocalTime(),
OtherBookingDetails = "testOtherBookingDetails"
};
// act
var result = await _bookingsQueryProcessor.Create(model);
// assert
result.BookingStatusCode.Should().Be(model.BookingStatusCode);
result.SelfBooked.Should().Be(model.SelfBooked);
result.UserEntityId.Should().Be(_currentUserEntity.Id);
_unitOfWorkMock.Verify(x => x.CommitAsync());
}
/// <summary>
/// Will Create a new booking record for the customer
/// </summary>
public async Task <bool> SaveBooking(CreateBookingModel model)
{
var uri = new Uri(BaseApiUrl + "BookingApi/Save");
try
{
var stringContent = JsonConvert.SerializeObject((NewBookingModel)model);
var response = await _client.PostAsync(uri, new StringContent(stringContent, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
return(true);
}
Debug.WriteLine(@"BAD RESPONSE FROM API");
return(false);
}
catch (Exception ex)
{
Debug.WriteLine(@"CREATE BOOKING ERROR {0}", ex.Message);
return(false);
}
}
private Booking CreateBooking(CreateBookingModel model)
{
// map model to entity
var booking = _mapper.Map <Booking>(model);
// get current user id
string authHeaderValue = Request.Headers["Authorization"];
var tokenClaims = SecurityClaimsHelper.GetClaims(authHeaderValue.Substring("Bearer ".Length).Trim(), _appSettings.Secret);
var userId = tokenClaims.Claims.Where(c => c.Type == ClaimTypes.Name).FirstOrDefault().Value;
booking.UserId = int.Parse(userId);
// get price for the period
decimal totalPrice = 0;
for (var i = booking.From; i <= booking.To; i = i.AddDays(1))
{
var price = _priceService.GetAll(i.Date, i.Date).FirstOrDefault();
totalPrice += price == null ? 0 : price.Value;
}
booking.TotalPrice = totalPrice;
return(booking);
}
public async Task <BookingEntity> Create(CreateBookingModel model)
{
var booking = new BookingEntity
{
Id = Guid.NewGuid(),
UserEntityId = _securityContext.UserEntity.Id,
BookingStatusCode = model.BookingStatusCode,
DateOfBooking = model.DateOfBooking,
OtherBookingDetails = model.OtherBookingDetails,
SelfBooked = model.SelfBooked,
CreateDate = DateTime.UtcNow.ToLocalTime(),
CreateUserId = _securityContext.UserEntity.Id.ToString(),
ModifyDate = DateTime.UtcNow.ToLocalTime(),
ModifyUserId = _securityContext.UserEntity.Id.ToString(),
IsDeleted = false,
StatusId = 1
};
_uniOfWork.Add(booking);
await _uniOfWork.CommitAsync();
return(booking);
}
public ValidationData ValidateCreateBooking(ClaimsPrincipal principal,
Member member,
CreateBookingModel model)
{
var memberQuery = _memberService.Members;
var userId = principal.Identity.Name;
var validationData = new ValidationData();
DateTime currentTime = DateTime.UtcNow;
if (!member.DepartmentMember.Any() && !member.AreaMember.Any())
{
validationData.Fail(code: AppResultCode.AccessDenied);
return(validationData);
}
if (model.BookedDate == null)
{
validationData.Fail("Booked date must not be empty", AppResultCode.FailValidation);
}
if (model.NumOfPeople == null || model.NumOfPeople == 0)
{
validationData.Fail("Number of people is not valid", AppResultCode.FailValidation);
}
else if (model.FromTime == null || model.ToTime == null)
{
validationData.Fail(mess: "From time and to time must not be empty", AppResultCode.FailValidation);
}
else if (model.FromTime >= model.ToTime)
{
validationData.Fail(mess: "Time range is not valid", AppResultCode.FailValidation);
}
else
{
var bookedTime = model.BookedDate?.AddMinutes(model.FromTime.Value.TotalMinutes);
if (currentTime >= bookedTime)
{
validationData.Fail(mess: "Booked time must be greater than current", AppResultCode.FailValidation);
}
}
if (model.UsingEmails == null || model.UsingEmails.Count == 0)
{
validationData.Fail(mess: "At lease one using email is required", AppResultCode.FailValidation);
}
else
{
var users = memberQuery.ByEmails(model.UsingEmails).Select(o => new
{
user_id = o.UserId,
email = o.Email
}).ToList();
var ids = users.Select(o => o.user_id).ToList();
var emails = users.Select(o => o.email).ToList();
var notFoundEmails = model.UsingEmails.Where(o => !emails.Contains(o)).ToList();
var notFoundEmailsList = string.Join(", ", notFoundEmails);
if (notFoundEmails.Any())
{
validationData.Fail(mess: $"One or more emails not found: {notFoundEmailsList}\n" +
$"Maybe they need to log into the application at least once", AppResultCode.FailValidation);
}
else
{
validationData.TempData["using_member_ids"] = ids;
}
}
if (validationData.IsValid)
{
var availableRoom = _roomService.Rooms.Code(model.RoomCode)
.AvailableForBooking(userId, Bookings, model.BookedDate.Value, model.FromTime.Value,
model.ToTime.Value, model.NumOfPeople.Value).FirstOrDefault();
if (availableRoom == null)
{
validationData.Fail("Room is not available for this booking", AppResultCode.FailValidation);
}
else
{
validationData.TempData["booked_room"] = availableRoom;
}
}
return(validationData);
}
public async Task <ActionResult <Booking> > Post(CreateBookingModel model)
{
return(Ok(await _mediator.Send(new CreateBookingRequest(model))));
}
public virtual ActionResult CreateAndEditEvent(CreateBookingModel createBookingModel)
{
var context = ModelFactory.GetUnitOfWork();
var oRepo = ModelFactory.GetRepository<IOfferRepository>(context);
if (ModelState.IsValid)
{
var booking = InternalCreateBooking(createBookingModel);
return Json(new { redirectToUrl = Url.Action(MVC.Backoffice.Schedule.EditBooking(booking.Id)) });
}
else
{
throw new ModelStateException(ModelState);
}
}
public virtual ActionResult CreateEvent(int id)
{
var memberId = WebHelper.GetIdentityId(User.Identity);
try
{
var context = ModelFactory.GetUnitOfWork();
var oRepo = ModelFactory.GetRepository<IOfferRepository>(context);
var offer = oRepo.Get(id);
var model = new CreateBookingModel(offer.Localisation);
model.Booking.OfferId = id;
return PartialView(MVC.Backoffice.Schedule.Views._CreateBooking, model);
}
catch (Exception ex)
{
_Logger.Error("CreateEvent", ex);
return View(MVC.Shared.Views.Error);
}
}
public virtual ActionResult CreateEvent(CreateBookingModel createBookingModel)
{
var context = ModelFactory.GetUnitOfWork();
var oRepo = ModelFactory.GetRepository<IOfferRepository>(context);
if (ModelState.IsValid)
{
var booking = InternalCreateBooking(createBookingModel);
return Json(booking.GetCalandarEvent(Url));
}
else
{
throw new ModelStateException(ModelState);
}
}
public async Task <ActionResult> CreateBooking(CreateBookingModel createBookingModel)
{
createBookingModel = CreateBookingModelWithoutInfoQuestions(createBookingModel);
if (createBookingModel.EventId <= 0)
{
throw new Exception(_localizer["AnErrorOccurred"]);
}
if (!ModelState.IsValid)
{
return(GetJsonResultFromModelStateErrors());
}
if (_bookingService.DateHasPassed(createBookingModel.StartDate) || _bookingService.DateHasPassed(createBookingModel.LastApplicationDate))
{
ModelState.AddModelError("", _localizer["BookingLastDayPassedError"]);
return(GetJsonResultFromModelStateErrors());
}
var newToken = await _token.GetNewToken();
var client = new EduAdminAPIClient.Client(newToken);
var booking = new PostBooking
{
Answers = _questionService.GetBookingAnswers(createBookingModel.BookingQuestions),
ContactPerson = new PostBookingContactPerson
{
FirstName = createBookingModel.CustomerContact?.FirstName,
LastName = createBookingModel.CustomerContact?.LastName,
Email = createBookingModel.CustomerContact?.Email
},
Customer = new PostBookingCustomer
{
CustomerName = createBookingModel.Customer?.CustomerName,
OrganisationNumber = createBookingModel.Customer?.InvoiceOrgnr,
Address = createBookingModel.Customer?.Address1,
Zip = createBookingModel.Customer?.Zip,
City = createBookingModel.Customer?.City
},
EventId = createBookingModel.EventId,
Participants = createBookingModel.Participants?.Select(x => new BookingParticipant
{
Answers = _questionService.GetBookingAnswers(x.ParticipantQuestions),
FirstName = x.FirstName,
LastName = x.LastName,
Email = x.Email,
CivicRegistrationNumber = x.CivicRegistrationNumber,
PriceNameId = x.PriceNameId != 0 ? (int?)x.PriceNameId : null,
Sessions = x.Sessions?.Where(s => s.Participating).Select(y => new BookingParticipantSession
{
SessionId = y.SessionId,
PriceNameId = y.PriceNameId
}).ToList()
}).ToList(),
SendConfirmationEmail = new SendInfoBase
{
SendToParticipants = true
},
};
BookingCreated newBooking;
try
{
newBooking = await client.Booking.PostAsync(booking);
}
catch (EduAdminApi.EduAdminException <ForbiddenResponse> ex)
{
var errorResult = ex.Result;
var errorStr = "";
foreach (var item in errorResult.Errors)
{
//If multiple errors would exist, separate these
if (!string.IsNullOrWhiteSpace(errorStr))
{
errorStr += "<br />";
}
switch (item?.ErrorCode ?? 0)
{
case 40:
//No seats left
errorStr += _localizer["NotEnoughSeatsLeft"];
break;
case 45:
//Person already booked
errorStr += _localizer["BookingContainsBookedParticipants"];
break;
case 200:
//Person exists on overlapping sessions
errorStr += _localizer["BookingContainsOverlapPersons"];
break;
default:
errorStr += _localizer["CouldntCreateBookingTryAgain"];
break;
}
}
ModelState.AddModelError("", errorStr);
return(GetJsonResultFromModelStateErrors());
}
return(Json(new CreateBookingResult
{
Success = true,
SuccessRedirectUrl = Url.Action("BookingCreated", "Booking", new { eclID = newBooking.BookingId })
}));
}
MemberBooking InternalCreateBooking(CreateBookingModel createBookingModel)
{
var context = ModelFactory.GetUnitOfWork();
var oRepo = ModelFactory.GetRepository<IOfferRepository>(context);
var memberId = WebHelper.GetIdentityId(User.Identity);
var offer = oRepo.Get(createBookingModel.Booking.OfferId);
try
{
createBookingModel.Booking.MemberBookingLogs.Add(new MemberBookingLog
{
CreatedDate = DateTime.UtcNow,
EventType = (int)MemberBookingLog.BookingEvent.Creation,
Event = "Booking Created From Calandar",
}
);
createBookingModel.Booking.InvoiceNumber = new InvoiceNumber();
if (createBookingModel.Booking.Paid)
{
createBookingModel.Booking.MemberBookingLogs.Add(new MemberBookingLog
{
CreatedDate = DateTime.UtcNow,
Event = "Payment completed",
EventType = (int)MemberBookingLog.BookingEvent.Payment,
LoggerId = memberId
});
}
offer.MemberBookings.Add(createBookingModel.Booking);
context.Commit();
var newContext = ModelFactory.GetUnitOfWork();
var bRepo = ModelFactory.GetRepository<IBookingRepository>(newContext);
var booking = bRepo.Get(createBookingModel.Booking.Id);
//send mail to client
var urlHelper = new UrlHelper(ControllerContext.RequestContext);
var dashboardUrl = urlHelper.ActionAbsolute(MVC.Dashboard.Home.Index());
TagBuilder dashboardLink = new TagBuilder("a");
dashboardLink.MergeAttribute("href", dashboardUrl);
dashboardLink.InnerHtml = dashboardUrl;
var localisationUrl = booking.Offer.Localisation.GetDetailFullUrl(Url);
TagBuilder localisationLink = new TagBuilder("a");
localisationLink.MergeAttribute("href", localisationUrl);
localisationLink.InnerHtml = localisationUrl;
var clientMailContent = string.Format(Worki.Resources.Email.BookingString.CalandarBookingCreation,
Localisation.GetOfferType(booking.Offer.Type),
booking.Offer.Localisation.Name,
booking.GetStartDate(),
booking.GetEndDate(),
dashboardLink,
booking.Price,
localisationLink);
var clientMail = _EmailService.PrepareMessageFromDefault(new MailAddress(booking.Client.Email, booking.Client.MemberMainData.FirstName),
string.Format(Worki.Resources.Email.BookingString.CalandarBookingCreationSubject, booking.Offer.Localisation.Name),
WebHelper.RenderEmailToString(booking.Client.MemberMainData.FirstName, clientMailContent));
_EmailService.Deliver(clientMail);
return booking;
}
catch (Exception ex)
{
_Logger.Error("CreateEvent", ex);
context.Complete();
throw new ModelStateException(ModelState);
}
}
public async Task <IActionResult> Create(CreateBookingModel model)
{
var memberQuery = _memberService.Members;
var member = _memberService.Members.Id(UserId).FirstOrDefault();
var validationData = _service.ValidateCreateBooking(User, member, model);
if (!validationData.IsValid)
{
return(BadRequest(AppResult.FailValidation(data: validationData)));
}
var usingMemberIds = validationData.GetTempData <List <string> >("using_member_ids");
var bookedRoom = validationData.GetTempData <Room>("booked_room");
AppEvent ev; Booking entity;
using (var trans = context.Database.BeginTransaction())
{
entity = _service.CreateBooking(member, bookedRoom, model, usingMemberIds);
var history = _service.CreateHistoryForCreateBooking(entity, member);
_roomService.ChangeRoomHangingStatus(bookedRoom, false, UserId);
//log event
ev = _sysService.GetEventForBookingProcessing(history);
_sysService.CreateAppEvent(ev);
//end log event
context.SaveChanges();
trans.Commit();
}
//notify using members, managers (if any)
var notiData = new Dictionary <string, string>
{
{ "event", ev.Type },
{ "id", entity.Id.ToString() }
};
var notiMemberIds = usingMemberIds.Where(o => o != UserId).ToList();
var notiMembers = notiMemberIds.Any() ? NotiHelper.Notify(notiMemberIds, new Notification
{
Title = $"You have a new booking",
Body = $"{UserEmail} has just created a booking of room {entity.RoomCode} for you. Press for more detail"
}, data: notiData) : Task.CompletedTask;
var managerNoti = new Notification
{
Title = $"There's a new booking request",
Body = $"{UserEmail} has just created a booking of room {entity.RoomCode}. Press for more detail"
};
if (entity.Status == BookingStatusValues.PROCESSING)
{
var managerIds = _memberService.QueryManagersOfMember(member.UserId)
.Select(o => o.UserId).ToList();
if (managerIds.Count > 0)
{
await NotiHelper.Notify(managerIds, managerNoti, data : notiData);
}
}
else if (entity.Status == BookingStatusValues.VALID)
{
var managerIds = _memberService.QueryManagersOfArea(bookedRoom.BuildingAreaCode)
.Select(o => o.UserId).ToList();
if (managerIds.Count > 0)
{
await NotiHelper.Notify(managerIds, managerNoti, data : notiData);
}
}
await notiMembers;
return(Created($"/{ApiEndpoint.BOOKING_API}/{entity.Id}",
AppResult.Success(data: entity.Id)));
}
public CreateBookingRequest(CreateBookingModel model)
{
Model = model;
}
