src/Core/Content/ImportExport/Event/Subscriber/ProductVariantsSubscriber.php line 62

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\ImportExport\Event\Subscriber;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Content\ImportExport\Event\ImportExportAfterImportRecordEvent;
  7. use Shopware\Core\Content\ImportExport\Exception\ProcessingException;
  8. use Shopware\Core\Content\Product\Aggregate\ProductConfiguratorSetting\ProductConfiguratorSettingDefinition;
  9. use Shopware\Core\Content\Product\ProductDefinition;
  10. use Shopware\Core\Framework\Api\Sync\SyncBehavior;
  11. use Shopware\Core\Framework\Api\Sync\SyncOperation;
  12. use Shopware\Core\Framework\Api\Sync\SyncServiceInterface;
  13. use Shopware\Core\Framework\Context;
  14. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  18. use Shopware\Core\Framework\Log\Package;
  19. use Shopware\Core\Framework\Uuid\Uuid;
  20. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  21. use Symfony\Contracts\Service\ResetInterface;
  23. /**
  24.  * @internal
  25.  *
  26.  * @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}}>}>
  27.  */
  28. #[Package('system-settings')]
  29. class ProductVariantsSubscriber implements EventSubscriberInterface, ResetInterface
  30. {
  31.     /**
  32.      * @var array<string, string>
  33.      */
  34.     private array $groupIdCache = [];
  36.     /**
  37.      * @var array<string, string>
  38.      */
  39.     private array $optionIdCache = [];
  41.     /**
  42.      * @internal
  43.      */
  44.     public function __construct(
  45.         private readonly SyncServiceInterface $syncService,
  46.         private readonly Connection $connection,
  47.         private readonly EntityRepository $groupRepository,
  48.         private readonly EntityRepository $optionRepository
  49.     ) {
  50.     }
  52.     /**
  53.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  54.      */
  55.     public static function getSubscribedEvents(): array
  56.     {
  57.         return [
  58.             ImportExportAfterImportRecordEvent::class => 'onAfterImportRecord',
  59.         ];
  60.     }
  62.     public function onAfterImportRecord(ImportExportAfterImportRecordEvent $event): void
  63.     {
  64.         $row = $event->getRow();
  65.         $entityName = $event->getConfig()->get('sourceEntity');
  66.         $entityWrittenEvents = $event->getResult()->getEvents();
  68.         if ($entityName !== ProductDefinition::ENTITY_NAME || empty($row['variants']) || !$entityWrittenEvents) {
  69.             return;
  70.         }
  72.         $variants = $this->parseVariantString($row['variants']);
  74.         $entityWrittenEvent = $entityWrittenEvents->filter(fn ($event) => $event instanceof EntityWrittenEvent && $event->getEntityName() === ProductDefinition::ENTITY_NAME)->first();
  76.         if (!$entityWrittenEvent instanceof EntityWrittenEvent) {
  77.             return;
  78.         }
  80.         $writeResults = $entityWrittenEvent->getWriteResults();
  82.         if (empty($writeResults)) {
  83.             return;
  84.         }
  86.         $parentId = $writeResults[0]->getPrimaryKey();
  87.         $parentPayload = $writeResults[0]->getPayload();
  89.         if (!\is_string($parentId)) {
  90.             return;
  91.         }
  93.         $payload = $this->getCombinationsPayload($variants, $parentId, $parentPayload['productNumber']);
  94.         $variantIds = array_column($payload, 'id');
  95.         $this->connection->executeStatement(
  96.             'DELETE FROM `product_option` WHERE `product_id` IN (:ids);',
  97.             ['ids' => Uuid::fromHexToBytesList($variantIds)],
  98.             ['ids' => Connection::PARAM_STR_ARRAY]
  99.         );
  100.         $configuratorSettingPayload = $this->getProductConfiguratorSettingPayload($payload, $parentId);
  101.         $this->connection->executeStatement(
  102.             'DELETE FROM `product_configurator_setting` WHERE `product_id` = :parentId AND `id` NOT IN (:ids);',
  103.             [
  104.                 'parentId' => Uuid::fromHexToBytes($parentId),
  105.                 'ids' => Uuid::fromHexToBytesList(array_column($configuratorSettingPayload, 'id')),
  106.             ],
  107.             ['ids' => Connection::PARAM_STR_ARRAY]
  108.         );
  110.         $this->syncService->sync([
  111.             new SyncOperation(
  112.                 'write',
  113.                 ProductDefinition::ENTITY_NAME,
  114.                 SyncOperation::ACTION_UPSERT,
  115.                 $payload
  116.             ),
  117.             new SyncOperation(
  118.                 'write',
  119.                 ProductConfiguratorSettingDefinition::ENTITY_NAME,
  120.                 SyncOperation::ACTION_UPSERT,
  121.                 $configuratorSettingPayload
  122.             ),
  123.         ], Context::createDefaultContext(), new SyncBehavior());
  124.     }
  126.     public function reset(): void
  127.     {
  128.         $this->groupIdCache = [];
  129.         $this->optionIdCache = [];
  130.     }
  132.     /**
  133.      * convert "size: m, l, xl" to ["size|m", "size|l", "size|xl"]
  134.      *
  135.      * @return list<array<string>>
  136.      */
  137.     private function parseVariantString(string $variantsString): array
  138.     {
  139.         $result = [];
  141.         $groups = explode('|', $variantsString);
  143.         foreach ($groups as $group) {
  144.             $groupOptions = explode(':', $group);
  146.             if (\count($groupOptions) !== 2) {
  147.                 $this->throwExceptionFailedParsingVariants($variantsString);
  148.             }
  150.             $groupName = trim($groupOptions[0]);
  151.             $options = array_filter(array_map('trim', explode(',', $groupOptions[1])));
  153.             if (empty($groupName) || empty($options)) {
  154.                 $this->throwExceptionFailedParsingVariants($variantsString);
  155.             }
  157.             $options = array_map(fn ($option) => sprintf('%s|%s', $groupName, $option), $options);
  159.             $result[] = $options;
  160.         }
  162.         return $result;
  163.     }
  165.     private function throwExceptionFailedParsingVariants(string $variantsString): void
  166.     {
  167.         throw new ProcessingException(sprintf(
  168.             'Failed parsing variants from string "%s", valid format is: "size: L, XL, | color: Green, White"',
  169.             $variantsString
  170.         ));
  171.     }
  173.     /**
  174.      * @param list<array<string>> $variants
  175.      *
  176.      * @return CombinationPayload
  177.      */
  178.     private function getCombinationsPayload(array $variants, string $parentId, string $productNumber): array
  179.     {
  180.         $combinations = $this->getCombinations($variants);
  181.         $payload = [];
  183.         foreach ($combinations as $key => $combination) {
  184.             $options = [];
  186.             if (\is_string($combination)) {
  187.                 $combination = [$combination];
  188.             }
  190.             foreach ($combination as $option) {
  191.                 [$group, $option] = explode('|', $option);
  193.                 $optionId = $this->getOptionId($group, $option);
  194.                 $groupId = $this->getGroupId($group);
  196.                 $options[] = [
  197.                     'id' => $optionId,
  198.                     'name' => $option,
  199.                     'group' => [
  200.                         'id' => $groupId,
  201.                         'name' => $group,
  202.                     ],
  203.                 ];
  204.             }
  206.             $variantId = Uuid::fromStringToHex(sprintf('%s.%s', $parentId, $key));
  207.             $variantProductNumber = sprintf('%s.%s', $productNumber, $key);
  209.             $payload[] = [
  210.                 'id' => $variantId,
  211.                 'parentId' => $parentId,
  212.                 'productNumber' => $variantProductNumber,
  213.                 'stock' => 0,
  214.                 'options' => $options,
  215.             ];
  216.         }
  218.         return $payload;
  219.     }
  221.     /**
  222.      * convert [["size|m", "size|l"], ["color|blue", "color|red"]]
  223.      * to [["size|m", "color|blue"], ["size|l", "color|blue"], ["size|m", "color|red"], ["size|l", "color|red"]]
  224.      *
  225.      * @param list<array<string>> $variants
  226.      *
  227.      * @return list<array<string>>|array<string>
  228.      */
  229.     private function getCombinations(array $variants, int $currentIndex = 0): array
  230.     {
  231.         if (!isset($variants[$currentIndex])) {
  232.             return [];
  233.         }
  235.         if ($currentIndex === \count($variants) - 1) {
  236.             return $variants[$currentIndex];
  237.         }
  239.         // get combinations from subsequent arrays
  240.         $combinations = $this->getCombinations($variants, $currentIndex + 1);
  242.         $result = [];
  244.         // concat each array from tmp with each element from $variants[$i]
  245.         foreach ($variants[$currentIndex] as $variant) {
  246.             foreach ($combinations as $combination) {
  247.                 $result[] = \is_array($combination) ? [...[$variant], ...$combination] : [$variant, $combination];
  248.             }
  249.         }
  251.         return $result;
  252.     }
  254.     /**
  255.      * @param CombinationPayload $variantsPayload
  256.      *
  257.      * @return list<array{id: string, optionId: string, productId: string}>
  258.      */
  259.     private function getProductConfiguratorSettingPayload(array $variantsPayload, string $parentId): array
  260.     {
  261.         $options = array_merge(...array_column($variantsPayload, 'options'));
  262.         $optionIds = array_unique(array_column($options, 'id'));
  264.         $payload = [];
  266.         foreach ($optionIds as $optionId) {
  267.             $payload[] = [
  268.                 'id' => Uuid::fromStringToHex(sprintf('%s_configurator', $optionId)),
  269.                 'optionId' => $optionId,
  270.                 'productId' => $parentId,
  271.             ];
  272.         }
  274.         return $payload;
  275.     }
  277.     private function getGroupId(string $groupName): string
  278.     {
  279.         $groupId = Uuid::fromStringToHex($groupName);
  281.         if (isset($this->groupIdCache[$groupId])) {
  282.             return $this->groupIdCache[$groupId];
  283.         }
  285.         $criteria = new Criteria();
  286.         $criteria->addFilter(new EqualsFilter('name', $groupName));
  288.         $group = $this->groupRepository->search($criteria, Context::createDefaultContext())->first();
  290.         if ($group !== null) {
  291.             $this->groupIdCache[$groupId] = $group->getId();
  293.             return $group->getId();
  294.         }
  296.         $this->groupIdCache[$groupId] = $groupId;
  298.         return $groupId;
  299.     }
  301.     private function getOptionId(string $groupName, string $optionName): string
  302.     {
  303.         $optionId = Uuid::fromStringToHex(sprintf('%s.%s', $groupName, $optionName));
  305.         if (isset($this->optionIdCache[$optionId])) {
  306.             return $this->optionIdCache[$optionId];
  307.         }
  309.         $criteria = new Criteria();
  310.         $criteria->addFilter(new EqualsFilter('name', $optionName));
  311.         $criteria->addFilter(new EqualsFilter('group.name', $groupName));
  313.         $option = $this->optionRepository->search($criteria, Context::createDefaultContext())->first();
  315.         if ($option !== null) {
  316.             $this->optionIdCache[$optionId] = $option->getId();
  318.             return $option->getId();
  319.         }
  321.         $this->optionIdCache[$optionId] = $optionId;
  323.         return $optionId;
  324.     }
  325. }