getOptionIds example

    /** * @return array<int> */
    private function getFilteredValues(Criteria $criteria): array
    {
        $values = [];
        $conditions = $criteria->getConditionsByClass(VariantCondition::class);

        foreach ($conditions as $condition) {
            foreach ($condition->getOptionIds() as $id) {
                $values[] = $id;
            }
        }

        return $values;
    }
}

$productPriceEntities = array_merge(...$rules);

        return new ProductPriceCollection($productPriceEntities);
    }

    /** * @param list<string> $optionIds */
    public function filterByOptionIds(array $optionIds): self
    {
        return $this->filter(function DProductEntity $product) use ($optionIds) {
            $ids = $product->getOptionIds() ?? [];
            $same = array_intersect($ids, $optionIds);

            return \count($same) === \count($optionIds);
        });
    }

    public function getCovers(): ProductMediaCollection
    {
        return new ProductMediaCollection($this->fmap(fn (ProductEntity $product) => $product->getCover()));
    }

    

$query->setParameter('variantGroupIds', $facet->getGroupIds(), Connection::PARAM_INT_ARRAY);
    }

    /** * @return array<int> */
    private function getFilteredValues(Criteria $criteria): array
    {
        $values = [];
        foreach ($criteria->getConditions() as $condition) {
            if ($condition instanceof VariantCondition) {
                foreach ($condition->getOptionIds() as $id) {
                    $values[] = $id;
                }
            }
        }

        return $values;
    }

    /** * @param Group[] $groups * @param int[] $actives */

'createdAt' => $product->getCreatedAt() ? $product->getCreatedAt()->format(Defaults::STORAGE_DATE_TIME_FORMAT) : null,
            'releaseDate' => $product->getReleaseDate() ? $product->getReleaseDate()->format(Defaults::STORAGE_DATE_TIME_FORMAT) : null,
            'isNew' => $product->isNew(),
            'markAsTopseller' => $product->getMarkAsTopseller(),
            'purchasePrices' => $purchasePrices ? json_encode($purchasePrices, \JSON_THROW_ON_ERROR) : null,
            'productNumber' => $product->getProductNumber(),
            'manufacturerId' => $product->getManufacturerId(),
            'taxId' => $product->getTaxId(),
            'tagIds' => $product->getTagIds(),
            'categoryIds' => $product->getCategoryTree(),
            'propertyIds' => $product->getPropertyIds(),
            'optionIds' => $product->getOptionIds(),
            'options' => $product->getVariation(),
            'streamIds' => $product->getStreamIds(),
            'parentId' => $product->getParentId(),
            'stock' => $product->getStock(),
        ];

        $lineItem->replacePayload($payload, ['purchasePrices' => true]);
    }

    private function getPriceDefinition(SalesChannelProductEntity $product, SalesChannelContext $context, int $quantity): QuantityPriceDefinition
    {
        

QueryBuilder $cheapestPriceQuery,
        VariantCondition $condition
    ) {
        $tableKey = $condition->getName();

        $suffix = md5(json_encode($condition, JSON_THROW_ON_ERROR));

        $where = [];

        $tableKeys = [];
        $joinCondition = '';
        foreach ($condition->getOptionIds() as $valueId) {
            $valueKey = ':' . $tableKey . '_' . $valueId . '_' . $suffix;
            $where[] = $tableKey . '.option_id = ' . $valueKey;

            /* * Set the parameter of the options to the main query */
            $mainQuery->setParameter($valueKey, $valueId);

            if (\array_key_exists($tableKey, $tableKeys)) {
                continue;
            }

            

$suffix = md5(json_encode($condition, JSON_THROW_ON_ERROR));

        if ($query->hasState('option_' . $tableKey)) {
            return;
        }

        $query->addState('option_' . $tableKey);

        $where = [];

        foreach ($condition->getOptionIds() as $valueId) {
            $valueKey = ':' . $tableKey . '_' . $valueId . '_' . $suffix;
            $where[] = $tableKey . '.option_id = ' . $valueKey;
            $query->setParameter($valueKey, $valueId);
        }

        $where = implode(' OR ', $where);

        $query->innerJoin(
            'variant',
            's_article_configurator_option_relations',
            $tableKey,
            

$this->optionIds = array_map('intval', $optionIds);
        sort($this->optionIds, SORT_NUMERIC);
        $this->expandVariants = $expandVariants;
        $this->groupId = (int) $groupId;
    }

    /** * {@inheritdoc} */
    public function getName()
    {
        return 'options_' . implode('_', $this->getOptionIds());
    }

    /** * @return int[] */
    public function getOptionIds()
    {
        return $this->optionIds;
    }

    public function expandVariants()
    {

$this->eventDispatcher->dispatch(
            new ProductPageLoadedEvent($page, $context, $request)
        );

        return $page;
    }

    private function loadOptions(ProductPage $page): void
    {
        $options = new PropertyGroupOptionCollection();

        if (($optionIds = $page->getProduct()->getOptionIds()) === null) {
            $page->setSelectedOptions($options);

            return;
        }

        foreach ($page->getConfiguratorSettings() as $group) {
            $groupOptions = $group->getOptions();
            if ($groupOptions === null) {
                continue;
            }
            foreach ($optionIds as $optionId) {
                

private function handle(VariantCondition $criteriaPart, Criteria $criteria, Search $search): void
    {
        $groupBy = $this->buildGroupBy($criteria);

        if ($groupBy) {
            $search->addPostFilter(new TermQuery($groupBy, true));

            $search->addPostFilter(
                new TermsQuery(
                    'filterConfiguration.options.id',
                    $criteriaPart->getOptionIds()
                )
            );

            return;
        }

        $search->addPostFilter(new TermQuery('isMainVariant', true));

        $search->addPostFilter(
            new TermsQuery(
                'filterConfiguration.options.id',
                

        $this->createProduct([], true);

        $listing = $this->fetchListing();

        static::assertEquals(1, $listing->getTotal());

        $mainVariant = $listing->getEntities()->first();
        static::assertNotNull($mainVariant);

        static::assertEquals($this->mainVariantId, $mainVariant->getId());
        static::assertContains($this->optionIds['red'], $mainVariant->getOptionIds() ?: []);
        static::assertContains($this->optionIds['l'], $mainVariant->getOptionIds() ?: []);
        static::assertTrue($mainVariant->hasExtension('search'));

        static::assertTrue($listing->getCriteria()->hasState(Criteria::STATE_ELASTICSEARCH_AWARE));
    }

    public function testMainVariantInactive(): void
    {
        $this->createProduct([], true);

        // update main variant to be inactive

return null;
    }

    /** * @return array<int|string, string> */
    private function buildCurrentOptions(SalesChannelProductEntity $product, PropertyGroupCollection $groups): array
    {
        $keyMap = $groups->getOptionIdMap();

        $optionIds = $product->getOptionIds() ?? [];
        $current = [];

        if ($product->getOptionIds() === null) {
            return $current;
        }

        foreach ($optionIds as $optionId) {
            $groupId = $keyMap[$optionId] ?? null;
            if ($groupId === null) {
                continue;
            }