/**
* {@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);
}
}
