public static AddDelivery of(final List<DeliveryItem> items) { return of(items, Collections.<ParcelDraft>emptyList()); }
public static AddDelivery of(final List<DeliveryItem> items, final List<ParcelDraft> parcels) { return new AddDelivery(items, parcels); }
final List<DeliveryItem> items = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Address deliveryAddress = Address.of(CountryCode.DE); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(items, parcels).withAddress(deliveryAddress))); final Delivery delivery = updatedOrder.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getItems()).isEqualTo(items);
final List<DeliveryItem> items = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Address deliveryAddress = Address.of(CountryCode.DE); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(items, parcels).withAddress(deliveryAddress))); final Delivery delivery = updatedOrder.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getItems()).isEqualTo(items);
public static AddDelivery of(final List<DeliveryItem> items) { return of(items, Collections.<ParcelDraft>emptyList()); }
public static AddDelivery of(final List<DeliveryItem> items, final List<ParcelDraft> parcels) { return new AddDelivery(items, parcels,null); }
public static AddDelivery of(final List<DeliveryItem> items) { return of(items, Collections.<ParcelDraft>emptyList()); }
public static AddDelivery of(final List<DeliveryItem> items, final List<ParcelDraft> parcels) { return new AddDelivery(items, parcels); }
public static AddDelivery of(final List<DeliveryItem> items) { return of(items, Collections.<ParcelDraft>emptyList()); }
public static AddDelivery of(final List<DeliveryItem> items, final List<ParcelDraft> parcels) { return new AddDelivery(items, parcels,null); }
public static void withOrderAndReturnInfo(final BlockingSphereClient client, final BiFunction<Order, ReturnInfo, Order> f) { withOrder(client, order -> { Assertions.assertThat(order.getReturnInfo()).isEmpty(); final String lineItemId = order.getLineItems().get(0).getId(); final List<LineItemReturnItemDraft> items = asList(LineItemReturnItemDraft.of(1L, lineItemId, ReturnShipmentState.RETURNED, "foo bar")); final AddReturnInfo action = AddReturnInfo.of(items); final AddDelivery addDelivery = AddDelivery.of(asList(DeliveryItem.of(lineItemId, 1))); final Order updatedOrder = client.executeBlocking(OrderUpdateCommand.of(order, asList(action, addDelivery))); final ReturnInfo returnInfo = updatedOrder.getReturnInfo().get(0); return f.apply(updatedOrder, returnInfo); }); } }
public AddDelivery withAddress(@Nullable final Address address) { return new AddDelivery(items, parcels, address); }
@Test public void testDeliveriesAndParcels() { withOrder(client(), order -> { assertThat(order.getLineItems()).hasSize(1); assertThat(order.getShippingInfo().getDeliveries()).isEmpty(); final LineItem lineItem = order.getLineItems().get(0); Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(asList(DeliveryItem.of(lineItem))))); assertThat(updatedOrder.getShippingInfo().getDeliveries()).hasSize(1); Delivery delivery = updatedOrder.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getParcels()).isEmpty(); final ParcelMeasurements parcelMeasurements = ParcelMeasurements.of(2, 3, 1, 3); Order updatedOrder2 = client().executeBlocking(OrderUpdateCommand.of(updatedOrder, AddParcelToDelivery.of(delivery, ParcelDraft.of(parcelMeasurements)))); assertThat(updatedOrder2.getShippingInfo().getDeliveries().get(0).getParcels()).hasSize(1); Parcel parcel = updatedOrder2.getShippingInfo().getDeliveries().get(0).getParcels().get(0); assertThat(parcel.getMeasurements()).isEqualTo(parcelMeasurements); return updatedOrder2; }); }
public AddDelivery withAddress(@Nullable final Address address) { return new AddDelivery(items, parcels, address); }
@Test public void removeParcelFromDelivery() throws Exception { withOrder(client(), order -> { final List<ParcelDraft> parcels = asList(ParcelDraft.of(SMALL_PARCEL_MEASUREMENTS, TRACKING_DATA)); final LineItem lineItem = order.getLineItems().get(0); final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); assertThat(orderWithDelivery.getShippingInfo().getDeliveries()).hasSize(1); final Delivery delivery = orderWithDelivery.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getParcels()).hasSize(1); final Parcel parcel = delivery.getParcels().get(0); final Order orderWithoutParcel = client().executeBlocking(OrderUpdateCommand.of(orderWithDelivery, RemoveParcelFromDelivery.of(parcel.getId()))); assertThat(orderWithoutParcel.getShippingInfo().getDeliveries()).hasSize(1); final Delivery deliveryWithoutParcel = orderWithoutParcel.getShippingInfo().getDeliveries().get(0); assertThat(deliveryWithoutParcel.getParcels()).isEmpty(); //you can observe a message final Query<ParcelRemovedFromDeliveryMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(ParcelRemovedFromDeliveryMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<ParcelRemovedFromDeliveryMessage> parcelRemovedFromDeliveryMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(parcelRemovedFromDeliveryMessageOptional).isPresent(); final ParcelRemovedFromDeliveryMessage parcelRemovedFromDeliveryMessage = parcelRemovedFromDeliveryMessageOptional.get(); assertThat(parcelRemovedFromDeliveryMessage.getDeliveryId()).isEqualTo(delivery.getId()); assertThat(parcelRemovedFromDeliveryMessage.getParcel()).isEqualTo(parcel); }); }); }
@Test public void setParcelTrackingData() throws Exception { withOrder(client(), order -> { final List<ParcelDraft> parcels = asList(ParcelDraft.of(SMALL_PARCEL_MEASUREMENTS, TRACKING_DATA)); final LineItem lineItem = order.getLineItems().get(0); final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); final Parcel parcel = orderWithDelivery.getShippingInfo().getDeliveries().get(0).getParcels().get(0); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(orderWithDelivery, SetParcelTrackingData.of(parcel.getId(), OTHER_TRACKING_DATA))); final Parcel updatedParcel = updatedOrder.getShippingInfo().getDeliveries().get(0).getParcels().get(0); assertThat(updatedParcel.getTrackingData()).isEqualTo(OTHER_TRACKING_DATA); //you can observe a message final Query<ParcelTrackingDataUpdatedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(ParcelTrackingDataUpdatedMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<ParcelTrackingDataUpdatedMessage> parcelTrackingDataUpdatedMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(parcelTrackingDataUpdatedMessageOptional).isPresent(); final ParcelTrackingDataUpdatedMessage parcelTrackingDataUpdatedMessage = parcelTrackingDataUpdatedMessageOptional.get(); assertThat(parcelTrackingDataUpdatedMessage.getParcelId()).isEqualTo(parcel.getId()); assertThat(parcelTrackingDataUpdatedMessage.getTrackingData()).isEqualTo(OTHER_TRACKING_DATA); }); }); }
final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); final Delivery delivery = orderWithDelivery.getShippingInfo().getDeliveries().get(0);
@Test public void setParcelMeasurements() throws Exception { withOrder(client(), order -> { final List<ParcelDraft> parcels = asList(ParcelDraft.of(SMALL_PARCEL_MEASUREMENTS, TRACKING_DATA)); final LineItem lineItem = order.getLineItems().get(0); final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); final Parcel parcel = orderWithDelivery.getShippingInfo().getDeliveries().get(0).getParcels().get(0); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(orderWithDelivery, SetParcelMeasurements.of(parcel.getId(), PARCEL_MEASUREMENTS))); final Parcel updatedParcel = updatedOrder.getShippingInfo().getDeliveries().get(0).getParcels().get(0); assertThat(updatedParcel.getMeasurements()).isEqualTo(PARCEL_MEASUREMENTS); //you can observe a message final Query<ParcelMeasurementsUpdatedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(ParcelMeasurementsUpdatedMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<ParcelMeasurementsUpdatedMessage> parcelMeasurementsUpdatedMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(parcelMeasurementsUpdatedMessageOptional).isPresent(); final ParcelMeasurementsUpdatedMessage parcelMeasurementsUpdatedMessage = parcelMeasurementsUpdatedMessageOptional.get(); assertThat(parcelMeasurementsUpdatedMessage.getParcelId()).isEqualTo(parcel.getId()); assertThat(parcelMeasurementsUpdatedMessage.getMeasurements()).isEqualTo(PARCEL_MEASUREMENTS); }); }); }
@Test public void setParcelItems() throws Exception { withOrder(client(), order -> { final List<ParcelDraft> parcels = asList(ParcelDraft.of(SMALL_PARCEL_MEASUREMENTS, TRACKING_DATA)); final LineItem lineItem = order.getLineItems().get(0); final long availableItemsToShip = 1; final List<DeliveryItem> initialItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(initialItems, parcels))); final Parcel parcel = orderWithDelivery.getShippingInfo().getDeliveries().get(0).getParcels().get(0); final List<DeliveryItem> parcelItems = asList(DeliveryItem.of(lineItem, availableItemsToShip)); final Order updatedOrder = client().executeBlocking(OrderUpdateCommand.of(orderWithDelivery, SetParcelItems.of(parcel.getId(), parcelItems))); final Parcel updatedParcel = updatedOrder.getShippingInfo().getDeliveries().get(0).getParcels().get(0); assertThat(updatedParcel.getItems()).hasSize(1); assertThat(updatedParcel.getItems()).isEqualTo(parcelItems); //you can observe a message final Query<ParcelItemsUpdatedMessage> messageQuery = MessageQuery.of() .withPredicates(m -> m.resource().is(order)) .forMessageType(ParcelItemsUpdatedMessage.MESSAGE_HINT); assertEventually(() -> { final Optional<ParcelItemsUpdatedMessage> parcelItemsUpdatedMessageOptional = client().executeBlocking(messageQuery).head(); assertThat(parcelItemsUpdatedMessageOptional).isPresent(); final ParcelItemsUpdatedMessage parcelItemsUpdatedMessage = parcelItemsUpdatedMessageOptional.get(); assertThat(parcelItemsUpdatedMessage.getParcelId()).isEqualTo(updatedParcel.getId()); assertThat(parcelItemsUpdatedMessage.getItems()).isEqualTo(parcelItems); assertThat(parcelItemsUpdatedMessage.getDeliveryId()).isEqualTo(updatedOrder.getShippingInfo().getDeliveries().get(0).getId()); }); }); }
final LineItem lineItem = order.getLineItems().get(0); final List<DeliveryItem> items = asList(DeliveryItem.of(lineItem)); final Order orderWithDelivery = client().executeBlocking(OrderUpdateCommand.of(order, AddDelivery.of(items))); final Delivery delivery = orderWithDelivery.getShippingInfo().getDeliveries().get(0); assertThat(delivery.getParcels()).isEmpty();