custom/plugins/PickwareErpStarter/vendor/pickware/shopware-extensions-bundle/src/OrderConfiguration/OrderConfigurationUpdater.php line 51

Open in your IDE?
  1. <?php
  2. /*
  3.  * Copyright (c) Pickware GmbH. All rights reserved.
  4.  * This file is part of software that is released under a proprietary license.
  5.  * You must not copy, modify, distribute, make publicly available, or execute
  6.  * its contents or parts thereof without express permission by the copyright
  7.  * holder, unless otherwise permitted by law.
  8.  */
  10. declare(strict_types=1);
  12. namespace Pickware\ShopwareExtensionsBundle\OrderConfiguration;
  14. use Doctrine\DBAL\Connection;
  15. use Pickware\DalBundle\RetryableTransaction;
  16. use Pickware\DalBundle\Sql\SqlUuid;
  17. use Shopware\Core\Checkout\Order\OrderEvents;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  19. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  21. class OrderConfigurationUpdater implements EventSubscriberInterface
  22. {
  23.     private Connection $connection;
  25.     public function __construct(Connection $connection)
  26.     {
  27.         $this->connection = $connection;
  28.     }
  30.     public static function getSubscribedEvents(): array
  31.     {
  32.         return [
  33.             OrderEvents::ORDER_WRITTEN_EVENT => 'orderWritten',
  34.             OrderEvents::ORDER_DELIVERY_WRITTEN_EVENT => 'orderDeliveryWritten',
  35.             OrderEvents::ORDER_DELIVERY_DELETED_EVENT => 'updateOrderConfigurationAfterDeliveryOrTransactionDeletion',
  36.             OrderEvents::ORDER_TRANSACTION_WRITTEN_EVENT => 'orderTransactionWritten',
  37.             OrderEvents::ORDER_TRANSACTION_DELETED_EVENT => 'updateOrderConfigurationAfterDeliveryOrTransactionDeletion',
  38.         ];
  39.     }
  41.     /**
  42.      * This subscriber method only ensures that the order configuration exists (without updating the actual primary
  43.      * delivery state or primary transaction state) when an order is written. If an order is written _with_ a delivery
  44.      * or transaction, the other events (ORDER_DELIVERY_WRITTEN_EVENT and/or ORDER_TRANSACTION_WRITTEN_EVENT) will be
  45.      * triggered as well, which in turn will update the primary states of the order configuration.
  46.      *
  47.      * So in production this lone "ensure order configuration exists" subscriber is relevant for creating orders
  48.      * without order deliveries or order transactions. This way we can ensure that the order configuration extension
  49.      * always exists.
  50.      */
  51.     public function orderWritten(EntityWrittenEvent $event): void
  52.     {
  53.         $orderIds = [];
  54.         foreach ($event->getWriteResults() as $writeResult) {
  55.             $payload = $writeResult->getPayload();
  56.             if (!array_key_exists('id', $payload)) {
  57.                 // If an order is deleted, this event is also triggered and there is no ID in the payload. The ON DELETE
  58.                 // CASCADE foreign key will delete the order configuration extension.
  59.                 continue;
  60.             }
  61.             $orderIds[] = $payload['id'];
  62.         }
  63.         $this->ensureOrderConfigurationsExist($orderIds);
  64.     }
  66.     /**
  67.      * This event is dispatched when an order delivery is created or updated (not when it is deleted).
  68.      */
  69.     public function orderDeliveryWritten(EntityWrittenEvent $event): void
  70.     {
  71.         $orderIds = $this->getOrderIdsFromOrderAssociationWrittenEvent($event, 'order_delivery');
  72.         if (count($orderIds) === 0) {
  73.             return;
  74.         }
  76.         RetryableTransaction::retryable($this->connection, function () use ($orderIds): void {
  77.             $this->ensureOrderConfigurationsExist($orderIds);
  78.             $this->updatePrimaryOrderDeliveries($orderIds);
  79.         });
  80.     }
  82.     /**
  83.      * This event is dispatched when an order transaction is created or updated (not when it is deleted).
  84.      */
  85.     public function orderTransactionWritten(EntityWrittenEvent $event): void
  86.     {
  87.         $orderIds = $this->getOrderIdsFromOrderAssociationWrittenEvent($event, 'order_transaction');
  88.         if (count($orderIds) === 0) {
  89.             return;
  90.         }
  92.         RetryableTransaction::retryable($this->connection, function () use ($orderIds): void {
  93.             $this->ensureOrderConfigurationsExist($orderIds);
  94.             $this->updatePrimaryOrderTransactions($orderIds);
  95.         });
  96.     }
  98.     private function getOrderIdsFromOrderAssociationWrittenEvent(
  99.         EntityWrittenEvent $event,
  100.         string $orderAssociationTableName
  101.     ): array {
  102.         $ids = [];
  103.         foreach ($event->getWriteResults() as $writeResult) {
  104.             $payload = $writeResult->getPayload();
  105.             if (!array_key_exists('id', $payload)) {
  106.                 // Whenever an order delivery or order transaction is written (created or updated), the 'id' must be
  107.                 // present in the payload. We are not 100% sure when or how this scenario occurs when there is no id set
  108.                 // in the payload. But a customer reported it in this SCS Support Ticket 212711.
  109.                 continue;
  110.             }
  111.             $ids[] = $payload['id'];
  112.         }
  113.         if (count($ids) === 0) {
  114.             return [];
  115.         }
  117.         return array_unique(array_values($this->connection->fetchFirstColumn(
  118.             'SELECT LOWER(HEX(`order_id`)) FROM `' . $orderAssociationTableName . '` WHERE `id` IN (:ids)',
  119.             ['ids' => array_map('hex2bin', $ids)],
  120.             ['ids' => Connection::PARAM_STR_ARRAY],
  121.         )));
  122.     }
  124.     /**
  125.      * @param String[] $orderIds
  126.      */
  127.     public function updateOrderConfigurations(array $orderIds): void
  128.     {
  129.         if (count($orderIds) === 0) {
  130.             return;
  131.         }
  133.         RetryableTransaction::retryable($this->connection, function () use ($orderIds): void {
  134.             $this->ensureOrderConfigurationsExist($orderIds);
  135.             $this->updatePrimaryOrderDeliveries($orderIds);
  136.             $this->updatePrimaryOrderTransactions($orderIds);
  137.         });
  138.     }
  140.     /**
  141.      * @param String[] $orderIds
  142.      */
  143.     private function ensureOrderConfigurationsExist(array $orderIds): void
  144.     {
  145.         $this->connection->executeStatement(
  146.             'INSERT INTO `pickware_shopware_extensions_order_configuration`
  147.             (
  148.                 `id`,
  149.                 `version_id`,
  150.                 `order_id`,
  151.                 `order_version_id`,
  152.                 `created_at`
  153.             ) SELECT
  154.                 ' . SqlUuid::UUID_V4_GENERATION . ',
  155.                 `version_id`,
  156.                 `id`,
  157.                 `version_id`,
  158.                 NOW(3)
  159.             FROM `order`
  160.             WHERE `order`.`id` IN (:orderIds)
  161.             ON DUPLICATE KEY UPDATE `pickware_shopware_extensions_order_configuration`.`id` = `pickware_shopware_extensions_order_configuration`.`id`',
  162.             ['orderIds' => array_map('hex2bin', $orderIds)],
  163.             ['orderIds' => Connection::PARAM_STR_ARRAY],
  164.         );
  165.     }
  167.     /**
  168.      * The order transactions and order deliveries are referenced in the
  169.      * `pickware_shopware_extensions_order_configuration` table. If such a reference is deleted, the respective
  170.      * reference field is nulled due to the ON DELETE SET NULL foreign key. In the ENTITY_DELETED event we have no way
  171.      * of knowing which order we have to update, because all references are gone at that point in time. Therefore, we
  172.      * check every order that has a null reference on a primary order transaction or order delivery. These should be
  173.      * only a few, ideally only the order of the recently deleted reference, because there should be no orders without
  174.      * order deliveries or order transactions in production.
  175.      *
  176.      * It is also possible that a non-primary order delivery or non-primary order transaction was deleted when this
  177.      * subscriber was triggered and this method will return early without any update.
  178.      */
  179.     public function updateOrderConfigurationAfterDeliveryOrTransactionDeletion(): void
  180.     {
  181.         RetryableTransaction::retryable($this->connection, function (): void {
  182.             $orderIds = $this->connection->fetchFirstColumn(
  183.                 'SELECT LOWER(HEX(`order_id`)) FROM `pickware_shopware_extensions_order_configuration` orderConfiguration
  184.                 WHERE (
  185.                     orderConfiguration.`primary_order_delivery_id` IS NULL
  186.                     OR orderConfiguration.`primary_order_transaction_id` IS NULL
  187.                 )',
  188.             );
  189.             if (!$orderIds) {
  190.                 return;
  191.             }
  192.             $this->updatePrimaryOrderDeliveries($orderIds);
  193.             $this->updatePrimaryOrderTransactions($orderIds);
  194.         });
  195.     }
  197.     /**
  198.      * @param String[] $orderIds
  199.      */
  200.     private function updatePrimaryOrderDeliveries(array $orderIds): void
  201.     {
  202.         $this->connection->executeStatement(
  203.             'UPDATE `pickware_shopware_extensions_order_configuration` orderConfiguration
  204.             LEFT JOIN `order`
  205.                 ON `order`.`id` = orderConfiguration.`order_id`
  206.                 AND `order`.`version_id` = orderConfiguration.`order_version_id`
  208.             -- Select a single order delivery with the highest shippingCosts.unitPrice as the primary order
  209.             -- delivery for the order. This selection strategy is adapted from how order deliveries are selected
  210.             -- in the administration. See /administration/src/module/sw-order/view/sw-order-detail-base/index.js
  211.             LEFT JOIN (
  212.                 SELECT
  213.                     `order_id`,
  214.                     `order_version_id`,
  215.                     MAX(
  216.                         CAST(JSON_UNQUOTE(
  217.                             JSON_EXTRACT(`order_delivery`.`shipping_costs`, "$.unitPrice")
  218.                         ) AS DECIMAL)
  219.                     ) AS `unitPrice`
  220.                 FROM `order_delivery`
  221.                 GROUP BY `order_id`, `order_version_id`
  222.             ) `primary_order_delivery_shipping_cost`
  223.                 ON `primary_order_delivery_shipping_cost`.`order_id` = `order`.`id`
  224.                 AND `primary_order_delivery_shipping_cost`.`order_version_id` = `order`.`version_id`
  225.             LEFT JOIN `order_delivery`
  226.                 ON `order_delivery`.`order_id` = `order`.`id`
  227.                 AND `order_delivery`.`order_version_id` = `order`.`version_id`
  228.                 AND CAST(JSON_UNQUOTE(JSON_EXTRACT(`order_delivery`.`shipping_costs`, "$.unitPrice")) AS DECIMAL) = `primary_order_delivery_shipping_cost`.`unitPrice`
  230.             SET orderConfiguration.`primary_order_delivery_id` = `order_delivery`.`id`,
  231.                 orderConfiguration.`primary_order_delivery_version_id` = `order_delivery`.`version_id`
  233.             WHERE orderConfiguration.`order_id` IN (:orderIds)',
  234.             ['orderIds' => array_map('hex2bin', $orderIds)],
  235.             ['orderIds' => Connection::PARAM_STR_ARRAY],
  236.         );
  237.     }
  239.     /**
  240.      * @param String[] $orderIds
  241.      */
  242.     private function updatePrimaryOrderTransactions(array $orderIds): void
  243.     {
  244.         $this->connection->executeStatement(
  245.             'UPDATE `pickware_shopware_extensions_order_configuration` orderConfiguration
  246.             LEFT JOIN `order`
  247.                 ON `order`.`id` = orderConfiguration.`order_id`
  248.                 AND `order`.`version_id` = orderConfiguration.`order_version_id`
  250.             -- Select oldest order transaction that is not "cancelled" or "failed" else return the last order transaction.
  251.             -- https://github.com/shopware/platform/blob/v6.4.8.1/src/Administration/Resources/app/administration/src/module/sw-order/view/sw-order-detail-base/index.js#L91-L98
  252.             -- https://github.com/shopware/platform/blob/v6.4.8.1/src/Administration/Resources/app/administration/src/module/sw-order/view/sw-order-detail-base/index.js#L207
  253.             LEFT JOIN `order_transaction`
  254.                 ON `order_transaction`.`id` = (
  255.                     SELECT innerOrderTransaction.`id`
  256.                     FROM `order_transaction` innerOrderTransaction
  257.                     LEFT JOIN `state_machine_state` AS innerOrderTransactionState
  258.                         ON innerOrderTransactionState.`id` = innerOrderTransaction.`state_id`
  259.                     WHERE innerOrderTransaction.`order_id` = `order`.`id`
  260.                     AND innerOrderTransaction.`version_id` = `order`.`version_id`
  261.                     ORDER BY
  262.                         IF((
  263.                             innerOrderTransactionState.`technical_name` = "cancelled" OR
  264.                             innerOrderTransactionState.`technical_name` = "failed"
  265.                         ), 0, 1) DESC,
  266.                         innerOrderTransaction.created_at ASC
  267.                     LIMIT 1
  268.                 ) AND `order_transaction`.`version_id` = `order`.`version_id`
  270.             SET orderConfiguration.`primary_order_transaction_id` = `order_transaction`.`id`,
  271.                 orderConfiguration.`primary_order_transaction_version_id` = `order_transaction`.`version_id`
  273.             WHERE orderConfiguration.`order_id` IN (:orderIds)',
  274.             ['orderIds' => array_map('hex2bin', $orderIds)],
  275.             ['orderIds' => Connection::PARAM_STR_ARRAY],
  276.         );
  277.     }
  278. }