Allow runtime eligibility checks

src/Checker/Eligibility/CalloutEligibilityCheckerInterface.php

@@ -10,4 +10,9 @@
 interface CalloutEligibilityCheckerInterface
 {
     public function isEligible(ProductInterface $product, CalloutInterface $callout): bool;
+
+    /**
+     * This is called at runtime, so it should be as fast as possible
+     */
+    public function isRuntimeEligible(ProductInterface $product, CalloutInterface $callout): bool;
 }

src/Checker/Eligibility/CalloutRulesEligibilityChecker.php

@@ -35,11 +35,35 @@ public function isEligible(ProductInterface $product, CalloutInterface $callout)
         return true;
     }
 
+    public function isRuntimeEligible(ProductInterface $product, CalloutInterface $callout): bool
+    {
+        if (!$callout->hasRules()) {
+            return true;
+        }
+
+        // All rules should pass for Product to be eligible
+        foreach ($callout->getRules() as $rule) {
+            if (!$this->isRuntimeEligibleToRule($product, $rule)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     private function isEligibleToRule(ProductInterface $product, CalloutRuleInterface $rule): bool
     {
         /** @var CalloutRuleCheckerInterface $checker */
         $checker = $this->ruleRegistry->get((string) $rule->getType());
 
         return $checker->isEligible($product, $rule->getConfiguration());
     }
+
+    private function isRuntimeEligibleToRule(ProductInterface $product, CalloutRuleInterface $rule): bool
+    {
+        /** @var CalloutRuleCheckerInterface $checker */
+        $checker = $this->ruleRegistry->get((string) $rule->getType());
+
+        return $checker->isEligible($product, $rule->getConfiguration());
+    }
 }

src/Checker/Eligibility/CompositeCalloutEligibilityChecker.php

@@ -23,4 +23,15 @@ public function isEligible(ProductInterface $product, CalloutInterface $callout)
 
         return true;
     }
+
+    public function isRuntimeEligible(ProductInterface $product, CalloutInterface $callout): bool
+    {
+        foreach ($this->services as $service) {
+            if (!$service->isRuntimeEligible($product, $callout)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

src/Checker/Rule/AbstractCalloutRuleChecker.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Setono\SyliusCalloutPlugin\Checker\Rule;
+
+use Sylius\Component\Core\Model\ProductInterface;
+
+abstract class AbstractCalloutRuleChecker implements CalloutRuleCheckerInterface
+{
+    public function isRuntimeEligible(ProductInterface $product, array $configuration): bool
+    {
+        return true;
+    }
+}

src/Checker/Rule/CalloutRuleCheckerInterface.php

@@ -9,4 +9,9 @@
 interface CalloutRuleCheckerInterface
 {
     public function isEligible(ProductInterface $product, array $configuration): bool;
+
+    /**
+     * This is called at runtime, so it should be as fast as possible
+     */
+    public function isRuntimeEligible(ProductInterface $product, array $configuration): bool;
 }

src/Checker/Rule/HasProductCalloutRuleChecker.php

@@ -8,7 +8,7 @@
 use Sylius\Component\Core\Repository\ProductRepositoryInterface;
 use Webmozart\Assert\Assert;
 
-final class HasProductCalloutRuleChecker implements CalloutRuleCheckerInterface
+final class HasProductCalloutRuleChecker extends AbstractCalloutRuleChecker
 {
     public const TYPE = 'has_product';
 

src/Checker/Rule/HasTaxonCalloutRuleChecker.php

@@ -9,7 +9,7 @@
 use Sylius\Component\Taxonomy\Repository\TaxonRepositoryInterface;
 use Webmozart\Assert\Assert;
 
-final class HasTaxonCalloutRuleChecker implements CalloutRuleCheckerInterface
+final class HasTaxonCalloutRuleChecker extends AbstractCalloutRuleChecker
 {
     public const TYPE = 'has_taxon';
 

src/Checker/Rule/IsNewCalloutRuleChecker.php

@@ -9,7 +9,7 @@
 use Sylius\Component\Core\Model\ProductInterface;
 use Webmozart\Assert\Assert;
 
-final class IsNewCalloutRuleChecker implements CalloutRuleCheckerInterface
+final class IsNewCalloutRuleChecker extends AbstractCalloutRuleChecker
 {
     public const TYPE = 'is_new';
 

src/Checker/Rule/OnSaleCalloutRuleChecker.php

@@ -23,6 +23,11 @@ public function __construct(ChannelContextInterface $channelContext)
     }
 
     public function isEligible(ProductInterface $product, array $configuration): bool
+    {
+        return true;
+    }
+
+    public function isRuntimeEligible(ProductInterface $product, array $configuration): bool
     {
         try {
             /** @var ChannelInterface $channel */

src/Form/Type/Rule/OnSaleConfigurationType.php

@@ -5,11 +5,23 @@
 namespace Setono\SyliusCalloutPlugin\Form\Type\Rule;
 
 use Symfony\Component\Form\AbstractType;
+use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
+use Symfony\Component\Form\FormBuilderInterface;
 
 final class OnSaleConfigurationType extends AbstractType
 {
+    public function buildForm(FormBuilderInterface $builder, array $options): void
+    {
+        $builder
+            ->add('singleVariantEligible', CheckboxType::class, [
+                'label' => 'setono_sylius_callout.form.callout_rule.on_sale.single_variant_eligible',
+                'required' => false,
+            ])
+        ;
+    }
+
     public function getBlockPrefix(): string
     {
-        return 'setono_callout_rule_on_sale_configuration';
+        return 'setono_sylius_callout_rule_on_sale_configuration';
     }
 }

src/Model/Callout.php

@@ -210,8 +210,18 @@ public function hasRules(): bool
         return !$this->rules->isEmpty();
     }
 
-    public function hasRule(CalloutRuleInterface $rule): bool
+    public function hasRule(CalloutRuleInterface|string $rule): bool
     {
+        if (is_string($rule)) {
+            foreach ($this->rules as $r) {
+                if ($r->getType() === $rule) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         return $this->rules->contains($rule);
     }
 

src/Model/CalloutInterface.php

@@ -76,7 +76,10 @@ public function getRules(): Collection;
 
     public function hasRules(): bool;
 
-    public function hasRule(CalloutRuleInterface $rule): bool;
+    /**
+     * @param CalloutRuleInterface|string $rule if the rule is a string, it will be treated as a rule type
+     */
+    public function hasRule(CalloutRuleInterface|string $rule): bool;
 
     public function addRule(CalloutRuleInterface $rule): void;
 

src/Repository/CalloutRepository.php

@@ -36,11 +36,12 @@ public function findEnabled(array $codes = []): array
 
     public function findByCodes(array $codes, ChannelInterface $channel, string $locale): array
     {
-        $objs = $this->createQueryBuilder('o')
-            ->select('o, c, t')
-            ->join('o.channels', 'c', 'WITH', 'c = :channel')
-            ->join('o.translations', 't', 'WITH', 't.locale = :locale')
-            ->andWhere('o.code IN (:codes)')
+        $objs = $this->createQueryBuilder('callout')
+            ->select('callout, rule, channel, translation')
+            ->join('callout.rules', 'rule')
+            ->join('callout.channels', 'channel', 'WITH', 'channel = :channel')
+            ->join('callout.translations', 'translation', 'WITH', 'translation.locale = :locale')
+            ->andWhere('callout.code IN (:codes)')
             ->setParameter('codes', $codes)
             ->setParameter('channel', $channel)
             ->setParameter('locale', $locale)

src/Resources/config/services/form.xml

@@ -61,7 +61,7 @@
             <tag name="form.type"/>
         </service>
 
-        <service id="setono_sylius_callout.form.type.rule.has_taxon_product"
+        <service id="setono_sylius_callout.form.type.rule.has_product"
                  class="Setono\SyliusCalloutPlugin\Form\Type\Rule\HasProductConfigurationType">
             <argument type="service" id="sylius.form.type.data_transformer.products_to_codes"/>
             <tag name="form.type"/>

src/Resources/config/services/twig.xml

@@ -13,6 +13,7 @@
         <service id="setono_sylius_callout.twig.callout_runtime"
                  class="Setono\SyliusCalloutPlugin\Twig\CalloutRuntime">
             <argument type="service" id="setono_sylius_callout.checker.rendering_eligibility.composite"/>
+            <argument type="service" id="setono_sylius_callout.checker.eligibility.composite"/>
             <argument type="service" id="setono_sylius_callout.css_class_builder.default"/>
             <argument type="service" id="setono_sylius_callout.provider.rendering_callout"/>
             <argument type="service" id="setono_sylius_callout.renderer.callout"/>

src/Resources/translations/messages.en.yml

@@ -41,6 +41,8 @@ setono_sylius_callout:
                 taxons: Taxons
             is_new:
                 days: Days
+            on_sale:
+                single_variant_eligible: A product is considered on sale if it has a single variant (the default) that is on sale
     ui:
         action:
             assign: Assign

src/Twig/CalloutRuntime.php

@@ -4,6 +4,7 @@
 
 namespace Setono\SyliusCalloutPlugin\Twig;
 
+use Setono\SyliusCalloutPlugin\Checker\Eligibility\CalloutEligibilityCheckerInterface;
 use Setono\SyliusCalloutPlugin\Checker\RenderingEligibility\CalloutRenderingEligibilityCheckerInterface;
 use Setono\SyliusCalloutPlugin\CssClassBuilder\CssClassBuilderInterface;
 use Setono\SyliusCalloutPlugin\Model\CalloutInterface;
@@ -16,6 +17,7 @@ final class CalloutRuntime implements RuntimeExtensionInterface
 {
     public function __construct(
         private readonly CalloutRenderingEligibilityCheckerInterface $calloutRenderingEligibilityChecker,
+        private readonly CalloutEligibilityCheckerInterface $calloutEligibilityChecker,
         private readonly CssClassBuilderInterface $cssClassBuilder,
         private readonly RenderingCalloutProviderInterface $renderingCalloutProvider,
         private readonly CalloutRendererInterface $calloutRenderer,
@@ -42,6 +44,10 @@ public function getCallouts(ProductInterface $product, string $element = null):
                 continue;
             }
 
+            if (!$this->calloutEligibilityChecker->isRuntimeEligible($product, $callout)) {
+                continue;
+            }
+
             $elements = $callout->getElements();
             if ([] === $elements) {
                 $elements = [CalloutInterface::DEFAULT_KEY];

tests/Twig/CalloutRuntimeTest.php

@@ -7,6 +7,7 @@
 use PHPUnit\Framework\TestCase;
 use Prophecy\Argument;
 use Prophecy\PhpUnit\ProphecyTrait;
+use Setono\SyliusCalloutPlugin\Checker\Eligibility\CalloutEligibilityCheckerInterface;
 use Setono\SyliusCalloutPlugin\Checker\RenderingEligibility\CalloutRenderingEligibilityCheckerInterface;
 use Setono\SyliusCalloutPlugin\CssClassBuilder\CssClassBuilderInterface;
 use Setono\SyliusCalloutPlugin\Model\Callout;
@@ -54,6 +55,14 @@ private function getCalloutRuntime(): CalloutRuntime
         $calloutRenderingEligibilityChecker = $this->prophesize(CalloutRenderingEligibilityCheckerInterface::class);
         $calloutRenderingEligibilityChecker->isEligible(Argument::type(CalloutInterface::class))->willReturn(true);
 
+        $calloutEligibilityChecker = $this->prophesize(CalloutEligibilityCheckerInterface::class);
+        $calloutEligibilityChecker
+            ->isRuntimeEligible(
+                Argument::type(ProductInterface::class),
+                Argument::type(CalloutInterface::class),
+            )->willReturn(true)
+        ;
+
         $cssClassBuilder = $this->prophesize(CssClassBuilderInterface::class);
 
         $renderCalloutProvider = $this->prophesize(RenderingCalloutProviderInterface::class);
@@ -70,6 +79,7 @@ private function getCalloutRuntime(): CalloutRuntime
 
         return new CalloutRuntime(
             $calloutRenderingEligibilityChecker->reveal(),
+            $calloutEligibilityChecker->reveal(),
             $cssClassBuilder->reveal(),
             $renderCalloutProvider->reveal(),
             $calloutRenderer->reveal(),