vendor/shopware/core/Content/Product/SalesChannel/Detail/ProductConfiguratorLoader.php line 42

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\Product\SalesChannel\Detail;
  5. use Shopware\Core\Content\Product\Aggregate\ProductConfiguratorSetting\ProductConfiguratorSettingEntity;
  6. use Shopware\Core\Content\Product\SalesChannel\SalesChannelProductEntity;
  7. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionCollection;
  8. use Shopware\Core\Content\Property\Aggregate\PropertyGroupOption\PropertyGroupOptionEntity;
  9. use Shopware\Core\Content\Property\PropertyGroupCollection;
  10. use Shopware\Core\Content\Property\PropertyGroupDefinition;
  11. use Shopware\Core\Content\Property\PropertyGroupEntity;
  12. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  13. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InconsistentCriteriaIdsException;
  14. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  15. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  16. use Shopware\Core\Framework\Log\Package;
  17. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  19. #[Package('inventory')]
  20. class ProductConfiguratorLoader
  21. {
  22.     /**
  23.      * @internal
  24.      */
  25.     public function __construct(
  26.         private readonly EntityRepository $configuratorRepository,
  27.         private readonly AbstractAvailableCombinationLoader $combinationLoader
  28.     ) {
  29.     }
  31.     /**
  32.      * @throws InconsistentCriteriaIdsException
  33.      */
  34.     public function load(
  35.         SalesChannelProductEntity $product,
  36.         SalesChannelContext $context
  37.     ): PropertyGroupCollection {
  38.         if (!$product->getParentId()) {
  39.             return new PropertyGroupCollection();
  40.         }
  42.         $groups = $this->loadSettings($product, $context);
  44.         $groups = $this->sortSettings($groups, $product);
  46.         $combinations = $this->combinationLoader->load(
  47.             $product->getParentId(),
  48.             $context->getContext(),
  49.             $context->getSalesChannelId()
  50.         );
  52.         $current = $this->buildCurrentOptions($product, $groups);
  54.         foreach ($groups as $group) {
  55.             $options = $group->getOptions();
  56.             if ($options === null) {
  57.                 continue;
  58.             }
  60.             foreach ($options as $option) {
  61.                 $combinable = $this->isCombinable($option, $current, $combinations);
  62.                 if ($combinable === null) {
  63.                     $options->remove($option->getId());
  65.                     continue;
  66.                 }
  67.                 $option->setGroup(null);
  69.                 $option->setCombinable($combinable);
  70.             }
  71.         }
  73.         return $groups;
  74.     }
  76.     /**
  77.      * @throws InconsistentCriteriaIdsException
  78.      *
  79.      * @return array<string, PropertyGroupEntity>|null
  80.      */
  81.     private function loadSettings(SalesChannelProductEntity $product, SalesChannelContext $context): ?array
  82.     {
  83.         $criteria = (new Criteria())->addFilter(
  84.             new EqualsFilter('productId', $product->getParentId() ?? $product->getId())
  85.         );
  87.         $criteria->addAssociation('option.group')
  88.             ->addAssociation('option.media')
  89.             ->addAssociation('media');
  91.         $settings = $this->configuratorRepository
  92.             ->search($criteria, $context->getContext())
  93.             ->getEntities();
  95.         if ($settings->count() <= 0) {
  96.             return null;
  97.         }
  98.         $groups = [];
  100.         /** @var ProductConfiguratorSettingEntity $setting */
  101.         foreach ($settings as $setting) {
  102.             $option = $setting->getOption();
  103.             if ($option === null) {
  104.                 continue;
  105.             }
  107.             $group = $option->getGroup();
  108.             if ($group === null) {
  109.                 continue;
  110.             }
  112.             $groupId = $group->getId();
  114.             if (isset($groups[$groupId])) {
  115.                 $group = $groups[$groupId];
  116.             }
  118.             $groups[$groupId] = $group;
  120.             $options = $group->getOptions();
  121.             if ($options === null) {
  122.                 $options = new PropertyGroupOptionCollection();
  123.                 $group->setOptions($options);
  124.             }
  125.             $options->add($option);
  127.             $options->add($option);
  129.             $option->setConfiguratorSetting($setting);
  130.         }
  132.         return $groups;
  133.     }
  135.     /**
  136.      * @param array<string, PropertyGroupEntity>|null $groups
  137.      */
  138.     private function sortSettings(?array $groups, SalesChannelProductEntity $product): PropertyGroupCollection
  139.     {
  140.         if (!$groups) {
  141.             return new PropertyGroupCollection();
  142.         }
  144.         $sorted = [];
  145.         foreach ($groups as $group) {
  146.             if (!$group) {
  147.                 continue;
  148.             }
  150.             if (!$group->getOptions()) {
  151.                 $group->setOptions(new PropertyGroupOptionCollection());
  152.             }
  154.             $sorted[$group->getId()] = $group;
  155.         }
  157.         /** @var PropertyGroupEntity $group */
  158.         foreach ($sorted as $group) {
  159.             $options = $group->getOptions();
  160.             if ($options === null) {
  161.                 continue;
  162.             }
  163.             $options->sort(
  164.                 static function (PropertyGroupOptionEntity $a, PropertyGroupOptionEntity $b) use ($group) {
  165.                     $configuratorSettingA = $a->getConfiguratorSetting();
  166.                     $configuratorSettingB = $b->getConfiguratorSetting();
  168.                     if ($configuratorSettingA !== null && $configuratorSettingB !== null
  169.                         && $configuratorSettingA->getPosition() !== $configuratorSettingB->getPosition()) {
  170.                         return $configuratorSettingA->getPosition() <=> $configuratorSettingB->getPosition();
  171.                     }
  173.                     if ($group->getSortingType() === PropertyGroupDefinition::SORTING_TYPE_ALPHANUMERIC) {
  174.                         return strnatcmp((string) $a->getTranslation('name'), (string) $b->getTranslation('name'));
  175.                     }
  177.                     return ($a->getTranslation('position') ?? $a->getPosition() ?? 0) <=> ($b->getTranslation('position') ?? $b->getPosition() ?? 0);
  178.                 }
  179.             );
  180.         }
  182.         $collection = new PropertyGroupCollection($sorted);
  184.         // check if product has an individual sorting configuration for property groups\
  185.         $config = $product->getVariantListingConfig();
  186.         if ($config) {
  187.             $config = $config->getConfiguratorGroupConfig();
  188.         }
  190.         if (!$config) {
  191.             $collection->sortByPositions();
  193.             return $collection;
  194.         }
  196.         $sortedGroupIds = array_column($config, 'id');
  198.         // ensure all ids are in the array (but only once)
  199.         $sortedGroupIds = array_unique(array_merge($sortedGroupIds, $collection->getIds()));
  201.         $collection->sortByIdArray($sortedGroupIds);
  203.         return $collection;
  204.     }
  206.     /**
  207.      * @param array<string> $current
  208.      */
  209.     private function isCombinable(
  210.         PropertyGroupOptionEntity $option,
  211.         array $current,
  212.         AvailableCombinationResult $combinations
  213.     ): ?bool {
  214.         unset($current[$option->getGroupId()]);
  215.         $current[] = $option->getId();
  217.         // available with all other current selected options
  218.         if ($combinations->hasCombination($current) && $combinations->isAvailable($current)) {
  219.             return true;
  220.         }
  222.         // available but not with the other current selected options
  223.         if ($combinations->hasOptionId($option->getId())) {
  224.             return false;
  225.         }
  227.         return null;
  228.     }
  230.     /**
  231.      * @return array<int|string, string>
  232.      */
  233.     private function buildCurrentOptions(SalesChannelProductEntity $product, PropertyGroupCollection $groups): array
  234.     {
  235.         $keyMap = $groups->getOptionIdMap();
  237.         $optionIds = $product->getOptionIds() ?? [];
  238.         $current = [];
  240.         if ($product->getOptionIds() === null) {
  241.             return $current;
  242.         }
  244.         foreach ($optionIds as $optionId) {
  245.             $groupId = $keyMap[$optionId] ?? null;
  246.             if ($groupId === null) {
  247.                 continue;
  248.             }
  250.             $current[$groupId] = $optionId;
  251.         }
  253.         return $current;
  254.     }
  255. }