php Sylius-Component-Promotion-Model-PromotionSubjectInterface类(方法)实例源码

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