/** * {@inheritdoc} */ public function revert(PromotionSubjectInterface $subject, PromotionInterface $promotion) { foreach ($promotion->getActions() as $action) { $this->getActionCommandByType($action->getType())->revert($subject, $action->getConfiguration(), $promotion); } $subject->removePromotion($promotion); }
function it_decrements_promotion_usage_if_promotion_was_used(OrderInterface $order, PromotionInterface $promotion) { $order->getPromotions()->willReturn([$promotion]); $promotion->getUsed()->willReturn(5); $promotion->setUsed(4)->shouldBeCalled(); $this->decrementPromotionUsage($order); }
/** * @param PromotionInterface $promotion * @param string $header * * @return NodeElement */ private function getPromotionFieldsWithHeader(PromotionInterface $promotion, $header) { $tableAccessor = $this->getTableAccessor(); $table = $this->getElement('table'); $fields = $tableAccessor->getFieldFromRow($table, $tableAccessor->getRowWithFields($table, ['code' => $promotion->getCode()]), $header); return $fields; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $promotionSubject, PromotionInterface $promotion) { if (!$promotion->isCouponBased()) { throw new UnsupportedPromotionException('Only coupon based promotions can be evaluated by this checker.'); } if (!$promotionSubject instanceof OrderInterface) { return false; } $coupon = $promotionSubject->getPromotionCoupon(); if (!$coupon instanceof CouponInterface) { return false; } if ($promotion !== $coupon->getPromotion()) { return false; } $couponUsageLimit = $coupon->getPerCustomerUsageLimit(); if (0 === $couponUsageLimit) { return true; } $customer = $promotionSubject->getCustomer(); if (null === $customer) { return false; } $placedOrdersNumber = $this->orderRepository->countByCustomerAndCoupon($customer, $coupon); // <= because we need to include the cart orders as well return $placedOrdersNumber <= $couponUsageLimit; }
/** * {@inheritdoc} */ public function createForPromotion(PromotionInterface $promotion) { Assert::true($promotion->isCouponBased(), sprintf('Promotion with name %s is not coupon based.', $promotion->getName())); $coupon = $this->factory->createNew(); $coupon->setPromotion($promotion); return $coupon; }
/** * @param PromotionInterface $promotion * @param string $type * * @return AdjustmentInterface */ protected function createAdjustment(PromotionInterface $promotion, $type = AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT) { $adjustment = $this->adjustmentFactory->createNew(); $adjustment->setType($type); $adjustment->setLabel($promotion->getName()); $this->originator->setOrigin($adjustment, $promotion); return $adjustment; }
function it_creates_a_coupon_and_assigns_a_promotion_to_id(FactoryInterface $factory, PromotionInterface $promotion, PromotionCouponInterface $coupon) { $factory->createNew()->willReturn($coupon); $promotion->getName()->willReturn('Christmas sale'); $promotion->isCouponBased()->willReturn(true); $coupon->setPromotion($promotion)->shouldBeCalled(); $this->createForPromotion($promotion)->shouldReturn($coupon); }
/** * @param OrderItemUnitInterface $unit * @param PromotionInterface $promotion */ private function removeUnitOrderPromotionAdjustmentsByOrigin(OrderItemUnitInterface $unit, PromotionInterface $promotion) { foreach ($unit->getAdjustments(AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT) as $adjustment) { if ($promotion->getCode() === $adjustment->getOriginCode()) { $unit->removeAdjustment($adjustment); } } }
function it_returns_false_if_subject_coupons_is_not_eligible(PromotionCouponEligibilityCheckerInterface $promotionCouponEligibilityChecker, PromotionCouponAwarePromotionSubjectInterface $promotionSubject, PromotionInterface $promotion, PromotionCouponInterface $promotionCoupon) { $promotion->isCouponBased()->willReturn(true); $promotionSubject->getPromotionCoupon()->willReturn($promotionCoupon); $promotionCoupon->getPromotion()->willReturn($promotion); $promotionCouponEligibilityChecker->isEligible($promotionSubject, $promotionCoupon)->willReturn(false); $this->isEligible($promotionSubject, $promotion)->shouldReturn(false); }
/** * @param PromotionInterface $promotion * * @return AdjustmentInterface */ protected function createAdjustment(PromotionInterface $promotion) { $adjustment = $this->adjustmentFactory->createNew(); $adjustment->setType(AdjustmentInterface::PROMOTION_ADJUSTMENT); $adjustment->setDescription($promotion->getDescription()); $this->originator->setOrigin($adjustment, $promotion); return $adjustment; }
/** * @param PromotionInterface $promotion * @param string $type * * @return AdjustmentInterface */ protected function createAdjustment(PromotionInterface $promotion, $type = AdjustmentInterface::ORDER_SHIPPING_PROMOTION_ADJUSTMENT) { /** @var AdjustmentInterface $adjustment */ $adjustment = $this->adjustmentFactory->createNew(); $adjustment->setType($type); $adjustment->setLabel($promotion->getName()); $adjustment->setOriginCode($promotion->getCode()); return $adjustment; }
/** * {@inheritdoc} */ public function isEligible(PromotionInterface $promotion) { if (null === ($usageLimit = $promotion->getUsageLimit())) { return true; } if ($promotion->getUsed() < $usageLimit) { return true; } return false; }
/** * {@inheritdoc} */ public function execute(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface && !$subject instanceof OrderItemInterface) { throw new UnexpectedTypeException($subject, 'Sylius\\Component\\Core\\Model\\OrderInterface or Sylius\\Component\\Core\\Model\\OrderItemInterface'); } $adjustment = $this->repository->createNew(); $adjustment->setAmount(-$configuration['amount']); $adjustment->setLabel(OrderInterface::PROMOTION_ADJUSTMENT); $adjustment->setDescription($promotion->getDescription()); $subject->addAdjustment($adjustment); }
function it_reverts_all_actions_registered(ServiceRegistryInterface $registry, PromotionActionCommandInterface $action, PromotionSubjectInterface $subject, PromotionInterface $promotion, PromotionActionInterface $actionModel) { $configuration = []; $registry->get('test_action')->willReturn($action); $promotion->getActions()->willReturn([$actionModel]); $actionModel->getType()->willReturn('test_action'); $actionModel->getConfiguration()->willReturn($configuration); $action->revert($subject, $configuration, $promotion)->shouldBeCalled(); $subject->removePromotion($promotion)->shouldBeCalled(); $this->revert($subject, $promotion); }
function it_applies_fixed_discount_as_promotion_adjustment($adjustmentRepository, OrderInterface $order, AdjustmentInterface $adjustment, PromotionInterface $promotion) { $adjustmentRepository->createNew()->willReturn($adjustment); $promotion->getDescription()->willReturn('promotion description'); $adjustment->setAmount(-500)->shouldBeCalled(); $adjustment->setLabel(OrderInterface::PROMOTION_ADJUSTMENT)->shouldBeCalled(); $adjustment->setDescription('promotion description')->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $configuration = array('amount' => 500); $this->execute($order, $configuration, $promotion); }
function it_should_revert_all_actions_registered(ServiceRegistryInterface $registry, PromotionActionInterface $action, PromotionSubjectInterface $subject, PromotionInterface $promotion, ActionInterface $actionModel) { $configuration = array(); $registry->get(ActionInterface::TYPE_FIXED_DISCOUNT)->shouldBeCalled()->willReturn($action); $promotion->getActions()->shouldBeCalled()->willReturn(array($actionModel)); $actionModel->getType()->shouldBeCalled()->willReturn(ActionInterface::TYPE_FIXED_DISCOUNT); $actionModel->getConfiguration()->shouldBeCalled()->willReturn($configuration); $action->revert($subject, $configuration, $promotion)->shouldBeCalled(); $subject->removePromotion($promotion)->shouldBeCalled(); $this->revert($subject, $promotion); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $promotionSubject, PromotionInterface $promotion) { if (!$promotion->hasRules()) { return true; } foreach ($promotion->getRules() as $rule) { if (!$this->isEligibleToRule($promotionSubject, $rule)) { return false; } } return true; }
function it_applies_percentage_discount_as_promotion_adjustment($adjustmentRepository, $originator, OrderInterface $order, AdjustmentInterface $adjustment, PromotionInterface $promotion) { $order->getPromotionSubjectTotal()->willReturn(10000); $adjustmentRepository->createNew()->willReturn($adjustment); $promotion->getDescription()->willReturn('promotion description'); $adjustment->setAmount(-2500)->shouldBeCalled(); $adjustment->setLabel(AdjustmentInterface::PROMOTION_ADJUSTMENT)->shouldBeCalled(); $adjustment->setDescription('promotion description')->shouldBeCalled(); $originator->setOrigin($adjustment, $promotion)->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $configuration = array('percentage' => 0.25); $this->execute($order, $configuration, $promotion); }
function it_does_not_applies_bigger_discount_than_promotion_subject_total($adjustmentFactory, $originator, OrderInterface $order, AdjustmentInterface $adjustment, PromotionInterface $promotion) { $adjustmentFactory->createNew()->willReturn($adjustment); $promotion->getDescription()->willReturn('promotion description'); $order->getPromotionSubjectTotal()->willReturn(1000); $adjustment->setAmount(-1000)->shouldBeCalled(); $adjustment->setType(AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT)->shouldBeCalled(); $adjustment->setLabel('promotion description')->shouldBeCalled(); $originator->setOrigin($adjustment, $promotion)->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $configuration = ['amount' => 1500]; $this->execute($order, $configuration, $promotion); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $promotionSubject, PromotionInterface $promotion) { $now = new \DateTime(); $startsAt = $promotion->getStartsAt(); if (null !== $startsAt && $now < $startsAt) { return false; } $endsAt = $promotion->getEndsAt(); if (null !== $endsAt && $now > $endsAt) { return false; } return true; }
function it_reverts_order_units_order_promotion_adjustments(AdjustmentInterface $firstAdjustment, AdjustmentInterface $secondAdjustment, OrderInterface $order, OrderItemInterface $item, OrderItemUnitInterface $unit, PromotionInterface $promotion) { $order->countItems()->willReturn(1); $order->getItems()->willReturn([$item]); $item->getUnits()->willReturn([$unit]); $unit->getAdjustments(AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT)->willReturn([$firstAdjustment, $secondAdjustment]); $promotion->getCode()->willReturn('PROMOTION'); $firstAdjustment->getOriginCode()->willReturn('PROMOTION'); $secondAdjustment->getOriginCode()->willReturn('OTHER_PROMOTION'); $unit->removeAdjustment($firstAdjustment)->shouldBeCalled(); $unit->removeAdjustment($secondAdjustment)->shouldNotBeCalled(); $this->revert($order, [], $promotion); }
function it_applies_only_exclusive_promotion(PreQualifiedPromotionsProviderInterface $preQualifiedPromotionsProvider, PromotionEligibilityCheckerInterface $promotionEligibilityChecker, PromotionApplicatorInterface $promotionApplicator, PromotionSubjectInterface $subject, PromotionInterface $promotion, PromotionInterface $exclusivePromotion) { $subject->getPromotions()->willReturn([]); $preQualifiedPromotionsProvider->getPromotions($subject)->willReturn([$promotion, $exclusivePromotion]); $exclusivePromotion->isExclusive()->willReturn(true); $promotionEligibilityChecker->isEligible($subject, $promotion)->willReturn(true); $promotionEligibilityChecker->isEligible($subject, $exclusivePromotion)->willReturn(true); $promotionApplicator->apply($subject, $exclusivePromotion)->shouldBeCalled(); $promotionApplicator->apply($subject, $promotion)->shouldNotBeCalled(); $promotionApplicator->revert($subject, $promotion)->shouldNotBeCalled(); $promotionApplicator->revert($subject, $exclusivePromotion)->shouldNotBeCalled(); $this->process($subject); }
function it_should_apply_only_exclusive_promotion($repository, $checker, $applicator, PromotionSubjectInterface $subject, PromotionInterface $promotion, PromotionInterface $exlusivePromotion) { $subject->getPromotions()->shouldBeCalled()->willReturn(array()); $repository->findActive()->shouldBeCalled()->willReturn(array($promotion, $exlusivePromotion)); $exlusivePromotion->isExclusive()->shouldBeCalled()->willReturn(true); $checker->isEligible($subject, $promotion)->shouldBeCalled()->willReturn(true); $checker->isEligible($subject, $exlusivePromotion)->shouldBeCalled()->willReturn(true); $applicator->apply($subject, $exlusivePromotion)->shouldBeCalled(); $applicator->apply($subject, $promotion)->shouldNotBeCalled(); $applicator->revert($subject, $promotion)->shouldNotBeCalled(); $applicator->revert($subject, $exlusivePromotion)->shouldNotBeCalled(); $this->process($subject); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $promotionSubject, PromotionInterface $promotion) { if (!$promotion->isCouponBased()) { throw new UnsupportedPromotionException('Only coupon based promotions can be evaluated by this checker.'); } if (!$promotionSubject instanceof CouponAwarePromotionSubjectInterface) { return false; } if (null === $promotionSubject->getPromotionCoupon()) { return false; } return $promotion === $promotionSubject->getPromotionCoupon()->getPromotion(); }
function it_applies_percentage_discount_as_promotion_adjustment(FactoryInterface $adjustmentFactory, $originator, OrderInterface $order, AdjustmentInterface $adjustment, PromotionInterface $promotion) { $order->getPromotionSubjectTotal()->willReturn(10000); $adjustmentFactory->createNew()->willReturn($adjustment); $promotion->getName()->willReturn('Test promotion'); $adjustment->setAmount(-2500)->shouldBeCalled(); $adjustment->setType(AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT)->shouldBeCalled(); $adjustment->setLabel('Test promotion')->shouldBeCalled(); $originator->setOrigin($adjustment, $promotion)->shouldBeCalled(); $order->addAdjustment($adjustment)->shouldBeCalled(); $configuration = ['percentage' => 0.25]; $this->execute($order, $configuration, $promotion); }
function it_should_apply_only_exclusive_promotion($activePromotionsProvider, $checker, $applicator, PromotionSubjectInterface $subject, PromotionInterface $promotion, PromotionInterface $exclusivePromotion) { $subject->getPromotions()->shouldBeCalled()->willReturn([]); $activePromotionsProvider->getPromotions($subject)->willReturn([$promotion, $exclusivePromotion]); $exclusivePromotion->isExclusive()->shouldBeCalled()->willReturn(true); $checker->isEligible($subject, $promotion)->shouldBeCalled()->willReturn(true); $checker->isEligible($subject, $exclusivePromotion)->shouldBeCalled()->willReturn(true); $applicator->apply($subject, $exclusivePromotion)->shouldBeCalled(); $applicator->apply($subject, $promotion)->shouldNotBeCalled(); $applicator->revert($subject, $promotion)->shouldNotBeCalled(); $applicator->revert($subject, $exclusivePromotion)->shouldNotBeCalled(); $this->process($subject); }
function it_does_not_check_more_rules_if_one_has_returned_false(RuleCheckerInterface $cartQuantityRuleChecker, RuleCheckerInterface $itemTotalRuleChecker, RuleInterface $cartQuantityRule, RuleInterface $itemTotalRule, PromotionInterface $promotion, PromotionSubjectInterface $subject, ServiceRegistryInterface $rulesRegistry) { $promotion->hasRules()->willReturn(true); $promotion->getRules()->willReturn([$cartQuantityRule, $itemTotalRule]); $cartQuantityRule->getType()->willReturn(RuleInterface::TYPE_CART_QUANTITY); $cartQuantityRule->getConfiguration()->willReturn([]); $itemTotalRule->getType()->willReturn(RuleInterface::TYPE_ITEM_TOTAL); $itemTotalRule->getConfiguration()->willReturn([]); $rulesRegistry->get(RuleInterface::TYPE_CART_QUANTITY)->willReturn($cartQuantityRuleChecker); $rulesRegistry->get(RuleInterface::TYPE_ITEM_TOTAL)->willReturn($itemTotalRuleChecker); $cartQuantityRuleChecker->isEligible($subject, [])->willReturn(false); $itemTotalRuleChecker->isEligible($subject, [])->shouldNotBeCalled(); $this->isEligible($subject, $promotion)->shouldReturn(false); }
function it_does_not_check_more_rules_if_one_has_returned_false(ServiceRegistryInterface $rulesRegistry, RuleCheckerInterface $firstRuleChecker, RuleCheckerInterface $secondRuleChecker, RuleInterface $firstRule, RuleInterface $secondRule, PromotionInterface $promotion, PromotionSubjectInterface $subject) { $promotion->hasRules()->willReturn(true); $promotion->getRules()->willReturn([$firstRule, $secondRule]); $firstRule->getType()->willReturn('first_rule'); $firstRule->getConfiguration()->willReturn([]); $secondRule->getType()->willReturn('second_rule'); $secondRule->getConfiguration()->willReturn([]); $rulesRegistry->get('first_rule')->willReturn($firstRuleChecker); $rulesRegistry->get('second_rule')->willReturn($secondRuleChecker); $firstRuleChecker->isEligible($subject, [])->willReturn(false); $secondRuleChecker->isEligible($subject, [])->shouldNotBeCalled(); $this->isEligible($subject, $promotion)->shouldReturn(false); }
public function revert(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface) { return; } if (!$promotion instanceof OriginAwareInterface) { return; } /** @var AdjustmentInterface $adjustment */ foreach ($subject->getAdjustments() as $adjustment) { if ($adjustment->getOriginId() === $promotion->getOriginId() && $adjustment->getOriginType() === $promotion->getOriginType() && $adjustment->getType() === $this->getAdjustmentType()) { $subject->removeAdjustment($adjustment); break; } } }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $promotionSubject, PromotionInterface $promotion) { if (!$promotion->isCouponBased()) { return true; } if (!$promotionSubject instanceof PromotionCouponAwarePromotionSubjectInterface) { return false; } $promotionCoupon = $promotionSubject->getPromotionCoupon(); if (null === $promotionCoupon) { return false; } if ($promotion !== $promotionCoupon->getPromotion()) { return false; } return $this->promotionCouponEligibilityChecker->isEligible($promotionSubject, $promotionCoupon); }