/** * {@inheritdoc} */ public function revert(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'); } $subject->removePromotionAdjustments(); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof CountablePromotionSubjectInterface) { return false; } return $subject->getPromotionSubjectCount() >= $configuration['count']; }
/** * {@inheritdoc} */ protected function areCouponsEligibleForPromotion(PromotionSubjectInterface $subject, PromotionInterface $promotion) { if (!$subject instanceof CustomerAwareInterface) { return false; } $eligible = false; // Check to see if there is a per customer usage limit on coupon if ($subject instanceof PromotionCouponAwareSubjectInterface) { $coupon = $subject->getPromotionCoupon(); if (null !== $coupon && $promotion === $coupon->getPromotion()) { $eligible = $this->isCouponEligibleToLimit($coupon, $promotion, $subject->getCustomer()); } } elseif ($subject instanceof PromotionCouponsAwareSubjectInterface) { foreach ($subject->getPromotionCoupons() as $coupon) { if ($promotion === $coupon->getPromotion()) { $eligible = $this->isCouponEligibleToLimit($coupon, $promotion, $subject->getCustomer()); break; } } } else { return false; } if ($eligible) { $this->dispatcher->dispatch(SyliusPromotionEvents::COUPON_ELIGIBLE, new GenericEvent($promotion)); } return $eligible; }
/** * {@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 isEligible(PromotionSubjectInterface $subject, array $configuration) { if (isset($configuration['equal']) && $configuration['equal']) { return $subject->getPromotionSubjectTotal() >= $configuration['amount']; } return $subject->getPromotionSubjectTotal() > $configuration['amount']; }
function it_reverts_promotions_that_are_not_eligible_anymore(PreQualifiedPromotionsProviderInterface $preQualifiedPromotionsProvider, PromotionEligibilityCheckerInterface $promotionEligibilityChecker, PromotionApplicatorInterface $promotionApplicator, PromotionSubjectInterface $subject, PromotionInterface $promotion) { $subject->getPromotions()->willReturn([$promotion]); $preQualifiedPromotionsProvider->getPromotions($subject)->willReturn([$promotion]); $promotionEligibilityChecker->isEligible($subject, $promotion)->willReturn(false); $promotionApplicator->apply($subject, $promotion)->shouldNotBeCalled(); $promotionApplicator->revert($subject, $promotion)->shouldBeCalled(); $this->process($subject); }
/** * {@inheritdoc} */ public function getPromotions(PromotionSubjectInterface $subject) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } $channel = $subject->getChannel(); $promotions = $this->promotionRepository->findActiveByChannel($channel); return $promotions; }
/** * {@inheritdoc} */ public function revert(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } foreach ($subject->getItems() as $item) { $this->removeUnitsAdjustment($item, $promotion); } }
/** * {@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->createAdjustment($promotion); $adjustment->setAmount(-$subject->getPromotionSubjectTotal() * $configuration['percentage']); $subject->addAdjustment($adjustment); }
function it_should_revert_promotions_that_are_not_eligible_anymore($activePromotionsProvider, $checker, $applicator, PromotionSubjectInterface $subject, PromotionInterface $promotion) { $subject->getPromotions()->shouldBeCalled()->willReturn([$promotion]); $activePromotionsProvider->getPromotions($subject)->willReturn([$promotion]); $checker->isEligible($subject, $promotion)->shouldBeCalled()->willReturn(false); $applicator->apply($subject, $promotion)->shouldNotBeCalled(); $applicator->revert($subject, $promotion)->shouldBeCalled(); $this->process($subject); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, 'Sylius\\Component\\Core\\Model\\OrderInterface'); } if (null === ($user = $subject->getUser())) { return false; } return $user->getOrders()->count() == $configuration['nth']; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, 'Sylius\\Component\\Core\\Model\\OrderInterface'); } if (null === ($customer = $subject->getCustomer())) { return false; } return $this->orderRepository->countByCustomerAndPaymentState($customer, PaymentInterface::STATE_COMPLETED) === $configuration['nth'] - 1; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof PromotionCountableSubjectInterface) { return false; } if (isset($configuration['equal']) && $configuration['equal']) { return $subject->getPromotionSubjectCount() >= $configuration['count']; } return $subject->getPromotionSubjectCount() > $configuration['count']; }
/** * {@inheritdoc} */ public function execute(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } $adjustment = $this->createAdjustment($promotion); $adjustmentAmount = (int) round($subject->getPromotionSubjectTotal() * $configuration['percentage']); $adjustment->setAmount(-$adjustmentAmount); $subject->addAdjustment($adjustment); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, 'Sylius\\Component\\Core\\Model\\OrderInterface'); } if (null === ($address = $subject->getShippingAddress())) { return false; } return $address->getCountry()->getId() === $configuration['country']; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } if (null === ($address = $subject->getShippingAddress())) { return false; } return $this->isTargetCountry($subject, $configuration['country']); }
/** * @param PromotionSubjectInterface $subject * * @return array */ protected function getActivePromotions(PromotionSubjectInterface $subject) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } if (null === $this->promotions) { $channel = $subject->getChannel(); $this->promotions = $this->repository->findActiveByChannel($channel); } return $this->promotions; }
/** * {@inheritdoc} */ public function revert(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'); } foreach ($subject->getAdjustments(AdjustmentInterface::ORDER_PROMOTION_ADJUSTMENT) as $adjustment) { if ($promotion->getCode() === $adjustment->getOriginCode()) { $subject->removeAdjustment($adjustment); } } }
/** * {@inheritdoc} */ public function getPromotions(PromotionSubjectInterface $subject) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } $channel = $subject->getChannel(); if (null === $channel) { throw new \InvalidArgumentException('Order has no channel, but it should.'); } $promotions = $this->promotionRepository->findActiveByChannel($channel); return $promotions; }
/** * {@inheritdoc} */ public function execute(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } $filteredItems = $this->priceRangeFilter->filter($subject->getItems()->toArray(), $configuration); $filteredItems = $this->taxonFilter->filter($filteredItems, $configuration); foreach ($filteredItems as $item) { $promotionAmount = (int) round($item->getUnitPrice() * $configuration['percentage']); $this->setUnitsAdjustments($item, $promotionAmount, $promotion); } }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, PromotionInterface $promotion) { if (!$subject instanceof PromotionCouponAwareSubjectInterface || null === $subject->getPromotionCoupon()) { return false; } if (!$this->isCouponEligible($promotion, $subject)) { $this->eventDispatcher->dispatch(SyliusPromotionEvents::COUPON_NOT_ELIGIBLE, new GenericEvent($promotion)); return false; } $this->eventDispatcher->dispatch(SyliusPromotionEvents::COUPON_ELIGIBLE, new GenericEvent($promotion)); return true; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } /* @var $item OrderItemInterface */ foreach ($subject->getItems() as $item) { if ($configuration['product_code'] === $item->getProduct()->getCode()) { return true; } } return false; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, 'Sylius\\Component\\Core\\Model\\OrderInterface'); } /* @var $item OrderItemInterface */ foreach ($subject->getItems() as $item) { if ($configuration['variant'] == $item->getVariant()->getId()) { return !$configuration['exclude']; } } return (bool) $configuration['exclude']; }
/** * {@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(); }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } if (null === ($customer = $subject->getCustomer())) { return false; } $time = new \DateTime(sprintf('%d %s ago', $configuration['time'], $configuration['unit'])); if (isset($configuration['after']) && $configuration['after']) { return $customer->getCreatedAt() >= $time; } return $customer->getCreatedAt() < $time; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } if (null === ($address = $subject->getShippingAddress())) { return false; } $country = $this->countryRepository->findOneBy(array('code' => $address->getCountry())); if (!$country instanceof CountryInterface) { return false; } return $country->getId() === $configuration['country']; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } /* @var $item OrderItemInterface */ foreach ($subject->getItems() as $item) { if ($configuration['variant'] != $item->getVariant()->getId()) { continue; } return $this->isItemEligible($item, $configuration); } return (bool) $configuration['exclude']; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } if (!isset($configuration['nth']) || !is_int($configuration['nth'])) { return false; } $customer = $subject->getCustomer(); if (null === $customer) { return false; } return $this->orderRepository->countByCustomerAndPaymentState($customer, PaymentInterface::STATE_COMPLETED) === $configuration['nth'] - 1; }
/** * {@inheritdoc} */ public function isEligible(PromotionSubjectInterface $subject, array $configuration) { if (!$subject instanceof OrderInterface) { throw new UnsupportedTypeException($subject, OrderInterface::class); } /* @var $item OrderItemInterface */ foreach ($subject->getItems() as $item) { foreach ($item->getProduct()->getTaxons() as $taxon) { if ($configuration['taxons']->contains($taxon->getId())) { return !$configuration['exclude']; } } } return (bool) $configuration['exclude']; }
/** * {@inheritdoc} */ public function execute(PromotionSubjectInterface $subject, array $configuration, PromotionInterface $promotion) { if (!$subject instanceof OrderInterface) { throw new UnexpectedTypeException($subject, OrderInterface::class); } if (0 === $configuration['amount']) { return; } $filteredItems = $this->priceRangeFilter->filter($subject->getItems()->toArray(), $configuration); $filteredItems = $this->taxonFilter->filter($filteredItems, $configuration); $filteredItems = $this->productFilter->filter($filteredItems, $configuration); foreach ($filteredItems as $item) { $this->setUnitsAdjustments($item, $configuration['amount'], $promotion); } }