custom/plugins/SasVariantSwitch/src/Storefront/Page/ProductListingConfigurationLoader.php line 49

  1. <?php declare(strict_types=1);
  3. namespace SasVariantSwitch\Storefront\Page;
  5. use Doctrine\DBAL\Connection;
  6. use Shopware\Core\Content\Product\Aggregate\ProductConfiguratorSetting\ProductConfiguratorSettingEntity;
  7. use Shopware\Core\Content\Product\ProductCollection;
  8. use Shopware\Core\Content\Product\SalesChannel\Detail\AvailableCombinationResult;
  9. use Shopware\Core\Content\Product\SalesChannel\Detail\ProductConfiguratorLoader;
  10. use Shopware\Core\Content\Product\SalesChannel\SalesChannelProductEntity;
  11. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionCollection;
  12. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionEntity;
  13. use Shopware\Core\Content\Property\PropertyGroupCollection;
  14. use Shopware\Core\Content\Property\PropertyGroupDefinition;
  15. use Shopware\Core\Content\Property\PropertyGroupEntity;
  16. use Shopware\Core\Framework\Context;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Doctrine\FetchModeHelper;
  18. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  19. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  20. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsAnyFilter;
  21. use Shopware\Core\Framework\Uuid\Uuid;
  22. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  24. class ProductListingConfigurationLoader
  25. {
  26.     private EntityRepositoryInterface $configuratorRepository;
  27.     private Connection $connection;
  29.     public function __construct(
  30.         EntityRepositoryInterface $configuratorRepository,
  31.         Connection $connection
  32.     ) {
  33.         $this->configuratorRepository = $configuratorRepository;
  34.         $this->connection = $connection;
  35.     }
  37.     public function loadListing(ProductCollection $products, SalesChannelContext $context): void
  38.     {
  39.         $productSettings = $this->loadSettings($products, $context);
  41.         if (empty($productSettings)) {
  42.             return;
  43.         }
  45.         $productIds = array_filter($products->map(function (SalesChannelProductEntity $product) {
  46.             return $product->getParentId() ?? $product->getId();
  47.         }));
  49.         $allCombinations = $this->loadCombinations($productIds, $context->getContext());
  51.         /** @var SalesChannelProductEntity $product */
  52.         foreach ($products as $product) {
  53.             if ($product->getConfiguratorSettings() !== null || !$product->getParentId() || empty($productSettings[$product->getParentId()])) {
  54.                 $product->addExtension('groups', new PropertyGroupCollection());
  56.                 continue;
  57.             }
  59.             $groups = $this->sortSettings($productSettings[$product->getParentId()], $product);
  61.             $combinations = $allCombinations[$product->getParentId()];
  63.             $current = $this->buildCurrentOptions($product, $groups);
  65.             foreach ($groups as $group) {
  66.                 $options = $group->getOptions();
  67.                 if ($options === null) {
  68.                     continue;
  69.                 }
  71.                 foreach ($options as $option) {
  72.                     $combinable = $this->isCombinable($option, $current, $combinations);
  73.                     if ($combinable === null) {
  74.                         $options->remove($option->getId());
  76.                         continue;
  77.                     }
  78.                     $option->setGroup(null);
  80.                     $option->setCombinable($combinable);
  81.                 }
  83.                 $group->setOptions($options);
  84.             }
  86.             $product->addExtension('groups', $groups);
  87.         }
  88.     }
  90.     public function loadCombinations(array $productIds, Context $context): array
  91.     {
  92.         $allCombinations = [];
  94.         $query = $this->connection->createQueryBuilder();
  95.         $query->from('product');
  96.         $query->leftJoin('product', 'product', 'parent', 'product.parent_id = parent.id');
  98.         $query->andWhere('product.parent_id IN (:id)');
  99.         $query->andWhere('product.version_id = :versionId');
  100.         $query->andWhere('IFNULL(product.active, parent.active) = :active');
  101.         $query->andWhere('product.option_ids IS NOT NULL');
  103.         $query->setParameter('id', Uuid::fromHexToBytesList($productIds), Connection::PARAM_STR_ARRAY);
  104.         $query->setParameter('versionId', Uuid::fromHexToBytes($context->getVersionId()));
  105.         $query->setParameter('active', true);
  107.         $query->select([
  108.             'LOWER(HEX(product.id))',
  109.             'LOWER(HEX(product.parent_id)) as parent_id',
  110.             'product.option_ids as options',
  111.             'product.product_number as productNumber',
  112.             'product.available',
  113.         ]);
  115.         $combinations = $query->execute()->fetchAll();
  116.         $combinations = FetchModeHelper::groupUnique($combinations);
  118.         foreach ($combinations as $combination) {
  119.             $parentId = $combination['parent_id'];
  121.             if (\array_key_exists($parentId, $allCombinations)) {
  122.                 $allCombinations[$parentId][] = $combination;
  123.             } else {
  124.                 $allCombinations[$parentId] = [$combination];
  125.             }
  126.         }
  128.         foreach ($allCombinations as $parentId => $groupedCombinations) {
  129.             $available = [];
  131.             foreach ($groupedCombinations as $combination) {
  132.                 $combination['options'] = json_decode($combination['options'], true);
  134.                 $available[] = $combination;
  135.             }
  137.             $result = new AvailableCombinationResult();
  139.             foreach ($available as $combination) {
  140.                 $result->addCombination($combination['options']);
  141.             }
  143.             $allCombinations[$parentId] = $result;
  144.         }
  146.         return $allCombinations;
  147.     }
  149.     private function loadSettings(ProductCollection $products, SalesChannelContext $context): ?array
  150.     {
  151.         $allSettings = [];
  152.         $criteria = (new Criteria())->addFilter(
  153.             new EqualsAnyFilter('productId', $products->map(function (SalesChannelProductEntity $product) {
  154.                       return $product->getParentId() ?? $product->getId();
  155.             }))
  156.         );
  158.         $criteria->addAssociation('option.group')
  159.             ->addAssociation('option.media')
  160.             ->addAssociation('media');
  162.         $settings = $this->configuratorRepository
  163.             ->search($criteria, $context->getContext())
  164.             ->getEntities();
  166.         if ($settings->count() <= 0) {
  167.             return null;
  168.         }
  170.         /** @var ProductConfiguratorSettingEntity $setting */
  171.         foreach ($settings as $setting) {
  172.             $productId = $setting->getProductId();
  174.             if (\array_key_exists($productId, $allSettings)) {
  175.                 $allSettings[$productId][] = clone $setting;
  176.             } else {
  177.                 $allSettings[$productId] = [clone $setting];
  178.             }
  179.         }
  181.         /** @var ProductConfiguratorSettingEntity $setting */
  182.         foreach ($allSettings as $productId => $settings) {
  183.             $groups = [];
  185.             /** @var ProductConfiguratorSettingEntity $setting */
  186.             foreach ($settings as $setting) {
  187.                 $option = $setting->getOption();
  188.                 if ($option === null) {
  189.                     continue;
  190.                 }
  192.                 $group = $option->getGroup();
  193.                 if ($group === null) {
  194.                     continue;
  195.                 }
  197.                 $groupId = $group->getId();
  199.                 // if (!in_array($groupId, $groupIds)) {
  200.                 //    continue;
  201.                 // }
  203.                 if (isset($groups[$groupId])) {
  204.                     $group = $groups[$groupId];
  205.                 }
  207.                 $groups[$groupId] = $group;
  209.                 if ($group->getOptions() === null) {
  210.                     $group->setOptions(new PropertyGroupOptionCollection());
  211.                 }
  213.                 $group->getOptions()->add($option);
  215.                 $option->setConfiguratorSetting($setting);
  216.             }
  218.             $allSettings[$productId] = $groups;
  219.         }
  221.         return $allSettings;
  222.     }
  224.     private function sortSettings(?array $groups, SalesChannelProductEntity $product): PropertyGroupCollection
  225.     {
  226.         if (!$groups) {
  227.             return new PropertyGroupCollection();
  228.         }
  230.         $sorted = [];
  231.         foreach ($groups as $group) {
  232.             if (!$group) {
  233.                 continue;
  234.             }
  236.             if (!$group->getOptions()) {
  237.                 $group->setOptions(new PropertyGroupOptionCollection());
  238.             }
  240.             $sorted[$group->getId()] = $group;
  241.         }
  243.         /** @var PropertyGroupEntity $group */
  244.         foreach ($sorted as $group) {
  245.             $group->getOptions()->sort(
  246.                 static function (PropertyGroupOptionEntity $a, PropertyGroupOptionEntity $b) use ($group) {
  247.                     if ($a->getConfiguratorSetting()->getPosition() !== $b->getConfiguratorSetting()->getPosition()) {
  248.                         return $a->getConfiguratorSetting()->getPosition() <=> $b->getConfiguratorSetting()->getPosition();
  249.                     }
  251.                     if ($group->getSortingType() === PropertyGroupDefinition::SORTING_TYPE_ALPHANUMERIC) {
  252.                         return strnatcmp($a->getTranslation('name'), $b->getTranslation('name'));
  253.                     }
  255.                     return ($a->getTranslation('position') ?? $a->getPosition() ?? 0) <=> ($b->getTranslation('position') ?? $b->getPosition() ?? 0);
  256.                 }
  257.             );
  258.         }
  260.         $collection = new PropertyGroupCollection($sorted);
  262.         // check if product has an individual sorting configuration for property groups
  263.         $config = $product->getConfiguratorGroupConfig();
  264.         if (!$config) {
  265.             $collection->sortByPositions();
  267.             return $collection;
  268.         }
  270.         $sortedGroupIds = array_column($config, 'id');
  272.         // ensure all ids are in the array (but only once)
  273.         $sortedGroupIds = array_unique(array_merge($sortedGroupIds, $collection->getIds()));
  275.         $collection->sortByIdArray($sortedGroupIds);
  277.         return $collection;
  278.     }
  280.     private function isCombinable(
  281.         PropertyGroupOptionEntity $option,
  282.         array $current,
  283.         AvailableCombinationResult $combinations
  284.     ): ?bool {
  285.         unset($current[$option->getGroupId()]);
  286.         $current[] = $option->getId();
  288.         // available with all other current selected options
  289.         if ($combinations->hasCombination($current)) {
  290.             return true;
  291.         }
  293.         // available but not with the other current selected options
  294.         if ($combinations->hasOptionId($option->getId())) {
  295.             return false;
  296.         }
  298.         return null;
  299.     }
  301.     private function buildCurrentOptions(SalesChannelProductEntity $product, PropertyGroupCollection $groups): array
  302.     {
  303.         $keyMap = $groups->getOptionIdMap();
  305.         $current = [];
  306.         foreach ($product->getOptionIds() as $optionId) {
  307.             $groupId = $keyMap[$optionId] ?? null;
  308.             if ($groupId === null) {
  309.                 continue;
  310.             }
  312.             $current[$groupId] = $optionId;
  313.         }
  315.         return $current;
  316.     }
  317. }