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