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

  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(private readonly EntityRepository $configuratorRepository, private readonly AbstractAvailableCombinationLoader $combinationLoader)
  26.     {
  27.     }
  29.     /**
  30.      * @throws InconsistentCriteriaIdsException
  31.      */
  32.     public function load(
  33.         SalesChannelProductEntity $product,
  34.         SalesChannelContext $context
  35.     ): PropertyGroupCollection {
  36.         if (!$product->getParentId()) {
  37.             return new PropertyGroupCollection();
  38.         }
  40.         $groups = $this->loadSettings($product, $context);
  42.         $groups = $this->sortSettings($groups, $product);
  44.         $combinations = $this->combinationLoader->load(
  45.             $product->getParentId(),
  46.             $context->getContext(),
  47.             $context->getSalesChannelId()
  48.         );
  50.         $current = $this->buildCurrentOptions($product, $groups);
  52.         foreach ($groups as $group) {
  53.             $options = $group->getOptions();
  54.             if ($options === null) {
  55.                 continue;
  56.             }
  58.             foreach ($options as $option) {
  59.                 $combinable = $this->isCombinable($option, $current, $combinations);
  60.                 if ($combinable === null) {
  61.                     $options->remove($option->getId());
  63.                     continue;
  64.                 }
  65.                 $option->setGroup(null);
  67.                 $option->setCombinable($combinable);
  68.             }
  69.         }
  71.         return $groups;
  72.     }
  74.     /**
  75.      * @throws InconsistentCriteriaIdsException
  76.      *
  77.      * @return array<string, PropertyGroupEntity>|null
  78.      */
  79.     private function loadSettings(SalesChannelProductEntity $product, SalesChannelContext $context): ?array
  80.     {
  81.         $criteria = (new Criteria())->addFilter(
  82.             new EqualsFilter('productId', $product->getParentId() ?? $product->getId())
  83.         );
  85.         $criteria->addAssociation('option.group')
  86.             ->addAssociation('option.media')
  87.             ->addAssociation('media');
  89.         $settings = $this->configuratorRepository
  90.             ->search($criteria, $context->getContext())
  91.             ->getEntities();
  93.         if ($settings->count() <= 0) {
  94.             return null;
  95.         }
  96.         $groups = [];
  98.         /** @var ProductConfiguratorSettingEntity $setting */
  99.         foreach ($settings as $setting) {
  100.             $option = $setting->getOption();
  101.             if ($option === null) {
  102.                 continue;
  103.             }
  105.             $group = $option->getGroup();
  106.             if ($group === null) {
  107.                 continue;
  108.             }
  110.             $groupId = $group->getId();
  112.             if (isset($groups[$groupId])) {
  113.                 $group = $groups[$groupId];
  114.             }
  116.             $groups[$groupId] = $group;
  118.             $options = $group->getOptions();
  119.             if ($options === null) {
  120.                 $options = new PropertyGroupOptionCollection();
  121.                 $group->setOptions($options);
  122.             }
  123.             $options->add($option);
  125.             $options->add($option);
  127.             $option->setConfiguratorSetting($setting);
  128.         }
  130.         return $groups;
  131.     }
  133.     /**
  134.      * @param array<string, PropertyGroupEntity>|null $groups
  135.      */
  136.     private function sortSettings(?array $groups, SalesChannelProductEntity $product): PropertyGroupCollection
  137.     {
  138.         if (!$groups) {
  139.             return new PropertyGroupCollection();
  140.         }
  142.         $sorted = [];
  143.         foreach ($groups as $group) {
  144.             if (!$group) {
  145.                 continue;
  146.             }
  148.             if (!$group->getOptions()) {
  149.                 $group->setOptions(new PropertyGroupOptionCollection());
  150.             }
  152.             $sorted[$group->getId()] = $group;
  153.         }
  155.         /** @var PropertyGroupEntity $group */
  156.         foreach ($sorted as $group) {
  157.             $options = $group->getOptions();
  158.             if ($options === null) {
  159.                 continue;
  160.             }
  161.             $options->sort(
  162.                 static function (PropertyGroupOptionEntity $a, PropertyGroupOptionEntity $b) use ($group) {
  163.                     $configuratorSettingA = $a->getConfiguratorSetting();
  164.                     $configuratorSettingB = $b->getConfiguratorSetting();
  166.                     if ($configuratorSettingA !== null && $configuratorSettingB !== null
  167.                         && $configuratorSettingA->getPosition() !== $configuratorSettingB->getPosition()) {
  168.                         return $configuratorSettingA->getPosition() <=> $configuratorSettingB->getPosition();
  169.                     }
  171.                     if ($group->getSortingType() === PropertyGroupDefinition::SORTING_TYPE_ALPHANUMERIC) {
  172.                         return strnatcmp((string) $a->getTranslation('name'), (string) $b->getTranslation('name'));
  173.                     }
  175.                     return ($a->getTranslation('position') ?? $a->getPosition() ?? 0) <=> ($b->getTranslation('position') ?? $b->getPosition() ?? 0);
  176.                 }
  177.             );
  178.         }
  180.         $collection = new PropertyGroupCollection($sorted);
  182.         // check if product has an individual sorting configuration for property groups\
  183.         $config = $product->getVariantListingConfig();
  184.         if ($config) {
  185.             $config = $config->getConfiguratorGroupConfig();
  186.         }
  188.         if (!$config) {
  189.             $collection->sortByPositions();
  191.             return $collection;
  192.         }
  194.         $sortedGroupIds = array_column($config, 'id');
  196.         // ensure all ids are in the array (but only once)
  197.         $sortedGroupIds = array_unique(array_merge($sortedGroupIds, $collection->getIds()));
  199.         $collection->sortByIdArray($sortedGroupIds);
  201.         return $collection;
  202.     }
  204.     /**
  205.      * @param array<string> $current
  206.      */
  207.     private function isCombinable(
  208.         PropertyGroupOptionEntity $option,
  209.         array $current,
  210.         AvailableCombinationResult $combinations
  211.     ): ?bool {
  212.         unset($current[$option->getGroupId()]);
  213.         $current[] = $option->getId();
  215.         // available with all other current selected options
  216.         if ($combinations->hasCombination($current) && $combinations->isAvailable($current)) {
  217.             return true;
  218.         }
  220.         // available but not with the other current selected options
  221.         if ($combinations->hasOptionId($option->getId())) {
  222.             return false;
  223.         }
  225.         return null;
  226.     }
  228.     /**
  229.      * @return array<int|string, string>
  230.      */
  231.     private function buildCurrentOptions(SalesChannelProductEntity $product, PropertyGroupCollection $groups): array
  232.     {
  233.         $keyMap = $groups->getOptionIdMap();
  235.         $optionIds = $product->getOptionIds() ?? [];
  236.         $current = [];
  238.         if ($product->getOptionIds() === null) {
  239.             return $current;
  240.         }
  242.         foreach ($optionIds as $optionId) {
  243.             $groupId = $keyMap[$optionId] ?? null;
  244.             if ($groupId === null) {
  245.                 continue;
  246.             }
  248.             $current[$groupId] = $optionId;
  249.         }
  251.         return $current;
  252.     }
  253. }