PHP PromotionInterface::isCouponBased方法代码示例

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

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

 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);
 }

 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);
 }

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

 function it_recognizes_subject_as_eligible_if_coupon_code_match($dispatcher, PromotionCouponsAwareSubjectInterface $subject, PromotionInterface $promotion, CouponInterface $coupon)
 {
     $subject->getPromotionCoupons()->willReturn(array($coupon));
     $promotion->getStartsAt()->willReturn(null);
     $promotion->getEndsAt()->willReturn(null);
     $promotion->getUsageLimit()->willReturn(null);
     $promotion->hasRules()->willReturn(false);
     $promotion->isCouponBased()->willReturn(true);
     $coupon->getPromotion()->willReturn($promotion);
     $dispatcher->dispatch(SyliusPromotionEvents::COUPON_ELIGIBLE, Argument::any())->shouldBeCalled();
     $this->isEligible($subject, $promotion)->shouldReturn(true);
 }

 /**
  * Checks is a promotion is eligible to a subject for a given rule.
  *
  * @param PromotionSubjectInterface $subject
  * @param PromotionInterface        $promotion
  * @param RuleInterface             $rule
  *
  * @return bool
  */
 protected function isEligibleToRule(PromotionSubjectInterface $subject, PromotionInterface $promotion, RuleInterface $rule)
 {
     $checker = $this->registry->get($rule->getType());
     if ($checker->isEligible($subject, $rule->getConfiguration())) {
         return true;
     }
     if (!$promotion->isCouponBased()) {
         return false;
     }
     if ($subject instanceof PromotionCouponAwareSubjectInterface) {
         $coupon = $subject->getPromotionCoupon();
         if (null !== $coupon && $promotion === $coupon->getPromotion()) {
             $this->dispatcher->dispatch(SyliusPromotionEvents::COUPON_NOT_ELIGIBLE, new GenericEvent($promotion));
         }
     } elseif ($subject instanceof PromotionCouponsAwareSubjectInterface) {
         foreach ($subject->getPromotionCoupons() as $coupon) {
             if ($promotion === $coupon->getPromotion()) {
                 $this->dispatcher->dispatch(SyliusPromotionEvents::COUPON_NOT_ELIGIBLE, new GenericEvent($promotion));
             }
         }
     }
     return false;
 }

 /**
  * Checks are subject's coupons eligible to promotion.
  *
  * @param PromotionSubjectInterface $subject
  * @param PromotionInterface        $promotion
  *
  * @return Boolean
  */
 private function areCouponsEligibleForPromotion(PromotionSubjectInterface $subject, PromotionInterface $promotion)
 {
     if (!$promotion->isCouponBased()) {
         return true;
     }
     $eligible = false;
     if ($subject instanceof PromotionCouponAwareSubjectInterface) {
         if (null !== ($coupon = $subject->getPromotionCoupon() && $promotion === $coupon->getPromotion())) {
             $eligible = true;
         }
     } elseif ($subject instanceof PromotionCouponsAwareSubjectInterface) {
         foreach ($subject->getPromotionCoupons() as $coupon) {
             if ($promotion === $coupon->getPromotion()) {
                 $eligible = true;
             }
         }
     } else {
         return false;
     }
     if ($eligible) {
         $this->dispatcher->dispatch(SyliusPromotionEvents::COUPON_ELIGIBLE, new GenericEvent($promotion));
     }
     return $eligible;
 }

 function it_returns_false_if_subject_is_not_coupon_aware(PromotionSubjectInterface $subject, PromotionInterface $promotion)
 {
     $promotion->isCouponBased()->willReturn(true);
     $this->isEligible($subject, $promotion)->shouldReturn(false);
 }