Add OrderBasedPaymentMethodsResolver

config/services/pay_by_link_payment/checker.php

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symfony\Component\DependencyInjection\Loader\Configurator;
+
+use CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker\PaymentMethodSupportedForOrderChecker;
+use CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker\PaymentMethodSupportedForOrderCheckerInterface;
+
+return static function(ContainerConfigurator $container): void {
+    $services = $container->services();
+
+    $services->set('commerce_weavers_sylius_tpay.pay_by_link_payment.checker.payment_method_supported_for_order', PaymentMethodSupportedForOrderChecker::class)
+        ->args([
+            service('payum.dynamic_gateways.cypher'),
+            service('commerce_weavers_sylius_tpay.tpay.provider.order_aware_validated_tpay_api_bank_list'),
+        ])
+        ->alias(PaymentMethodSupportedForOrderCheckerInterface::class, 'commerce_weavers_sylius_tpay.pay_by_link_payment.checker.payment_method_supported_for_order')
+    ;
+};

config/services/payment.php

@@ -8,6 +8,7 @@
 use CommerceWeavers\SyliusTpayPlugin\Payment\Canceller\PaymentCancellerInterface;
 use CommerceWeavers\SyliusTpayPlugin\Payment\Checker\PaymentCancellationPossibilityChecker;
 use CommerceWeavers\SyliusTpayPlugin\Payment\Checker\PaymentCancellationPossibilityCheckerInterface;
+use CommerceWeavers\SyliusTpayPlugin\Payment\Resolver\OrderBasedPaymentMethodsResolver;
 
 return static function(ContainerConfigurator $container): void {
     $services = $container->services();
@@ -27,4 +28,12 @@
         ])
         ->alias(PaymentCancellationPossibilityCheckerInterface::class, 'commerce_weavers_sylius_tpay.payment.checker.payment_cancellation_possibility')
     ;
+
+    $services->set('commerce_weavers_sylius_tpay.payment.resolver.order_based_payment_methods', OrderBasedPaymentMethodsResolver::class)
+        ->args([
+            service('sylius.payment_methods_resolver.channel_based'),
+            service('commerce_weavers_sylius_tpay.pay_by_link_payment.checker.payment_method_supported_for_order'),
+        ])
+        ->tag('sylius.payment_method_resolver', ['type' => 'tpay_order_based', 'label' => 'commerce_weavers_sylius_tpay.payment_methods_resolver.order_based', 'priority' => 2])
+    ;
 };

src/PayByLinkPayment/Checker/PaymentMethodSupportedForOrderChecker.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker;
+
+use CommerceWeavers\SyliusTpayPlugin\Tpay\GatewayName;
+use CommerceWeavers\SyliusTpayPlugin\Tpay\Provider\OrderAwareValidTpayChannelListProviderInterface;
+use Payum\Core\Security\CryptedInterface;
+use Payum\Core\Security\CypherInterface;
+use Sylius\Bundle\PayumBundle\Model\GatewayConfigInterface;
+use Sylius\Component\Core\Model\OrderInterface;
+use Sylius\Component\Core\Model\PaymentMethodInterface;
+
+final class PaymentMethodSupportedForOrderChecker implements PaymentMethodSupportedForOrderCheckerInterface
+{
+    public function __construct(
+        private readonly CypherInterface $cypher,
+        private readonly OrderAwareValidTpayChannelListProviderInterface $orderAwareValidTpayChannelListProvider,
+    ) {
+    }
+
+    public function isSupportedForOrder(PaymentMethodInterface $paymentMethod, OrderInterface $order): bool
+    {
+        /** @var GatewayConfigInterface|null $gatewayConfig */
+        $gatewayConfig = $paymentMethod->getGatewayConfig();
+
+        if (null === $gatewayConfig || GatewayName::PAY_BY_LINK !== $gatewayConfig->getFactoryName()) {
+            return true;
+        }
+
+        if ($gatewayConfig instanceof CryptedInterface) {
+            $gatewayConfig->decrypt($this->cypher);
+        }
+
+        $tpayChannelId = $gatewayConfig->getConfig()['tpay_channel_id'] ?? null;
+
+        if (null === $tpayChannelId) {
+            return true;
+        }
+
+        $validTpayChannelList = $this->orderAwareValidTpayChannelListProvider->provide($order);
+
+        return isset($validTpayChannelList[$tpayChannelId]);
+    }
+}

src/PayByLinkPayment/Checker/PaymentMethodSupportedForOrderCheckerInterface.php

@@ -0,0 +1,13 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker;
+
+use Sylius\Component\Core\Model\OrderInterface;
+use Sylius\Component\Core\Model\PaymentMethodInterface;
+
+interface PaymentMethodSupportedForOrderCheckerInterface
+{
+    public function isSupportedForOrder(PaymentMethodInterface $paymentMethod, OrderInterface $order): bool;
+}

src/Payment/Resolver/OrderBasedPaymentMethodsResolver.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CommerceWeavers\SyliusTpayPlugin\Payment\Resolver;
+
+use CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker\PaymentMethodSupportedForOrderCheckerInterface;
+use Sylius\Component\Core\Model\PaymentInterface as CorePaymentInterface;
+use Sylius\Component\Core\Model\PaymentMethodInterface;
+use Sylius\Component\Payment\Model\PaymentInterface;
+use Sylius\Component\Payment\Resolver\PaymentMethodsResolverInterface;
+use Webmozart\Assert\Assert;
+
+final class OrderBasedPaymentMethodsResolver implements PaymentMethodsResolverInterface
+{
+    public function __construct(
+        private readonly PaymentMethodsResolverInterface $paymentMethodsResolver,
+        private readonly PaymentMethodSupportedForOrderCheckerInterface $paymentMethodSupportedForOrderChecker,
+    ) {
+    }
+
+    public function getSupportedMethods(PaymentInterface $subject): array
+    {
+        Assert::isInstanceOf($subject, CorePaymentInterface::class);
+        Assert::true($this->supports($subject), 'This payment method is not support by resolver');
+
+        /** @var PaymentMethodInterface[] $supportedMethods */
+        $supportedMethods = $this->paymentMethodsResolver->getSupportedMethods($subject);
+
+        foreach ($supportedMethods as $key => $supportedMethod) {
+            $order = $subject->getOrder();
+            Assert::notNull($order);
+
+            if ($this->paymentMethodSupportedForOrderChecker->isSupportedForOrder($supportedMethod, $order)) {
+                continue;
+            }
+
+            unset($supportedMethods[$key]);
+        }
+
+        return array_values($supportedMethods);
+    }
+
+    public function supports(PaymentInterface $subject): bool
+    {
+        return $this->paymentMethodsResolver->supports($subject);
+    }
+}

tests/E2E/Resources/fixtures/common/payment_method.yaml

@@ -41,6 +41,20 @@ Sylius\Component\Core\Model\PaymentMethod:
         translations:
             - '@tpay_pbl_one_channel_payment_method_translation'
         channels: [ '@channel_web' ]
+    tpay_pbl_one_channel_with_amount_min_20_constraint:
+        code: 'tpay_pbl_one_channel_with_amount_min_20_constraint'
+        enabled: true
+        gatewayConfig: '@gateway_tpay_pbl_one_channel_with_amount_min_20_constraint'
+        translations:
+            - '@tpay_pbl_one_channel_with_amount_min_20_constraint_payment_method_translation'
+        channels: [ '@channel_web' ]
+    tpay_pbl_one_channel_with_amount_min_30_constraint:
+        code: 'tpay_pbl_one_channel_with_amount_min_30_constraint'
+        enabled: true
+        gatewayConfig: '@gateway_tpay_pbl_one_channel_with_amount_min_30_constraint'
+        translations:
+            - '@tpay_pbl_one_channel_with_amount_min_30_constraint_payment_method_translation'
+        channels: [ '@channel_web' ]
     tpay_visa_mobile:
         code: 'tpay_visa_mobile'
         enabled: true
@@ -101,6 +115,26 @@ Sylius\Bundle\PayumBundle\Model\GatewayConfig:
             type: 'pay_by_link'
             production_mode: false
             encrypted: true
+    gateway_tpay_pbl_one_channel_with_amount_min_20_constraint:
+        gatewayName: 'tpay_pbl'
+        factoryName: 'tpay_pbl'
+        config:
+            client_id: 'encrypted_<getenv("TPAY_CLIENT_ID")>'
+            client_secret: 'encrypted_<getenv("TPAY_CLIENT_SECRET")>'
+            tpay_channel_id: '4'
+            type: 'pay_by_link'
+            production_mode: false
+            encrypted: true
+    gateway_tpay_pbl_one_channel_with_amount_min_30_constraint:
+        gatewayName: 'tpay_pbl'
+        factoryName: 'tpay_pbl'
+        config:
+            client_id: 'encrypted_<getenv("TPAY_CLIENT_ID")>'
+            client_secret: 'encrypted_<getenv("TPAY_CLIENT_SECRET")>'
+            tpay_channel_id: '5'
+            type: 'pay_by_link'
+            production_mode: false
+            encrypted: true
     gateway_tpay_visa_mobile:
         gatewayName: 'tpay_visa_mobile'
         factoryName: 'tpay_visa_mobile'
@@ -141,6 +175,16 @@ Sylius\Component\Payment\Model\PaymentMethodTranslation:
         locale: 'en_US'
         description: '<paragraph(2)>'
         translatable: '@tpay_pbl_one_channel'
+    tpay_pbl_one_channel_with_amount_min_20_constraint_payment_method_translation:
+        name: 'One Bank With Amount Min 20 Constraint (Tpay)'
+        locale: 'en_US'
+        description: '<paragraph(2)>'
+        translatable: '@tpay_pbl_one_channel_with_amount_min_20_constraint'
+    tpay_pbl_one_channel_with_amount_min_30_constraint_payment_method_translation:
+        name: 'One Bank With Amount Min 30 Constraint (Tpay)'
+        locale: 'en_US'
+        description: '<paragraph(2)>'
+        translatable: '@tpay_pbl_one_channel_with_amount_min_20_constraint'
     tpay_visa_mobile_payment_method_translation:
         name: 'Visa mobile (Tpay)'
         locale: 'en_US'

tests/E2E/Shop/Checkout/TpayPayByLinkCheckoutTest.php

@@ -45,4 +45,13 @@ public function test_it_completes_the_checkout_using_pay_by_link_channel_presele
 
         $this->assertPageTitleContains('Thank you!');
     }
+
+    public function test_it_cannot_complete_the_checkout_using_not_supported_pay_by_link(): void
+    {
+        $element = $this->client->findElement(WebDriverBy::xpath('//*[@id="sylius-payment-methods"]/form/div[1]/div/div[2]'));
+
+        $this->assertStringContainsString('One Bank (Tpay)', $element->getText());
+        $this->assertStringContainsString('One Bank With Amount Min 20 Constraint (Tpay)', $element->getText());
+        $this->assertStringNotContainsString('One Bank With Amount Min 30 Constraint (Tpay)', $element->getText());
+    }
 }

tests/Unit/PayByLinkPayment/Checker/PaymentMethodSupportedForOrderCheckerTest.php

@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\CommerceWeavers\SyliusTpayPlugin\Unit\PayByLinkPayment\Checker;
+
+use CommerceWeavers\SyliusTpayPlugin\PayByLinkPayment\Checker\PaymentMethodSupportedForOrderChecker;
+use CommerceWeavers\SyliusTpayPlugin\Tpay\GatewayName;
+use CommerceWeavers\SyliusTpayPlugin\Tpay\Provider\OrderAwareValidTpayChannelListProviderInterface;
+use Payum\Core\Security\CypherInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\PhpUnit\ProphecyTrait;
+use Prophecy\Prophecy\ObjectProphecy;
+use Sylius\Bundle\PayumBundle\Model\GatewayConfigInterface;
+use Sylius\Component\Core\Model\OrderInterface;
+use Sylius\Component\Core\Model\PaymentMethodInterface;
+
+final class PaymentMethodSupportedForOrderCheckerTest extends TestCase
+{
+    use ProphecyTrait;
+
+    private CypherInterface|ObjectProphecy $cypher;
+
+    private OrderAwareValidTpayChannelListProviderInterface|ObjectProphecy $orderAwareValidTpayChannelListProvider;
+
+    private PaymentMethodInterface|ObjectProphecy $paymentMethod;
+
+    private OrderInterface|ObjectProphecy $order;
+
+    protected function setUp(): void
+    {
+        $this->cypher = $this->prophesize(CypherInterface::class);
+        $this->orderAwareValidTpayChannelListProvider = $this->prophesize(OrderAwareValidTpayChannelListProviderInterface::class);
+        $this->paymentMethod = $this->prophesize(PaymentMethodInterface::class);
+        $this->order = $this->prophesize(OrderInterface::class);
+    }
+
+    public function test_it_returns_true_if_gateway_config_is_null(): void
+    {
+        $this->paymentMethod->getGatewayConfig()->willReturn(null);
+
+        $result = $this
+            ->createTestSubject()
+            ->isSupportedForOrder($this->paymentMethod->reveal(), $this->order->reveal())
+        ;
+
+        $this->assertTrue($result);
+    }
+
+    public function test_it_returns_true_if_gateway_config_factory_name_is_not_pay_by_link(): void
+    {
+        $gatewayConfig = $this->prophesize(GatewayConfigInterface::class);
+        $this->paymentMethod->getGatewayConfig()->willReturn($gatewayConfig->reveal());
+        $gatewayConfig->getFactoryName()->willReturn('i_am_not_pay_by_link');
+
+        $result = $this
+            ->createTestSubject()
+            ->isSupportedForOrder($this->paymentMethod->reveal(), $this->order->reveal())
+        ;
+
+        $this->assertTrue($result);
+    }
+
+    public function test_it_returns_true_if_gateway_config_does_not_have_tpay_channel_id(): void
+    {
+        $gatewayConfig = $this->prophesize(GatewayConfigInterface::class);
+        $this->paymentMethod->getGatewayConfig()->willReturn($gatewayConfig->reveal());
+        $gatewayConfig->getFactoryName()->willReturn(GatewayName::PAY_BY_LINK);
+        $gatewayConfig->getConfig()->willReturn([]);
+
+        $result = $this
+            ->createTestSubject()
+            ->isSupportedForOrder($this->paymentMethod->reveal(), $this->order->reveal())
+        ;
+
+        $this->assertTrue($result);
+    }
+
+    public function test_it_returns_true_if_tpay_channel_id_is_valid(): void
+    {
+        $gatewayConfig = $this->prophesize(GatewayConfigInterface::class);
+        $this->paymentMethod->getGatewayConfig()->willReturn($gatewayConfig);
+        $gatewayConfig->getFactoryName()->willReturn(GatewayName::PAY_BY_LINK);
+        $gatewayConfig->getConfig()->willReturn(['tpay_channel_id' => 21]);
+        $this->orderAwareValidTpayChannelListProvider
+            ->provide($this->order)
+            ->willReturn([19 => [], 21 => [], 22 => []])
+        ;
+
+        $result = $this
+            ->createTestSubject()
+            ->isSupportedForOrder($this->paymentMethod->reveal(), $this->order->reveal())
+        ;
+
+        $this->assertTrue($result);
+    }
+
+    public function test_it_returns_false_if_tpay_channel_id_is_not_valid(): void
+    {
+        $gatewayConfig = $this->prophesize(GatewayConfigInterface::class);
+        $this->paymentMethod->getGatewayConfig()->willReturn($gatewayConfig->reveal());
+        $gatewayConfig->getFactoryName()->willReturn(GatewayName::PAY_BY_LINK);
+        $gatewayConfig->getConfig()->willReturn(['tpay_channel_id' => 21]);
+        $this->orderAwareValidTpayChannelListProvider
+            ->provide($this->order)
+            ->willReturn([19 => [], 22 => []])
+        ;
+
+        $result = $this
+            ->createTestSubject()
+            ->isSupportedForOrder($this->paymentMethod->reveal(), $this->order->reveal())
+        ;
+
+        $this->assertFalse($result);
+    }
+
+    private function createTestSubject(): PaymentMethodSupportedForOrderChecker
+    {
+        return new PaymentMethodSupportedForOrderChecker(
+            $this->cypher->reveal(),
+            $this->orderAwareValidTpayChannelListProvider->reveal(),
+        );
+    }
+}