vendor/shopware/core/Checkout/Payment/Cart/PaymentHandler/PaymentHandlerRegistry.php line 42

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Checkout\Payment\Cart\PaymentHandler;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Checkout\Payment\PaymentMethodEntity;
  7. use Shopware\Core\Framework\App\Payment\Handler\AppAsyncPaymentHandler;
  8. use Shopware\Core\Framework\App\Payment\Handler\AppSyncPaymentHandler;
  9. use Shopware\Core\Framework\Feature;
  10. use Shopware\Core\Framework\Log\Package;
  11. use Shopware\Core\Framework\Uuid\Uuid;
  12. use Symfony\Contracts\Service\ServiceProviderInterface;
  14. #[Package('checkout')]
  15. class PaymentHandlerRegistry
  16. {
  17.     /**
  18.      * @var array<string, PaymentHandlerInterface>
  19.      */
  20.     private array $handlers = [];
  22.     private Connection $connection;
  24.     /**
  25.      * @internal
  26.      */
  27.     public function __construct(
  28.         ServiceProviderInterface $syncHandlers,
  29.         ServiceProviderInterface $asyncHandlers,
  30.         ServiceProviderInterface $preparedHandlers,
  31.         ServiceProviderInterface $refundHandlers,
  32.         Connection $connection
  33.     ) {
  34.         $this->connection = $connection;
  36.         foreach (\array_keys($syncHandlers->getProvidedServices()) as $serviceId) {
  37.             $handler = $syncHandlers->get($serviceId);
  38.             $this->handlers[(string) $serviceId] = $handler;
  39.         }
  41.         foreach (\array_keys($asyncHandlers->getProvidedServices()) as $serviceId) {
  42.             $handler = $asyncHandlers->get($serviceId);
  43.             $this->handlers[(string) $serviceId] = $handler;
  44.         }
  46.         foreach (\array_keys($preparedHandlers->getProvidedServices()) as $serviceId) {
  47.             $handler = $preparedHandlers->get($serviceId);
  48.             $this->handlers[(string) $serviceId] = $handler;
  49.         }
  51.         foreach (\array_keys($refundHandlers->getProvidedServices()) as $serviceId) {
  52.             $handler = $refundHandlers->get($serviceId);
  53.             $this->handlers[(string) $serviceId] = $handler;
  54.         }
  55.     }
  57.     /**
  58.      * @deprecated tag:v6.5.0 - Will be removed. Use getPaymentMethodHandler instead.
  59.      *
  60.      * @return PaymentHandlerInterface|null
  61.      */
  62.     public function getHandler(string $handlerId)
  63.     {
  64.         Feature::triggerDeprecationOrThrow(
  65.             'v6.5.0.0',
  66.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPaymentMethodHandler()')
  67.         );
  69.         if (!\array_key_exists($handlerId, $this->handlers)) {
  70.             return null;
  71.         }
  73.         return $this->handlers[$handlerId];
  74.     }
  76.     /**
  77.      * @deprecated tag:v6.5.0 Will be removed. Use getPaymentMethodHandler instead.
  78.      *
  79.      * @return PaymentHandlerInterface|null
  80.      */
  81.     public function getHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod)
  82.     {
  83.         Feature::triggerDeprecationOrThrow(
  84.             'v6.5.0.0',
  85.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPaymentMethodHandler()')
  86.         );
  88.         return $this->getPaymentMethodHandler($paymentMethod->getId());
  89.     }
  91.     public function getPaymentMethodHandler(
  92.         string $paymentMethodId,
  93.         ?string $expectedHandlerType = null
  94.     ): ?PaymentHandlerInterface {
  95.         $statement = $this->connection->createQueryBuilder()
  96.             ->select('
  97.                 payment_method.handler_identifier,
  98.                 app_payment_method.id as app_payment_method_id,
  99.                 app_payment_method.pay_url,
  100.                 app_payment_method.finalize_url,
  101.                 app_payment_method.capture_url,
  102.                 app_payment_method.validate_url,
  103.                 app_payment_method.refund_url
  104.             ')
  105.             ->from('payment_method')
  106.             ->leftJoin(
  107.                 'payment_method',
  108.                 'app_payment_method',
  109.                 'app_payment_method',
  110.                 'payment_method.id = app_payment_method.payment_method_id'
  111.             )
  112.             ->andWhere('payment_method.id = :paymentMethodId')
  113.             ->setParameter('paymentMethodId', Uuid::fromHexToBytes($paymentMethodId))
  114.             ->execute();
  116.         $result = $statement->fetchAssociative();
  118.         if (!$result || !\array_key_exists('handler_identifier', $result)) {
  119.             return null;
  120.         }
  122.         // app payment method is set: we need to resolve an app handler
  123.         if (isset($result['app_payment_method_id'])) {
  124.             return $this->resolveAppPaymentMethodHandler($result, $expectedHandlerType);
  125.         }
  127.         $handlerIdentifier = $result['handler_identifier'];
  129.         if (!\array_key_exists($handlerIdentifier, $this->handlers)) {
  130.             return null;
  131.         }
  133.         $handler = $this->handlers[$handlerIdentifier];
  135.         // a specific handler type was requested
  136.         if ($expectedHandlerType !== null && !\is_a($handler, $expectedHandlerType, true)) {
  137.             return null;
  138.         }
  140.         return $this->handlers[$handlerIdentifier];
  141.     }
  143.     public function getSyncPaymentHandler(string $paymentMethodId): ?SynchronousPaymentHandlerInterface
  144.     {
  145.         $handler = $this->getPaymentMethodHandler($paymentMethodId, SynchronousPaymentHandlerInterface::class);
  147.         if (!$handler instanceof SynchronousPaymentHandlerInterface) {
  148.             return null;
  149.         }
  151.         return $handler;
  152.     }
  154.     public function getAsyncPaymentHandler(string $paymentMethodId): ?AsynchronousPaymentHandlerInterface
  155.     {
  156.         $handler = $this->getPaymentMethodHandler($paymentMethodId, AsynchronousPaymentHandlerInterface::class);
  158.         if (!$handler instanceof AsynchronousPaymentHandlerInterface) {
  159.             return null;
  160.         }
  162.         return $handler;
  163.     }
  165.     public function getPreparedPaymentHandler(string $paymentMethodId): ?PreparedPaymentHandlerInterface
  166.     {
  167.         $handler = $this->getPaymentMethodHandler($paymentMethodId, PreparedPaymentHandlerInterface::class);
  169.         if (!$handler instanceof PreparedPaymentHandlerInterface) {
  170.             return null;
  171.         }
  173.         return $handler;
  174.     }
  176.     public function getRefundPaymentHandler(string $paymentMethodId): ?RefundPaymentHandlerInterface
  177.     {
  178.         $handler = $this->getPaymentMethodHandler($paymentMethodId, RefundPaymentHandlerInterface::class);
  180.         if (!$handler instanceof RefundPaymentHandlerInterface) {
  181.             return null;
  182.         }
  184.         return $handler;
  185.     }
  187.     /**
  188.      * @deprecated tag:v6.5.0 Will be removed. Use getSyncPaymentHandler instead.
  189.      */
  190.     public function getSyncHandler(string $handlerId): ?SynchronousPaymentHandlerInterface
  191.     {
  192.         Feature::triggerDeprecationOrThrow(
  193.             'v6.5.0.0',
  194.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getSyncPaymentHandler()')
  195.         );
  197.         $handler = $this->getPaymentMethodHandler($handlerId);
  198.         if (!$handler || !$handler instanceof SynchronousPaymentHandlerInterface) {
  199.             return null;
  200.         }
  202.         return $handler;
  203.     }
  205.     /**
  206.      * @deprecated tag:v6.5.0 Will be removed. Use getAsyncPaymentHandler instead.
  207.      */
  208.     public function getAsyncHandler(string $handlerId): ?AsynchronousPaymentHandlerInterface
  209.     {
  210.         Feature::triggerDeprecationOrThrow(
  211.             'v6.5.0.0',
  212.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getAsyncPaymentHandler()')
  213.         );
  215.         $handler = $this->getPaymentMethodHandler($handlerId);
  216.         if (!$handler || !$handler instanceof AsynchronousPaymentHandlerInterface) {
  217.             return null;
  218.         }
  220.         return $handler;
  221.     }
  223.     /**
  224.      * @deprecated tag:v6.5.0 Will be removed. Use getSyncPaymentHandler instead.
  225.      */
  226.     public function getSyncHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?SynchronousPaymentHandlerInterface
  227.     {
  228.         Feature::triggerDeprecationOrThrow(
  229.             'v6.5.0.0',
  230.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getSyncPaymentHandler()')
  231.         );
  233.         return $this->getSyncPaymentHandler($paymentMethod->getId());
  234.     }
  236.     /**
  237.      * @deprecated tag:v6.5.0 Will be removed. Use getAsyncPaymentHandler instead.
  238.      */
  239.     public function getAsyncHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?AsynchronousPaymentHandlerInterface
  240.     {
  241.         Feature::triggerDeprecationOrThrow(
  242.             'v6.5.0.0',
  243.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getAsyncPaymentHandler()')
  244.         );
  246.         return $this->getAsyncPaymentHandler($paymentMethod->getId());
  247.     }
  249.     /**
  250.      * @deprecated tag:v6.5.0 Will be removed. Use getPreparedPaymentHandler instead.
  251.      */
  252.     public function getPreparedHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?PreparedPaymentHandlerInterface
  253.     {
  254.         Feature::triggerDeprecationOrThrow(
  255.             'v6.5.0.0',
  256.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPreparedPaymentHandler()')
  257.         );
  259.         return $this->getPreparedPaymentHandler($paymentMethod->getId());
  260.     }
  262.     /**
  263.      * @deprecated tag:v6.5.0 Will be removed. Use getRefundPaymentHandler instead.
  264.      */
  265.     public function getRefundHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?RefundPaymentHandlerInterface
  266.     {
  267.         Feature::triggerDeprecationOrThrow(
  268.             'v6.5.0.0',
  269.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getRefundPaymentHandler()')
  270.         );
  272.         return $this->getRefundPaymentHandler($paymentMethod->getId());
  273.     }
  275.     private function resolveAppPaymentMethodHandler(
  276.         array $appPaymentMethod,
  277.         ?string $expectedHandlerType = null
  278.     ): ?PaymentHandlerInterface {
  279.         // validate if prepared and refund handlers have all information set
  280.         if ($expectedHandlerType) {
  281.             if (\is_a(PreparedPaymentHandlerInterface::class, $expectedHandlerType, true)) {
  282.                 if (empty($appPaymentMethod['capture_url']) || empty($appPaymentMethod['validate_url'])) {
  283.                     return null;
  284.                 }
  285.             }
  287.             if (\is_a(RefundPaymentHandlerInterface::class, $expectedHandlerType, true)) {
  288.                 if (empty($appPaymentMethod['refund_url'])) {
  289.                     return null;
  290.                 }
  291.             }
  292.         }
  294.         if (empty($appPaymentMethod['finalize_url'])) {
  295.             return $this->handlers[AppSyncPaymentHandler::class] ?? null;
  296.         }
  298.         return $this->handlers[AppAsyncPaymentHandler::class] ?? null;
  299.     }
  300. }