function it_applies_calculated_shipping_charge_for_each_shipment_associated_with_the_order( $adjustmentRepository, $calculator, AdjustmentInterface $adjustment, OrderInterface $order, ShipmentInterface $shipment, ShippingMethodInterface $shippingMethod ) { $adjustmentRepository->createNew()->willReturn($adjustment); $order->getShipments()->willReturn(array($shipment)); $calculator->calculate($shipment)->willReturn(450); $shipment->getMethod()->willReturn($shippingMethod); $shippingMethod->getName()->willReturn('FedEx'); $adjustment->setAmount(450)->shouldBeCalled(); $adjustment->setType(AdjustmentInterface::SHIPPING_ADJUSTMENT)->shouldBeCalled(); $adjustment->setDescription('FedEx')->shouldBeCalled(); $order->removeAdjustments(AdjustmentInterface::SHIPPING_ADJUSTMENT)->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $order->calculateTotal()->shouldBeCalled(); $this->applyShippingCharges($order); }
/** * Update order's shipping state. * * @param OrderInterface $order * @param string $transition */ public function updateOrderShipmentStates(OrderInterface $order, $transition = ShipmentTransitions::SYLIUS_PREPARE) { if ($order->isBackorder()) { $transition = ShipmentTransitions::SYLIUS_BACKORDER; } $this->processor->updateShipmentStates($order->getShipments(), $transition); }
/** * @param OrderInterface $order */ public function updateOrderShippingState(OrderInterface $order) { foreach ($order->getShipments() as $shipment) { if ($this->factory->get($shipment, ShipmentTransitions::GRAPH)->can(ShipmentTransitions::SYLIUS_SHIP)) { return; } } $this->factory->get($order, OrderTransitions::GRAPH)->apply(OrderTransitions::SYLIUS_SHIP, true); }
function it_does_not_update_order_state_if_one_shipment_is_not_shipped($factory, ShipmentInterface $shipment, OrderInterface $order, StateMachineInterface $sm1, StateMachineInterface $sm2) { $order->getShipments()->willReturn(array($shipment)); $factory->get($order, OrderTransitions::GRAPH)->willReturn($sm1); $factory->get($shipment, ShipmentTransitions::GRAPH)->willReturn($sm2); $sm2->can(ShipmentTransitions::SYLIUS_SHIP)->shouldBeCalled()->willReturn(false); $sm1->apply(OrderTransitions::SYLIUS_SHIP, true)->shouldBeCalled(); $this->updateOrderShippingState($order); }
function it_marks_order_as_returned_if_all_shipments_were_returned(OrderInterface $order, ShipmentInterface $shipment1, ShipmentInterface $shipment2) { $order->isBackorder()->shouldBeCalled()->willReturn(false); $order->getShipments()->willReturn(array($shipment1, $shipment2)); $shipment1->getState()->willReturn(ShipmentInterface::STATE_RETURNED); $shipment2->getState()->willReturn(ShipmentInterface::STATE_RETURNED); $order->setShippingState(OrderShippingStates::RETURNED)->shouldBeCalled(); $this->resolveShippingState($order); }
/** * Update order shipping state. * * @param OrderInterface $order */ public function updateOrderShippingState(OrderInterface $order) { // Check if all shipments are shipped (= transition "ship" cannot be applied) foreach ($order->getShipments() as $shipment) { if ($this->factory->get($shipment, ShipmentTransitions::GRAPH)->can(ShipmentTransitions::SYLIUS_SHIP)) { return; } } $this->factory->get($order, OrderTransitions::GRAPH)->apply(OrderTransitions::SYLIUS_SHIP, true); }
function it_adds_new_inventory_units_to_existing_shipment(OrderInterface $order, ShipmentInterface $shipment, ArrayCollection $shipments, InventoryUnitInterface $inventoryUnit, InventoryUnitInterface $inventoryUnitWithoutShipment) { $shipments->first()->willReturn($shipment)->shouldBeCalled(); $inventoryUnit->getShipment()->willReturn($shipment); $order->getInventoryUnits()->willReturn(array($inventoryUnit, $inventoryUnitWithoutShipment)); $order->getShipments()->willReturn($shipments)->shouldBeCalled(); $shipment->addItem($inventoryUnitWithoutShipment)->shouldBeCalled(); $shipment->addItem($inventoryUnit)->shouldNotBeCalled(); $this->createShipment($order); }
function it_does_nothing_if_tax_rate_cannot_be_resolved(CalculatorInterface $calculator, TaxRateResolverInterface $taxRateResolver, OrderInterface $order, ShipmentInterface $shipment, ShippingMethodInterface $shippingMethod, ZoneInterface $zone) { $order->getShippingTotal()->willReturn(100); $order->getShipments()->willReturn(new ArrayCollection([$shipment->getWrappedObject()])); $shipment->getMethod()->willReturn($shippingMethod); $taxRateResolver->resolve($shippingMethod, ['zone' => $zone])->willReturn(null); $calculator->calculate(Argument::any())->shouldNotBeCalled(); $order->addAdjustment(Argument::any())->shouldNotBeCalled(); $this->apply($order, $zone); }
/** * @param OrderInterface $order * * @return ShipmentInterface */ private function getOrderShipment(OrderInterface $order) { if ($order->hasShipments()) { return $order->getShipments()->first(); } /** @var ShipmentInterface $shipment */ $shipment = $this->shipmentFactory->createNew(); $order->addShipment($shipment); $shipment->setMethod($this->defaultShippingMethodResolver->getDefaultShippingMethod($shipment)); return $shipment; }
function it_adds_new_item_units_to_existing_shipment(OrderInterface $order, ShipmentInterface $shipment, ArrayCollection $shipments, OrderItemUnitInterface $itemUnit, OrderItemUnitInterface $itemUnitWithoutShipment) { $shipments->first()->willReturn($shipment)->shouldBeCalled(); $order->hasShipments()->willReturn(true)->shouldBeCalled(); $itemUnit->getShipment()->willReturn($shipment); $order->getItemUnits()->willReturn([$itemUnit, $itemUnitWithoutShipment]); $order->getShipments()->willReturn($shipments)->shouldBeCalled(); $shipment->addUnit($itemUnitWithoutShipment)->shouldBeCalled(); $shipment->addUnit($itemUnit)->shouldNotBeCalled(); $this->createForOrder($order); }
function it_does_not_mark_an_order_if_it_is_already_in_this_shipping_state(FactoryInterface $stateMachineFactory, OrderInterface $order, ShipmentInterface $shipment1, ShipmentInterface $shipment2, StateMachineInterface $orderStateMachine) { $shipments = new ArrayCollection(); $shipments->add($shipment1->getWrappedObject()); $shipments->add($shipment2->getWrappedObject()); $order->getShipments()->willReturn($shipments); $order->getShippingState()->willReturn(OrderShippingStates::STATE_SHIPPED); $stateMachineFactory->get($order, OrderShippingTransitions::GRAPH)->willReturn($orderStateMachine); $shipment1->getState()->willReturn(ShipmentInterface::STATE_SHIPPED); $shipment2->getState()->willReturn(ShipmentInterface::STATE_SHIPPED); $orderStateMachine->apply(OrderShippingTransitions::TRANSITION_SHIP)->shouldNotBeCalled(); $this->resolve($order); }
/** * {@inheritdoc} */ public function applyShippingCharges(OrderInterface $order) { // Remove all shipping adjustments, we recalculate everything from scratch. $order->removeAdjustments(AdjustmentInterface::SHIPPING_ADJUSTMENT); foreach ($order->getShipments() as $shipment) { $shippingCharge = $this->calculator->calculate($shipment); $adjustment = $this->adjustmentFactory->createNew(); $adjustment->setType(AdjustmentInterface::SHIPPING_ADJUSTMENT); $adjustment->setAmount($shippingCharge); $adjustment->setDescription($shipment->getMethod()->getName()); $order->addAdjustment($adjustment); } }
/** * {@inheritdoc} */ public function createShipment(OrderInterface $order) { $shipment = $order->getShipments()->first(); if (!$shipment) { $shipment = $this->shipmentRepository->createNew(); $order->addShipment($shipment); } foreach ($order->getInventoryUnits() as $inventoryUnit) { if (null === $inventoryUnit->getShipment()) { $shipment->addItem($inventoryUnit); } } }
/** * {@inheritdoc} */ public function createForOrder(OrderInterface $order) { if ($order->hasShipments()) { $shipment = $order->getShipments()->first(); } else { $shipment = $this->shipmentFactory->createNew(); $order->addShipment($shipment); } foreach ($order->getItemUnits() as $itemUnit) { if (null === $itemUnit->getShipment()) { $shipment->addUnit($itemUnit); } } }
function it_applies_calculated_shipping_charge_for_each_shipment_associated_with_the_order(FactoryInterface $adjustmentFactory, DelegatingCalculatorInterface $calculator, AdjustmentInterface $adjustment, OrderInterface $order, ShipmentInterface $shipment, ShippingMethodInterface $shippingMethod) { $adjustmentFactory->createNew()->willReturn($adjustment); $order->getShipments()->willReturn([$shipment]); $calculator->calculate($shipment)->willReturn(450); $shipment->getMethod()->willReturn($shippingMethod); $shippingMethod->getName()->willReturn('FedEx'); $adjustment->setAmount(450)->shouldBeCalled(); $adjustment->setType(AdjustmentInterface::SHIPPING_ADJUSTMENT)->shouldBeCalled(); $adjustment->setLabel('FedEx')->shouldBeCalled(); $order->removeAdjustments(AdjustmentInterface::SHIPPING_ADJUSTMENT)->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $this->process($order); }
protected function getShippingState(OrderInterface $order) { $states = []; foreach ($order->getShipments() as $shipment) { $states[] = $shipment->getState(); } $states = array_unique($states); $acceptableStates = [ShipmentInterface::STATE_CHECKOUT => OrderShippingStates::CHECKOUT, ShipmentInterface::STATE_ONHOLD => OrderShippingStates::ONHOLD, ShipmentInterface::STATE_READY => OrderShippingStates::READY, ShipmentInterface::STATE_SHIPPED => OrderShippingStates::SHIPPED, ShipmentInterface::STATE_RETURNED => OrderShippingStates::RETURNED, ShipmentInterface::STATE_CANCELLED => OrderShippingStates::CANCELLED]; foreach ($acceptableStates as $shipmentState => $orderState) { if ([$shipmentState] == $states) { return $orderState; } } return OrderShippingStates::PARTIALLY_SHIPPED; }
/** * {@inheritdoc} */ public function process(OrderInterface $order) { // Remove all shipping adjustments, we recalculate everything from scratch. $order->removeAdjustments(AdjustmentInterface::SHIPPING_ADJUSTMENT); foreach ($order->getShipments() as $shipment) { try { $shippingCharge = $this->shippingChargesCalculator->calculate($shipment); $adjustment = $this->adjustmentFactory->createNew(); $adjustment->setType(AdjustmentInterface::SHIPPING_ADJUSTMENT); $adjustment->setAmount($shippingCharge); $adjustment->setLabel($shipment->getMethod()->getName()); $order->addAdjustment($adjustment); } catch (UndefinedShippingMethodException $exception) { } } }
/** * @param OrderInterface $order */ private function selectShipping(OrderInterface $order) { $shippingMethod = $this->faker->randomElement($this->shippingMethodRepository->findEnabledForChannel($order->getChannel())); Assert::notNull($shippingMethod, 'Shipping method should not be null.'); foreach ($order->getShipments() as $shipment) { $shipment->setMethod($shippingMethod); } $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_SHIPPING); }
/** * @param OrderInterface $order * @param string $transition */ private function applyShipmentTransitionOnOrder(OrderInterface $order, $transition) { $shipment = $order->getShipments()->first(); $this->stateMachineFactory->get($shipment, ShipmentTransitions::GRAPH)->apply($transition); }
/** * @param OrderInterface $order * @param ShippingMethodInterface $shippingMethod * @param PaymentMethodInterface $paymentMethod */ private function proceedSelectingShippingAndPaymentMethod(OrderInterface $order, ShippingMethodInterface $shippingMethod, PaymentMethodInterface $paymentMethod) { foreach ($order->getShipments() as $shipment) { $shipment->setMethod($shippingMethod); } $this->applyTransitionOnOrderCheckout($order, OrderCheckoutTransitions::TRANSITION_SELECT_SHIPPING); $payment = $order->getLastPayment(PaymentInterface::STATE_CART); $payment->setMethod($paymentMethod); $this->applyTransitionOnOrderCheckout($order, OrderCheckoutTransitions::TRANSITION_SELECT_PAYMENT); $this->applyTransitionOnOrderCheckout($order, OrderCheckoutTransitions::TRANSITION_COMPLETE); }
/** * @param OrderInterface $order */ private function selectShipping(OrderInterface $order) { $shippingMethod = $this->faker->randomElement($order->getChannel()->getShippingMethods()->toArray()); Assert::notNull($shippingMethod); foreach ($order->getShipments() as $shipment) { $shipment->setMethod($shippingMethod); } $this->applyCheckoutStateTransition($order, OrderCheckoutTransitions::TRANSITION_SELECT_SHIPPING); }
/** * @param OrderInterface $order * @param string $shipmentState * * @return int */ private function countOrderShipmentsInState(OrderInterface $order, $shipmentState) { $shipments = $order->getShipments(); return $shipments->filter(function (ShipmentInterface $shipment) use($shipmentState) { return $shipment->getState() === $shipmentState; })->count(); }
/** * @param OrderInterface $order * * @return string */ private function getShippingMethodName(OrderInterface $order) { /** @var ShipmentInterface $shipment */ $shipment = $order->getShipments()->first(); if (false === $shipment) { throw new \LogicException('Order should have at least one shipment.'); } return $shipment->getMethod()->getName(); }
/** * @param OrderInterface $order * @param string $transition */ private function applyShipmentTransitionOnOrder(OrderInterface $order, $transition) { foreach ($order->getShipments() as $shipment) { $this->stateMachineFactory->get($shipment, ShipmentTransitions::GRAPH)->apply($transition); } }
/** * @param OrderInterface $order * * @return NodeElement|null */ private function getLastOrderShipmentElement(OrderInterface $order) { $shipment = $order->getShipments()->last(); $shipmentStateElements = $this->getElement('shipments')->findAll('css', sprintf('span.ui.label:contains(\'%s\')', ucfirst($shipment->getState()))); $shipmentStateElement = end($shipmentStateElements); return $shipmentStateElement->getParent()->getParent(); }
function it_updates_order_shipment_states_to_other_if_order_is_not_be_backordered(ShipmentInterface $shipment, OrderInterface $order) { $order->isBackorder()->willReturn(false); $order->getShipments()->willReturn([$shipment]); $this->updateOrderShipmentStates($order, 'foo'); }