/** * Searches for an existing cart the platform otherwise the stage contains a {@link CartNotFoundException}. * A cart will not be created if it does not exist. * @return stage with the cart in session, or {@link CartNotFoundException} */ protected CompletionStage<Cart> requireExistingCart() { return findCart() .thenApplyAsync(cartOptional -> cartOptional .orElseThrow(CartNotFoundException::new), defaultContext()); }
@Override public CompletionStage<?> onCustomerSignInResultLoaded(final CustomerSignInResult customerSignInResult) { return Optional.ofNullable(customerSignInResult.getCart()) .map(cart -> updateCartWithMissingInfoOnSignIn(cart, customerSignInResult.getCustomer())) .orElseGet(() -> completedFuture(null)) .thenAcceptAsync(this::overwriteCartInSession, HttpExecution.defaultContext()); }
@Override public CompletionStage<Optional<Cart>> findCart(final Void unused) { final CompletionStage<Optional<Cart>> cartStage = fetchCart(); cartStage.thenAcceptAsync(cartOpt -> cartOpt.ifPresent(cart -> CartLoadedHook.runHook(hookContext, cart)), HttpExecution.defaultContext()); return cartStage; }
@Override public CompletionStage<Optional<Customer>> findCustomer(final Void unused) { final CompletionStage<Optional<Customer>> customerStage = fetchCustomer(); customerStage.thenAcceptAsync(customerOpt -> customerOpt.ifPresent(customer -> CustomerLoadedHook.runHook(hookContext, customer)), HttpExecution.defaultContext()); return customerStage; }
@SunriseRoute("processDeleteLineItemForm") public CompletionStage<Result> removeLineItem(final String languageTag) { return doRequest(() -> { logger.debug("process remove line item form in locale={}", languageTag); return doRequest(() -> findCart() .thenComposeAsync(cartOptional -> cartOptional .map(this::validateForm) .orElseGet(this::redirectToCartDetail), HttpExecution.defaultContext())); }); }
@SunriseRoute("processChangeLineItemQuantityForm") public CompletionStage<Result> changeLineItemQuantity(final String languageTag) { return doRequest(() -> findCart() .thenComposeAsync(cartOptional -> cartOptional .map(this::validateForm) .orElseGet(this::redirectToCartDetail), HttpExecution.defaultContext())); }
@SunriseRoute("checkoutThankYouPageCall") public CompletionStage<Result> show(final String languageTag) { return doRequest(() -> findLastOrder(). thenComposeAsync(orderOpt -> orderOpt .map(this::handleFoundOrder) .orElseGet(this::handleNotFoundOrder), defaultContext())); }
protected CompletionStage<Cart> requireNonEmptyCart() { return requireExistingCart() .thenApplyAsync(cart -> { if (cart.getLineItems().isEmpty()) { throw new CartEmptyException(cart); } else { return cart; } }, defaultContext()); }
default CompletionStage<Result> showForm(final T context) { final Form<? extends F> form = createNewFilledForm(context); return renderPage(form, context, null) .thenApplyAsync(Results::ok, HttpExecution.defaultContext()); }
default CompletionStage<Result> handleValidForm(final Form<? extends F> form, final T context) { final CompletionStage<Result> resultStage = doAction(form.get(), context) .thenComposeAsync(result -> handleSuccessfulAction(form.get(), context, result), HttpExecution.defaultContext()); return recoverWith(resultStage, throwable -> handleFailedAction(form, context, throwable), HttpExecution.defaultContext()); }
@SunriseRoute("showCart") public CompletionStage<Result> show(final String languageTag) { return doRequest(() -> findCart() .thenApplyAsync(cartOptional -> pageContentFactory.create(cartOptional.orElse(null)), defaultContext()) .thenComposeAsync(pageContent -> asyncOk(renderPageWithTemplate(pageContent, getTemplateName())), HttpExecution.defaultContext())); } }
@SunriseRoute("checkoutAddressesProcessFormCall") @SuppressWarnings("unused") public CompletionStage<Result> process(final String languageTag) { return doRequest(() -> loadCartWithPreconditions().thenComposeAsync(this::validateForm, HttpExecution.defaultContext())); }
@SuppressWarnings("unused") @SunriseRoute("processAddProductToCartForm") public CompletionStage<Result> addProductToCart(final String languageTag) { return doRequest(() -> getOrCreateCart().thenComposeAsync(this::validateForm, defaultContext())); }
@SunriseRoute("checkoutPaymentPageCall") public CompletionStage<Result> show(final String languageTag) { return doRequest(() -> loadCartWithPreconditions().thenComposeAsync(this::showForm, defaultContext())); }
protected CompletionStage<Cart> executeCartUpdateCommandWithHooks(final CartUpdateCommand cmd) { final CartUpdateCommand command = CartUpdateCommandHook.runHook(hooks(), cmd); final CompletionStage<Cart> cartAfterOriginalCommandStage = sphere().execute(command); return cartAfterOriginalCommandStage .thenComposeAsync(cart -> CartUpdatedActionHook.runHook(hooks(), cart, cmd), defaultContext()) .thenApplyAsync(cart -> { CartUpdatedHook.runHook(hooks(), cart); return cart; }, defaultContext()); }
default CompletionStage<Result> validateForm(final T context) { return bindForm().thenComposeAsync(form -> { if (!form.hasErrors()) { return handleValidForm(form, context); } else { return handleInvalidForm(form, context); } }, HttpExecution.defaultContext()); }
private CompletionStage<Order> createOrder(final Cart cart) { final String orderNumber = generateOrderNumber(); final OrderFromCartDraft orderDraft = OrderFromCartDraft.of(cart, orderNumber, orderInitialPaymentState(cart)); return sphere().execute(OrderFromCartCreateCommand.of(orderDraft)) .thenApplyAsync(order -> { injector().getInstance(OrderInSession.class).store(order); injector().getInstance(CartInSession.class).remove(); return order; }, defaultContext()); } }
public CompletionStage<Result> showHealth() throws IOException { final ProductProjectionSearch productRequest = ProductProjectionSearch.ofCurrent().withLimit(1); return sphere.execute(productRequest) .thenApplyAsync(this::renderGoodHealthStatus, HttpExecution.defaultContext()) .exceptionally(this::renderBadHealthStatus) .thenApply(result -> result.as(Http.MimeTypes.JSON)); }
protected CompletionStage<Optional<Order>> findOrderById(final String orderId) { final OrderByIdGet baseRequest = OrderByIdGet.of(orderId).plusExpansionPaths(m -> m.paymentInfo().payments()); final OrderByIdGet orderByIdGet = OrderByIdGetHook.runHook(hooks(), baseRequest); return sphere().execute(orderByIdGet) .thenApplyAsync(nullableOrder -> { if (nullableOrder != null) { OrderLoadedHook.runHook(hooks(), nullableOrder); } return Optional.ofNullable(nullableOrder); }, defaultContext()); }
protected CompletionStage<Html> renderPageWithTemplate(final PageContent pageContent, final String templateName, @Nullable final CmsPage cmsPage) { final SunrisePageData pageData = createPageData(pageContent); return hooks().allAsyncHooksCompletionStage().thenApplyAsync(unused -> { PageDataReadyHook.runHook(hooks(), pageData); logFinalPageData(pageData); final TemplateContext templateContext = new TemplateContext(pageData, userContext.locales(), cmsPage); final String html = templateEngine().render(templateName, templateContext); return new Html(html); }, HttpExecution.defaultContext()); }