src/Core/Checkout/Promotion/DataAbstractionLayer/PromotionRedemptionUpdater.php line 92

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Checkout\Promotion\DataAbstractionLayer;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Checkout\Cart\Event\CheckoutOrderPlacedEvent;
  7. use Shopware\Core\Checkout\Order\Aggregate\OrderLineItem\OrderLineItemEntity;
  8. use Shopware\Core\Checkout\Promotion\Cart\PromotionProcessor;
  9. use Shopware\Core\Defaults;
  10. use Shopware\Core\Framework\Context;
  11. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\RetryableQuery;
  12. use Shopware\Core\Framework\Log\Package;
  13. use Shopware\Core\Framework\Uuid\Uuid;
  14. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  16. /**
  17.  * @internal
  18.  */
  19. #[Package('checkout')]
  20. class PromotionRedemptionUpdater implements EventSubscriberInterface
  21. {
  22.     /**
  23.      * @internal
  24.      */
  25.     public function __construct(private readonly Connection $connection)
  26.     {
  27.     }
  29.     /**
  30.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  31.      */
  32.     public static function getSubscribedEvents(): array
  33.     {
  34.         return [
  35.             CheckoutOrderPlacedEvent::class => 'orderPlaced',
  36.         ];
  37.     }
  39.     /**
  40.      * @param array<string> $ids
  41.      */
  42.     public function update(array $ids, Context $context): void
  43.     {
  44.         $ids = array_unique(array_filter($ids));
  46.         if (empty($ids) || $context->getVersionId() !== Defaults::LIVE_VERSION) {
  47.             return;
  48.         }
  50.         $sql = <<<'SQL'
  51.                 SELECT LOWER(HEX(order_line_item.promotion_id)) as promotion_id,
  52.                        COUNT(DISTINCT order_line_item.id) as total,
  53.                        LOWER(HEX(order_customer.customer_id)) as customer_id
  54.                 FROM order_line_item
  55.                 INNER JOIN order_customer
  56.                     ON order_customer.order_id = order_line_item.order_id
  57.                     AND order_customer.version_id = order_line_item.version_id
  58.                 WHERE order_line_item.type = :type
  59.                 AND order_line_item.promotion_id IN (:ids)
  60.                 AND order_line_item.version_id = :versionId
  61.                 GROUP BY order_line_item.promotion_id, order_customer.customer_id
  62. SQL;
  64.         $promotions = $this->connection->fetchAllAssociative(
  65.             $sql,
  66.             ['type' => PromotionProcessor::LINE_ITEM_TYPE, 'ids' => Uuid::fromHexToBytesList($ids), 'versionId' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION)],
  67.             ['ids' => Connection::PARAM_STR_ARRAY]
  68.         );
  70.         if (empty($promotions)) {
  71.             return;
  72.         }
  73.         $update = new RetryableQuery(
  74.             $this->connection,
  75.             $this->connection->prepare('UPDATE promotion SET order_count = :count, orders_per_customer_count = :customerCount WHERE id = :id')
  76.         );
  78.         // group the promotions to update each promotion with a single update statement
  79.         $promotions = $this->groupByPromotion($promotions);
  81.         foreach ($promotions as $id => $totals) {
  82.             $total = array_sum($totals);
  84.             $update->execute([
  85.                 'id' => Uuid::fromHexToBytes($id),
  86.                 'count' => (int) $total,
  87.                 'customerCount' => json_encode($totals, \JSON_THROW_ON_ERROR),
  88.             ]);
  89.         }
  90.     }
  92.     public function orderPlaced(CheckoutOrderPlacedEvent $event): void
  93.     {
  94.         $lineItems = $event->getOrder()->getLineItems();
  95.         $customer = $event->getOrder()->getOrderCustomer();
  97.         if (!$lineItems || !$customer) {
  98.             return;
  99.         }
  101.         $promotionIds = [];
  102.         /** @var OrderLineItemEntity $lineItem */
  103.         foreach ($lineItems as $lineItem) {
  104.             if ($lineItem->getType() !== PromotionProcessor::LINE_ITEM_TYPE) {
  105.                 continue;
  106.             }
  108.             $promotionId = $lineItem->getPromotionId();
  109.             if ($promotionId === null) {
  110.                 continue;
  111.             }
  113.             $promotionIds[] = $promotionId;
  114.         }
  116.         if (!$promotionIds) {
  117.             return;
  118.         }
  120.         $allCustomerCounts = $this->getAllCustomerCounts($promotionIds);
  122.         $update = new RetryableQuery(
  123.             $this->connection,
  124.             $this->connection->prepare('UPDATE promotion SET order_count = order_count + 1, orders_per_customer_count = :customerCount WHERE id = :id')
  125.         );
  127.         foreach ($promotionIds as $promotionId) {
  128.             $customerId = $customer->getCustomerId();
  129.             if ($customerId !== null) {
  130.                 $allCustomerCounts[$promotionId][$customerId] = 1 + ($allCustomerCounts[$promotionId][$customerId] ?? 0);
  131.             }
  133.             $update->execute([
  134.                 'id' => Uuid::fromHexToBytes($promotionId),
  135.                 'customerCount' => json_encode($allCustomerCounts[$promotionId], \JSON_THROW_ON_ERROR),
  136.             ]);
  137.         }
  138.     }
  140.     /**
  141.      * @param array<mixed> $promotions
  142.      *
  143.      * @return array<mixed>
  144.      */
  145.     private function groupByPromotion(array $promotions): array
  146.     {
  147.         $grouped = [];
  148.         foreach ($promotions as $promotion) {
  149.             $id = $promotion['promotion_id'];
  150.             $customerId = $promotion['customer_id'];
  151.             $grouped[$id][$customerId] = (int) $promotion['total'];
  152.         }
  154.         return $grouped;
  155.     }
  157.     /**
  158.      * @param array<string> $promotionIds
  159.      *
  160.      * @return array<string>
  161.      */
  162.     private function getAllCustomerCounts(array $promotionIds): array
  163.     {
  164.         $allCustomerCounts = [];
  165.         $countResult = $this->connection->fetchAllAssociative(
  166.             'SELECT `id`, `orders_per_customer_count` FROM `promotion` WHERE `id` IN (:ids)',
  167.             ['ids' => Uuid::fromHexToBytesList($promotionIds)],
  168.             ['ids' => Connection::PARAM_STR_ARRAY]
  169.         );
  171.         foreach ($countResult as $row) {
  172.             if (!\is_string($row['orders_per_customer_count'])) {
  173.                 $allCustomerCounts[Uuid::fromBytesToHex($row['id'])] = [];
  175.                 continue;
  176.             }
  178.             $customerCount = json_decode($row['orders_per_customer_count'], true, 512, \JSON_THROW_ON_ERROR);
  179.             if (!$customerCount) {
  180.                 $allCustomerCounts[Uuid::fromBytesToHex($row['id'])] = [];
  182.                 continue;
  183.             }
  185.             $allCustomerCounts[Uuid::fromBytesToHex($row['id'])] = $customerCount;
  186.         }
  188.         return $allCustomerCounts;
  189.     }
  190. }