/** Creates a command object to delete a {@link Order} by its orderNumber. @param orderNumber the orderNumber of the Order to delete, see {@link Order#getOrderNumber()} @param version `the current version of the Order, see {@link Order#getVersion()} @return delete command */ static OrderDeleteCommand ofOrderNumber(final String orderNumber, final Long version) { final Versioned<Order> versioned = Versioned.of("order-number=" + urlEncode(orderNumber), version);//hack for simple reuse return of(versioned); }
/** Creates a command object to delete a {@link Order} by its orderNumber. @param orderNumber the orderNumber of the Order to delete, see {@link Order#getOrderNumber()} @param version the current version of the Order, see {@link Order#getVersion()} @param eraseData If set to {@literal true}, the commercetools platform guarantees that all personal data related to the particular object, including invisible data, is erased, in compliance with the GDPR. @return delete command */ static OrderDeleteCommand ofOrderNumber(final String orderNumber, final Long version, final boolean eraseData) { final Versioned<Order> versioned = Versioned.of("order-number=" + urlEncode(orderNumber), version);//hack for simple reuse return of(versioned, eraseData); }
public static void withOrder(final BlockingSphereClient client, final Customer customer, final Cart cart, final UnaryOperator<Order> op) { final Order updatedOrder = createOrderFromCart(client, customer, cart); final Order orderToDelete = op.apply(updatedOrder); client.executeBlocking(OrderDeleteCommand.of(orderToDelete)); }
private static void withImportedOrder(final BlockingSphereClient client, final OrderImportDraft draft, final Function<Order, Order> operator) { final Order order = client.executeBlocking(OrderImportCommand.of(draft)); final Order updatedOrder = operator.apply(order); client.executeBlocking(OrderDeleteCommand.of(updatedOrder)); }
public static void withOrder(final BlockingSphereClient client, final Customer customer, final UnaryOperator<Order> op) { withFilledCart(client, cart -> { final Order updatedOrder = createOrderFromCart(client, customer, cart); final Order orderToDelete = op.apply(updatedOrder); client.executeBlocking(OrderDeleteCommand.of(orderToDelete)); }); }
private static void delete(final BlockingSphereClient client, final CartLike<?> cartLike) { if (cartLike instanceof Cart) { final Cart cart = (Cart) cartLike; client.executeBlocking(CartDeleteCommand.of(cart)); } else { final Order order = (Order) cartLike; client.executeBlocking(OrderDeleteCommand.of(order)); } }
assertThat(order.getOrderState()).isEqualTo(OrderState.COMPLETE); client().executeBlocking(OrderDeleteCommand.of(order)); }); });
@Test public void deleteById() throws Exception { withOrder(client(), order -> { final Order deletedOrder = client().executeBlocking(OrderDeleteCommand.of(order)); final Order queriedDeletedOrder = client().executeBlocking(OrderByIdGet.of(deletedOrder)); assertThat(queriedDeletedOrder).isNull(); }); }
@Test public void deleteByIdEraseData() throws Exception { withOrder(client(), order -> { final Order deletedOrder = client().executeBlocking(OrderDeleteCommand.of(order,true)); final Order queriedDeletedOrder = client().executeBlocking(OrderByIdGet.of(deletedOrder)); assertThat(queriedDeletedOrder).isNull(); }); }
@Test public void orderFromCartDraft() { withStateByBuilder(client(), builder -> builder.type(StateType.ORDER_STATE), state -> { withFilledCart(client(), cart -> { final OrderFromCartDraft orderFromCartDraft = OrderFromCartDraftBuilder.of(cart.getId(), cart.getVersion()) .shipmentState(ShipmentState.SHIPPED) .state(state.toReference()) .orderState(OrderState.CANCELLED) .build(); final Order order = client().executeBlocking(OrderFromCartCreateCommand.of(cart).withDraft(orderFromCartDraft)); assertThat(order.getState().getId()).isEqualTo(state.getId()); assertThat(order.getOrderState()).isEqualTo(OrderState.CANCELLED); assertThat(order).isNotNull(); assertThat(order.getShipmentState()).isEqualTo(ShipmentState.SHIPPED); client().executeBlocking(OrderDeleteCommand.of(order)); }); }); } }
@Test public void execution() throws Exception { withStateByBuilder(client(), builder -> builder.type(StateType.ORDER_STATE), state -> { withFilledCart(client(), cart -> { final Order order = client().executeBlocking(OrderFromCartCreateCommand.of(cart)); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, TransitionState.of(state)) .plusExpansionPaths(OrderExpansionModel::state) .plusExpansionPaths(OrderExpansionModel::cart) ); assertThat(updatedOrder.getLineItems()).isEqualTo(cart.getLineItems()); assertThat(updatedOrder.getCustomLineItems()).isEqualTo(cart.getCustomLineItems()); assertThat(updatedOrder.getCart().getId()).isEqualTo(cart.getId()); assertThat(updatedOrder.getCart()).is(expanded()); final Cart orderedCart = updatedOrder.getCart().getObj(); assertThat(orderedCart).isNotNull(); assertThat(orderedCart.getId()).isEqualTo(cart.getId()); assertThat(orderedCart.getCartState()).isEqualTo(CartState.ORDERED); assertThat(updatedOrder.getState()).is(expanded()); //to be able to delete the state transition we have to delete the associated order. client().executeBlocking(OrderDeleteCommand.of(updatedOrder)); }); }); }
@Test public void orderDeletedMessage() throws Exception { withOrder(client(), order -> { final Order orderWithOrderNumber = client().executeBlocking(OrderUpdateCommand.of(order, SetOrderNumber.of(randomString()))); final Order deletedOrder = client().executeBlocking(OrderDeleteCommand.of(orderWithOrderNumber)); final Query<OrderDeletedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(deletedOrder)) .withExpansionPaths(m -> m.resource()) .withLimit(1L) .forMessageType(OrderDeletedMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<OrderDeletedMessage> orderDeletedMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(orderDeletedMessageOptional).isPresent(); final OrderDeletedMessage orderDeletedMessage = orderDeletedMessageOptional.get(); final Order orderFromMessage = orderDeletedMessage.getOrder(); assertThat(orderDeletedMessage.getResourceUserProvidedIdentifiers()).isNotNull(); assertThat(orderDeletedMessage.getResourceUserProvidedIdentifiers().getOrderNumber()).isEqualTo(orderWithOrderNumber.getOrderNumber()); assertThat(orderFromMessage.getId()).isEqualTo(deletedOrder.getId()); }); }); }
private void testOrderAspect(final Consumer<OrderImportDraftBuilder> orderBuilderConsumer, final Consumer<Order> orderConsumer) { withProduct(client(), product -> { final String productId = product.getId(); final int variantId = 1; final LocalizedString name = en("a name"); final long quantity = 1; final Price price = Price.of(EURO_10); final OrderState orderState = OrderState.OPEN; final MonetaryAmount amount = EURO_10; final ProductVariantImportDraft variant = ProductVariantImportDraftBuilder.of(productId, variantId).build(); final LineItemImportDraft lineItemImportDraft = LineItemImportDraftBuilder.of(variant, quantity, price, name).build(); final OrderImportDraftBuilder orderImportDraftBuilder = OrderImportDraftBuilder.ofLineItems(amount, orderState, asList(lineItemImportDraft)); orderBuilderConsumer.accept(orderImportDraftBuilder); final OrderImportDraft orderImportDraft = orderImportDraftBuilder.build(); final OrderImportCommand cmd = OrderImportCommand.of(orderImportDraft); final Order order = client().executeBlocking(cmd); orderConsumer.accept(order); client().executeBlocking(OrderDeleteCommand.of(order)); }); }
@Test public void inventoryMode() throws Exception { testOrderAspect(builder -> { builder.inventoryMode(null); }, order -> assertThat(order.getInventoryMode()).isEqualTo(InventoryMode.NONE)); withProductOfStock(client(), 5, product -> { final int variantId = 1; final String sku = product.getMasterData().getStaged().getMasterVariant().getSku(); final String productId = product.getId(); final LocalizedString name = en("a name"); final long quantity = 1; final Price price = Price.of(EURO_10); final OrderState orderState = OrderState.COMPLETE; final MonetaryAmount amount = EURO_10; final TaxCalculationMode taxCalculationMode = TaxCalculationMode.LINE_ITEM_LEVEL; final ProductVariantImportDraft variant = ProductVariantImportDraftBuilder.of(productId, variantId, sku).build(); final LineItemImportDraft lineItemImportDraft = LineItemImportDraftBuilder.of(variant, quantity, price, name).build(); final OrderImportDraft orderImportDraft = OrderImportDraftBuilder.ofLineItems(amount, orderState, asList(lineItemImportDraft)) .inventoryMode(InventoryMode.TRACK_ONLY) .taxCalculationMode(taxCalculationMode) .build(); final OrderImportCommand cmd = OrderImportCommand.of(orderImportDraft); final Order order = client().executeBlocking(cmd); assertThat(order.getInventoryMode()).isEqualTo(InventoryMode.TRACK_ONLY); assertThat(order.getTaxCalculationMode()).isEqualTo(taxCalculationMode); client().executeBlocking(OrderDeleteCommand.of(order)); }); }
public static void withNonUpdatedOrder(final BlockingSphereClient client, final Customer customer, final UnaryOperator<Order> op) { withFilledCart(client, cart -> { final TaxCategory taxCategory = TaxCategoryFixtures.defaultTaxCategory(client); final SetCustomShippingMethod shippingMethodAction = SetCustomShippingMethod.of("custom shipping method", ShippingRate.of(EURO_10), taxCategory); final SetCustomerEmail emailAction = SetCustomerEmail.of(CUSTOMER_EMAIL); final Cart updatedCart = client.executeBlocking(CartUpdateCommand.of(cart, asList(shippingMethodAction, emailAction))); final CustomerSignInCommand signInCommand = CustomerSignInCommand.of(customer.getEmail(), CustomerFixtures.PASSWORD, cart.getId()); final CustomerSignInResult signInResult = client.executeBlocking(signInCommand); final Order order = client.executeBlocking(OrderFromCartCreateCommand.of(signInResult.getCart())); final Order orderToDelete = op.apply(order); client.executeBlocking(OrderDeleteCommand.of(orderToDelete)); }); }