getConditions example

if ($comparableCriteria == $existingCriteria) {
                return $index;
            }
        }

        return false;
    }

    private function getComparableCriteria(Criteria $criteria): Criteria
    {
        $conditions = $criteria->getConditions();
        $sortings = $criteria->getSortings();

        usort($conditions, function DConditionInterface $a, ConditionInterface $b) {
            return strnatcmp($a->getName(), $b->getName());
        });

        usort($sortings, function DSortingInterface $a, SortingInterface $b) {
            return strnatcmp($a->getName(), $b->getName());
        });

        $criteria = new Criteria();

        

    private function getFacet(
        CombinedConditionFacet $facet,
        Criteria $reverted,
        Criteria $criteria,
        ShopContextInterface $context
    ): ?BooleanFacetResult {
        $own = clone $reverted;

        if (!$criteria->hasCondition($facet->getName())) {
            foreach ($facet->getConditions() as $condition) {
                $own->addCondition($condition);
            }
        }

        $query = $this->queryBuilderFactory->createQuery($own, $context);
        $query->select('1');
        $query->setMaxResults(1);

        $hasFacet = $query->execute()->fetch(PDO::FETCH_COLUMN);
        if (!$hasFacet) {
            return null;
        }

$query->addGroupBy('variantOptions.option_id');
        $query->select('variantOptions.option_id as id');
        $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 */

foreach ($definitions as $plugin_id => $definition) {
      // Remove definition when plugin has conditions and they are not met.       if ($definition->hasConditions()) {
        $plugin = $this->getPlugin($plugin_id, $editor);
        if ($this->isPluginDisabled($plugin, $editor)) {
          unset($definitions[$plugin_id]);
        }
        else {
          // The `plugins` condition can only be evaluated at the end of           // gathering enabled definitions. ::isPluginDisabled() did not yet           // evaluate that condition.           if (array_key_exists('plugins', $definition->getConditions())) {
            $definitions_with_plugins_condition[$plugin_id] = $definition;
          }
        }
      }
      // Otherwise, only remove the definition if the plugin has buttons and       // none of its buttons are active.       elseif ($definition->hasToolbarItems()) {
        if (empty(array_intersect($editor->getSettings()['toolbar']['items'], array_keys($definition->getToolbarItems())))) {
          unset($definitions[$plugin_id]);
        }
      }
    }

ShopContextInterface $context
    ) {
        $search->addPostFilter($this->getQuery($criteriaPart, $criteria, $context));
    }

    private function getQuery(
        CombinedCondition $criteriaPart,
        Criteria $criteria,
        ShopContextInterface $context
    ): BoolQuery {
        return $this->combinedConditionQueryBuilder->build(
            $criteriaPart->getConditions(),
            $criteria,
            $context
        );
    }
}

private function handleCombinedConditionFacet(
        Request $request,
        Criteria $criteria,
        CombinedConditionFacet $facet
    ) {
        if (!$request->has($facet->getRequestParameter())) {
            return;
        }
        $criteria->addCondition(
            new CombinedCondition(
                $facet->getConditions()
            )
        );
    }

    /** * @return bool */
    private function isAttributeInRequest(ProductAttributeFacet $facet, Request $request)
    {
        $params = $request->getParams();

        

    public function getOne($id, $offset = 0, $limit = 50, $conditions = '', $sortings = '')
    {
        $this->checkPrivilege('read');

        $criteria = new Criteria();

        $parsedConditions = $this->getConditions($id, $conditions);

        foreach ($parsedConditions as $condition) {
            $criteria->addCondition($condition);
        }
        $decodedSortings = json_decode($sortings, true);
        if (!empty($decodedSortings)) {
            $unserializedSortings = $this->reflectionHelper->unserialize($decodedSortings, '');

            foreach ($unserializedSortings as $sorting) {
                if (!$sorting instanceof SortingInterface) {
                    continue;
                }

    public function getListing(ListingRequest $context)
    {
        $params = [
            'locale' => $context->getLocale(),
            'shopwareVersion' => $context->getShopwareVersion(),
            'offset' => $context->getOffset(),
            'limit' => $context->getLimit(),
            'sort' => json_encode($context->getSortings()),
            'filter' => json_encode($context->getConditions()),
        ];

        $data = $this->storeClient->doGetRequest(
            '/pluginStore/plugins',
            $params
        );

        $plugins = $this->hydrator->hydrateStorePlugins($data['data']);

        return new ListingResultStruct(
            $plugins,
            

/** * @return QueryBuilder */
    private function buildQuery(Criteria $criteria)
    {
        $query = new QueryBuilder($this->connection);

        $query->from('s_customer_search_index', 'customer');
        $query->leftJoin('customer', 's_user_attributes', 'customerAttribute', 'customerAttribute.userID = customer.id');

        foreach ($criteria->getConditions() as $condition) {
            $handler = $this->handlerRegistry->getConditionHandler($condition);
            $handler->handle($condition, $query);
        }

        return $query;
    }

    /** * @return array[] */
    private function fetchCustomers(Criteria $criteria, QueryBuilder $query)
    {

$query->addSelect('product.filtergroupID as filterGroupId');
        $query->orderBy('propertySet.position');
    }

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

        return $values;
    }

    /** * @param array<Set> $sets * @param array<int> $actives */

'count' => 6,
                        ],
                    ],
                ],
            ],
        ], $this->context);

        $criteria = new Criteria([$ruleId]);
        $criteria->addAssociation('conditions');

        $rule = $this->ruleRepository->search($criteria, $this->context)->getEntities()->get($ruleId);
        static::assertEquals(1, $rule->getConditions()->count());
        static::assertNotNull($rule->getConditions()->get($conditionId));
    }

    public function testItThrowsIfTypeIsMissing(): void
    {
        $ruleData = [
            [
                'name' => 'super rule',
                'priority' => 15,
                'conditions' => [
                    [
                        

 {
        $query->addState($condition->getName());

        $this->addConditions($condition, $query, $context);
    }

    private function addConditions(
        CombinedCondition $condition,
        QueryBuilder $query,
        ShopContextInterface $context
    ): void {
        foreach ($condition->getConditions() as $innerCondition) {
            $handler = $this->getConditionHandler($innerCondition);
            $handler->generateCondition($innerCondition, $query, $context);
        }
    }

    /** * @throws RuntimeException */
    private function getConditionHandler(ConditionInterface $condition): ConditionHandlerInterface
    {
        // Initialize the condition handler collection service

/** * @template TCondition of ConditionInterface * * @param class-string<TCondition> $class * * @return array<TCondition> */
    public function getConditionsByClass($class)
    {
        return array_filter(
            $this->getConditions(),
            function DConditionInterface $condition) use ($class) {
                return $condition instanceof $class;
            }
        );
    }
}

        return new FacetResultGroup($results, null, 'property');
    }

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

        return $values;
    }
}

    // There are two circumstances where a plugin not listed in $enabled_plugins     // due to isEnabled() returning false, that should still have its config     // form provided:     // 1 - A conditionally enabled plugin that does not depend on a toolbar item     // to be active AND the plugins it depends on are enabled (if any) AND the     // filter it depends on is enabled (if any).     // 2 - A conditionally enabled plugin that does depend on a toolbar item,     // and that toolbar item is active.     if ($definition->hasConditions()) {
      $conditions = $definition->getConditions();
      if (!array_key_exists('toolbarItem', $conditions)) {
        $conclusion = TRUE;
        // The filter this plugin depends on must be enabled.         if (array_key_exists('filter', $conditions)) {
          $required_filter = $conditions['filter'];
          $format_filters = $editor->getFilterFormat()->filters();
          $conclusion = $conclusion && $format_filters->has($required_filter) && $format_filters->get($required_filter)->status;
        }
        // The CKEditor 5 plugins this plugin depends on must be enabled.         if (array_key_exists('plugins', $conditions)) {
          $all_plugins = $this->ckeditor5PluginManager->getDefinitions();