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

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\Uuid\Uuid;
  11. use Symfony\Contracts\Service\ServiceProviderInterface;
  13. class PaymentHandlerRegistry
  14. {
  15.     /**
  16.      * @var array<string, PaymentHandlerInterface>
  17.      */
  18.     private array $handlers = [];
  20.     private Connection $connection;
  22.     /**
  23.      * @internal
  24.      */
  25.     public function __construct(
  26.         ServiceProviderInterface $syncHandlers,
  27.         ServiceProviderInterface $asyncHandlers,
  28.         ServiceProviderInterface $preparedHandlers,
  29.         ServiceProviderInterface $refundHandlers,
  30.         Connection $connection
  31.     ) {
  32.         $this->connection = $connection;
  34.         foreach (\array_keys($syncHandlers->getProvidedServices()) as $serviceId) {
  35.             $handler = $syncHandlers->get($serviceId);
  36.             $this->handlers[(string) $serviceId] = $handler;
  37.         }
  39.         foreach (\array_keys($asyncHandlers->getProvidedServices()) as $serviceId) {
  40.             $handler = $asyncHandlers->get($serviceId);
  41.             $this->handlers[(string) $serviceId] = $handler;
  42.         }
  44.         foreach (\array_keys($preparedHandlers->getProvidedServices()) as $serviceId) {
  45.             $handler = $preparedHandlers->get($serviceId);
  46.             $this->handlers[(string) $serviceId] = $handler;
  47.         }
  49.         foreach (\array_keys($refundHandlers->getProvidedServices()) as $serviceId) {
  50.             $handler = $refundHandlers->get($serviceId);
  51.             $this->handlers[(string) $serviceId] = $handler;
  52.         }
  53.     }
  55.     /**
  56.      * @deprecated tag:v6.5.0 - Will be removed. Use getPaymentMethodHandler instead.
  57.      *
  58.      * @return PaymentHandlerInterface|null
  59.      */
  60.     public function getHandler(string $handlerId)
  61.     {
  62.         Feature::triggerDeprecationOrThrow(
  63.             'v6.5.0.0',
  64.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPaymentMethodHandler()')
  65.         );
  67.         if (!\array_key_exists($handlerId, $this->handlers)) {
  68.             return null;
  69.         }
  71.         return $this->handlers[$handlerId];
  72.     }
  74.     /**
  75.      * @deprecated tag:v6.5.0 Will be removed. Use getPaymentMethodHandler instead.
  76.      *
  77.      * @return PaymentHandlerInterface|null
  78.      */
  79.     public function getHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod)
  80.     {
  81.         Feature::triggerDeprecationOrThrow(
  82.             'v6.5.0.0',
  83.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPaymentMethodHandler()')
  84.         );
  86.         return $this->getPaymentMethodHandler($paymentMethod->getId());
  87.     }
  89.     public function getPaymentMethodHandler(
  90.         string $paymentMethodId,
  91.         ?string $expectedHandlerType = null
  92.     ): ?PaymentHandlerInterface {
  93.         $statement = $this->connection->createQueryBuilder()
  94.             ->select('
  95.                 payment_method.handler_identifier,
  96.                 app_payment_method.id as app_payment_method_id,
  97.                 app_payment_method.pay_url,
  98.                 app_payment_method.finalize_url,
  99.                 app_payment_method.capture_url,
  100.                 app_payment_method.validate_url,
  101.                 app_payment_method.refund_url
  102.             ')
  103.             ->from('payment_method')
  104.             ->leftJoin(
  105.                 'payment_method',
  106.                 'app_payment_method',
  107.                 'app_payment_method',
  108.                 'payment_method.id = app_payment_method.payment_method_id'
  109.             )
  110.             ->andWhere('payment_method.id = :paymentMethodId')
  111.             ->setParameter('paymentMethodId', Uuid::fromHexToBytes($paymentMethodId))
  112.             ->execute();
  114.         $result = $statement->fetchAssociative();
  116.         if (!$result || !\array_key_exists('handler_identifier', $result)) {
  117.             return null;
  118.         }
  120.         // app payment method is set: we need to resolve an app handler
  121.         if (isset($result['app_payment_method_id'])) {
  122.             return $this->resolveAppPaymentMethodHandler($result, $expectedHandlerType);
  123.         }
  125.         $handlerIdentifier = $result['handler_identifier'];
  127.         if (!\array_key_exists($handlerIdentifier, $this->handlers)) {
  128.             return null;
  129.         }
  131.         $handler = $this->handlers[$handlerIdentifier];
  133.         // a specific handler type was requested
  134.         if ($expectedHandlerType !== null && !\is_a($handler, $expectedHandlerType, true)) {
  135.             return null;
  136.         }
  138.         return $this->handlers[$handlerIdentifier];
  139.     }
  141.     public function getSyncPaymentHandler(string $paymentMethodId): ?SynchronousPaymentHandlerInterface
  142.     {
  143.         $handler = $this->getPaymentMethodHandler($paymentMethodId, SynchronousPaymentHandlerInterface::class);
  145.         if (!$handler instanceof SynchronousPaymentHandlerInterface) {
  146.             return null;
  147.         }
  149.         return $handler;
  150.     }
  152.     public function getAsyncPaymentHandler(string $paymentMethodId): ?AsynchronousPaymentHandlerInterface
  153.     {
  154.         $handler = $this->getPaymentMethodHandler($paymentMethodId, AsynchronousPaymentHandlerInterface::class);
  156.         if (!$handler instanceof AsynchronousPaymentHandlerInterface) {
  157.             return null;
  158.         }
  160.         return $handler;
  161.     }
  163.     public function getPreparedPaymentHandler(string $paymentMethodId): ?PreparedPaymentHandlerInterface
  164.     {
  165.         $handler = $this->getPaymentMethodHandler($paymentMethodId, PreparedPaymentHandlerInterface::class);
  167.         if (!$handler instanceof PreparedPaymentHandlerInterface) {
  168.             return null;
  169.         }
  171.         return $handler;
  172.     }
  174.     public function getRefundPaymentHandler(string $paymentMethodId): ?RefundPaymentHandlerInterface
  175.     {
  176.         $handler = $this->getPaymentMethodHandler($paymentMethodId, RefundPaymentHandlerInterface::class);
  178.         if (!$handler instanceof RefundPaymentHandlerInterface) {
  179.             return null;
  180.         }
  182.         return $handler;
  183.     }
  185.     /**
  186.      * @deprecated tag:v6.5.0 Will be removed. Use getSyncPaymentHandler instead.
  187.      */
  188.     public function getSyncHandler(string $handlerId): ?SynchronousPaymentHandlerInterface
  189.     {
  190.         Feature::triggerDeprecationOrThrow(
  191.             'v6.5.0.0',
  192.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getSyncPaymentHandler()')
  193.         );
  195.         $handler = $this->getPaymentMethodHandler($handlerId);
  196.         if (!$handler || !$handler instanceof SynchronousPaymentHandlerInterface) {
  197.             return null;
  198.         }
  200.         return $handler;
  201.     }
  203.     /**
  204.      * @deprecated tag:v6.5.0 Will be removed. Use getAsyncPaymentHandler instead.
  205.      */
  206.     public function getAsyncHandler(string $handlerId): ?AsynchronousPaymentHandlerInterface
  207.     {
  208.         Feature::triggerDeprecationOrThrow(
  209.             'v6.5.0.0',
  210.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getAsyncPaymentHandler()')
  211.         );
  213.         $handler = $this->getPaymentMethodHandler($handlerId);
  214.         if (!$handler || !$handler instanceof AsynchronousPaymentHandlerInterface) {
  215.             return null;
  216.         }
  218.         return $handler;
  219.     }
  221.     /**
  222.      * @deprecated tag:v6.5.0 Will be removed. Use getSyncPaymentHandler instead.
  223.      */
  224.     public function getSyncHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?SynchronousPaymentHandlerInterface
  225.     {
  226.         Feature::triggerDeprecationOrThrow(
  227.             'v6.5.0.0',
  228.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getSyncPaymentHandler()')
  229.         );
  231.         return $this->getSyncPaymentHandler($paymentMethod->getId());
  232.     }
  234.     /**
  235.      * @deprecated tag:v6.5.0 Will be removed. Use getAsyncPaymentHandler instead.
  236.      */
  237.     public function getAsyncHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?AsynchronousPaymentHandlerInterface
  238.     {
  239.         Feature::triggerDeprecationOrThrow(
  240.             'v6.5.0.0',
  241.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getAsyncPaymentHandler()')
  242.         );
  244.         return $this->getAsyncPaymentHandler($paymentMethod->getId());
  245.     }
  247.     /**
  248.      * @deprecated tag:v6.5.0 Will be removed. Use getPreparedPaymentHandler instead.
  249.      */
  250.     public function getPreparedHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?PreparedPaymentHandlerInterface
  251.     {
  252.         Feature::triggerDeprecationOrThrow(
  253.             'v6.5.0.0',
  254.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getPreparedPaymentHandler()')
  255.         );
  257.         return $this->getPreparedPaymentHandler($paymentMethod->getId());
  258.     }
  260.     /**
  261.      * @deprecated tag:v6.5.0 Will be removed. Use getRefundPaymentHandler instead.
  262.      */
  263.     public function getRefundHandlerForPaymentMethod(PaymentMethodEntity $paymentMethod): ?RefundPaymentHandlerInterface
  264.     {
  265.         Feature::triggerDeprecationOrThrow(
  266.             'v6.5.0.0',
  267.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'getRefundPaymentHandler()')
  268.         );
  270.         return $this->getRefundPaymentHandler($paymentMethod->getId());
  271.     }
  273.     private function resolveAppPaymentMethodHandler(
  274.         array $appPaymentMethod,
  275.         ?string $expectedHandlerType = null
  276.     ): ?PaymentHandlerInterface {
  277.         // validate if prepared and refund handlers have all information set
  278.         if ($expectedHandlerType) {
  279.             if (\is_a(PreparedPaymentHandlerInterface::class, $expectedHandlerType, true)) {
  280.                 if (empty($appPaymentMethod['capture_url']) || empty($appPaymentMethod['validate_url'])) {
  281.                     return null;
  282.                 }
  283.             }
  285.             if (\is_a(RefundPaymentHandlerInterface::class, $expectedHandlerType, true)) {
  286.                 if (empty($appPaymentMethod['refund_url'])) {
  287.                     return null;
  288.                 }
  289.             }
  290.         }
  292.         if (empty($appPaymentMethod['finalize_url'])) {
  293.             return $this->handlers[AppSyncPaymentHandler::class] ?? null;
  294.         }
  296.         return $this->handlers[AppAsyncPaymentHandler::class] ?? null;
  297.     }
  298. }