vendor/shopware/core/Content/ImportExport/Event/Subscriber/ProductVariantsSubscriber.php line 63

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\ImportExport\Event\Subscriber;
  5. use Doctrine\DBAL\ArrayParameterType;
  6. use Doctrine\DBAL\Connection;
  7. use Shopware\Core\Content\ImportExport\Event\ImportExportAfterImportRecordEvent;
  8. use Shopware\Core\Content\ImportExport\Exception\ProcessingException;
  9. use Shopware\Core\Content\Product\Aggregate\ProductConfiguratorSetting\ProductConfiguratorSettingDefinition;
  10. use Shopware\Core\Content\Product\ProductDefinition;
  11. use Shopware\Core\Framework\Api\Sync\SyncBehavior;
  12. use Shopware\Core\Framework\Api\Sync\SyncOperation;
  13. use Shopware\Core\Framework\Api\Sync\SyncServiceInterface;
  14. use Shopware\Core\Framework\Context;
  15. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  19. use Shopware\Core\Framework\Log\Package;
  20. use Shopware\Core\Framework\Uuid\Uuid;
  21. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  22. use Symfony\Contracts\Service\ResetInterface;
  24. /**
  25.  * @internal
  26.  *
  27.  * @phpstan-type CombinationPayload list<array{id: string, parentId: string, productNumber: string, stock: int, options: list<array{id: string, name: string, group: array{id: string, name: string}}>}>
  28.  */
  29. #[Package('system-settings')]
  30. class ProductVariantsSubscriber implements EventSubscriberInterface, ResetInterface
  31. {
  32.     /**
  33.      * @var array<string, string>
  34.      */
  35.     private array $groupIdCache = [];
  37.     /**
  38.      * @var array<string, string>
  39.      */
  40.     private array $optionIdCache = [];
  42.     /**
  43.      * @internal
  44.      */
  45.     public function __construct(
  46.         private readonly SyncServiceInterface $syncService,
  47.         private readonly Connection $connection,
  48.         private readonly EntityRepository $groupRepository,
  49.         private readonly EntityRepository $optionRepository
  50.     ) {
  51.     }
  53.     /**
  54.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  55.      */
  56.     public static function getSubscribedEvents(): array
  57.     {
  58.         return [
  59.             ImportExportAfterImportRecordEvent::class => 'onAfterImportRecord',
  60.         ];
  61.     }
  63.     public function onAfterImportRecord(ImportExportAfterImportRecordEvent $event): void
  64.     {
  65.         $row = $event->getRow();
  66.         $entityName = $event->getConfig()->get('sourceEntity');
  67.         $entityWrittenEvents = $event->getResult()->getEvents();
  69.         if ($entityName !== ProductDefinition::ENTITY_NAME || empty($row['variants']) || !$entityWrittenEvents) {
  70.             return;
  71.         }
  73.         $variants = $this->parseVariantString($row['variants']);
  75.         $entityWrittenEvent = $entityWrittenEvents->filter(fn ($event) => $event instanceof EntityWrittenEvent && $event->getEntityName() === ProductDefinition::ENTITY_NAME)->first();
  77.         if (!$entityWrittenEvent instanceof EntityWrittenEvent) {
  78.             return;
  79.         }
  81.         $writeResults = $entityWrittenEvent->getWriteResults();
  83.         if (empty($writeResults)) {
  84.             return;
  85.         }
  87.         $parentId = $writeResults[0]->getPrimaryKey();
  88.         $parentPayload = $writeResults[0]->getPayload();
  90.         if (!\is_string($parentId)) {
  91.             return;
  92.         }
  94.         $payload = $this->getCombinationsPayload($variants, $parentId, $parentPayload['productNumber']);
  95.         $variantIds = array_column($payload, 'id');
  96.         $this->connection->executeStatement(
  97.             'DELETE FROM `product_option` WHERE `product_id` IN (:ids);',
  98.             ['ids' => Uuid::fromHexToBytesList($variantIds)],
  99.             ['ids' => ArrayParameterType::STRING]
  100.         );
  101.         $configuratorSettingPayload = $this->getProductConfiguratorSettingPayload($payload, $parentId);
  102.         $this->connection->executeStatement(
  103.             'DELETE FROM `product_configurator_setting` WHERE `product_id` = :parentId AND `id` NOT IN (:ids);',
  104.             [
  105.                 'parentId' => Uuid::fromHexToBytes($parentId),
  106.                 'ids' => Uuid::fromHexToBytesList(array_column($configuratorSettingPayload, 'id')),
  107.             ],
  108.             ['ids' => ArrayParameterType::STRING]
  109.         );
  111.         $this->syncService->sync([
  112.             new SyncOperation(
  113.                 'write',
  114.                 ProductDefinition::ENTITY_NAME,
  115.                 SyncOperation::ACTION_UPSERT,
  116.                 $payload
  117.             ),
  118.             new SyncOperation(
  119.                 'write',
  120.                 ProductConfiguratorSettingDefinition::ENTITY_NAME,
  121.                 SyncOperation::ACTION_UPSERT,
  122.                 $configuratorSettingPayload
  123.             ),
  124.         ], Context::createDefaultContext(), new SyncBehavior());
  125.     }
  127.     public function reset(): void
  128.     {
  129.         $this->groupIdCache = [];
  130.         $this->optionIdCache = [];
  131.     }
  133.     /**
  134.      * convert "size: m, l, xl" to ["size|m", "size|l", "size|xl"]
  135.      *
  136.      * @return list<array<string>>
  137.      */
  138.     private function parseVariantString(string $variantsString): array
  139.     {
  140.         $result = [];
  142.         $groups = explode('|', $variantsString);
  144.         foreach ($groups as $group) {
  145.             $groupOptions = explode(':', $group);
  147.             if (\count($groupOptions) !== 2) {
  148.                 $this->throwExceptionFailedParsingVariants($variantsString);
  149.             }
  151.             $groupName = trim($groupOptions[0]);
  152.             $options = array_filter(array_map('trim', explode(',', $groupOptions[1])));
  154.             if (empty($groupName) || empty($options)) {
  155.                 $this->throwExceptionFailedParsingVariants($variantsString);
  156.             }
  158.             $options = array_map(fn ($option) => sprintf('%s|%s', $groupName, $option), $options);
  160.             $result[] = $options;
  161.         }
  163.         return $result;
  164.     }
  166.     private function throwExceptionFailedParsingVariants(string $variantsString): void
  167.     {
  168.         throw new ProcessingException(sprintf(
  169.             'Failed parsing variants from string "%s", valid format is: "size: L, XL, | color: Green, White"',
  170.             $variantsString
  171.         ));
  172.     }
  174.     /**
  175.      * @param list<array<string>> $variants
  176.      *
  177.      * @return CombinationPayload
  178.      */
  179.     private function getCombinationsPayload(array $variants, string $parentId, string $productNumber): array
  180.     {
  181.         $combinations = $this->getCombinations($variants);
  182.         $payload = [];
  184.         foreach ($combinations as $key => $combination) {
  185.             $options = [];
  187.             if (\is_string($combination)) {
  188.                 $combination = [$combination];
  189.             }
  191.             foreach ($combination as $option) {
  192.                 [$group, $option] = explode('|', $option);
  194.                 $optionId = $this->getOptionId($group, $option);
  195.                 $groupId = $this->getGroupId($group);
  197.                 $options[] = [
  198.                     'id' => $optionId,
  199.                     'name' => $option,
  200.                     'group' => [
  201.                         'id' => $groupId,
  202.                         'name' => $group,
  203.                     ],
  204.                 ];
  205.             }
  207.             $variantId = Uuid::fromStringToHex(sprintf('%s.%s', $parentId, $key));
  208.             $variantProductNumber = sprintf('%s.%s', $productNumber, $key);
  210.             $payload[] = [
  211.                 'id' => $variantId,
  212.                 'parentId' => $parentId,
  213.                 'productNumber' => $variantProductNumber,
  214.                 'stock' => 0,
  215.                 'options' => $options,
  216.             ];
  217.         }
  219.         return $payload;
  220.     }
  222.     /**
  223.      * convert [["size|m", "size|l"], ["color|blue", "color|red"]]
  224.      * to [["size|m", "color|blue"], ["size|l", "color|blue"], ["size|m", "color|red"], ["size|l", "color|red"]]
  225.      *
  226.      * @param list<array<string>> $variants
  227.      *
  228.      * @return list<array<string>>|array<string>
  229.      */
  230.     private function getCombinations(array $variants, int $currentIndex = 0): array
  231.     {
  232.         if (!isset($variants[$currentIndex])) {
  233.             return [];
  234.         }
  236.         if ($currentIndex === \count($variants) - 1) {
  237.             return $variants[$currentIndex];
  238.         }
  240.         // get combinations from subsequent arrays
  241.         $combinations = $this->getCombinations($variants, $currentIndex + 1);
  243.         $result = [];
  245.         // concat each array from tmp with each element from $variants[$i]
  246.         foreach ($variants[$currentIndex] as $variant) {
  247.             foreach ($combinations as $combination) {
  248.                 $result[] = \is_array($combination) ? [...[$variant], ...$combination] : [$variant, $combination];
  249.             }
  250.         }
  252.         return $result;
  253.     }
  255.     /**
  256.      * @param CombinationPayload $variantsPayload
  257.      *
  258.      * @return list<array{id: string, optionId: string, productId: string}>
  259.      */
  260.     private function getProductConfiguratorSettingPayload(array $variantsPayload, string $parentId): array
  261.     {
  262.         $options = array_merge(...array_column($variantsPayload, 'options'));
  263.         $optionIds = array_unique(array_column($options, 'id'));
  265.         $payload = [];
  267.         foreach ($optionIds as $optionId) {
  268.             $payload[] = [
  269.                 'id' => Uuid::fromStringToHex(sprintf('%s_configurator', $optionId)),
  270.                 'optionId' => $optionId,
  271.                 'productId' => $parentId,
  272.             ];
  273.         }
  275.         return $payload;
  276.     }
  278.     private function getGroupId(string $groupName): string
  279.     {
  280.         $groupId = Uuid::fromStringToHex($groupName);
  282.         if (isset($this->groupIdCache[$groupId])) {
  283.             return $this->groupIdCache[$groupId];
  284.         }
  286.         $criteria = new Criteria();
  287.         $criteria->addFilter(new EqualsFilter('name', $groupName));
  289.         $group = $this->groupRepository->search($criteria, Context::createDefaultContext())->first();
  291.         if ($group !== null) {
  292.             $this->groupIdCache[$groupId] = $group->getId();
  294.             return $group->getId();
  295.         }
  297.         $this->groupIdCache[$groupId] = $groupId;
  299.         return $groupId;
  300.     }
  302.     private function getOptionId(string $groupName, string $optionName): string
  303.     {
  304.         $optionId = Uuid::fromStringToHex(sprintf('%s.%s', $groupName, $optionName));
  306.         if (isset($this->optionIdCache[$optionId])) {
  307.             return $this->optionIdCache[$optionId];
  308.         }
  310.         $criteria = new Criteria();
  311.         $criteria->addFilter(new EqualsFilter('name', $optionName));
  312.         $criteria->addFilter(new EqualsFilter('group.name', $groupName));
  314.         $option = $this->optionRepository->search($criteria, Context::createDefaultContext())->first();
  316.         if ($option !== null) {
  317.             $this->optionIdCache[$optionId] = $option->getId();
  319.             return $option->getId();
  320.         }
  322.         $this->optionIdCache[$optionId] = $optionId;
  324.         return $optionId;
  325.     }
  326. }