vendor/shopware/core/Framework/DataAbstractionLayer/Search/Criteria.php line 14

Open in your IDE?
  1. <?php declare(strict_types=1);
  2. namespace Shopware\Core\Framework\DataAbstractionLayer\Search;
  3. use Shopware\Core\Framework\DataAbstractionLayer\Exception\InconsistentCriteriaIdsException;
  4. use Shopware\Core\Framework\DataAbstractionLayer\Search\Aggregation\Aggregation;
  5. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  6. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\Filter;
  7. use Shopware\Core\Framework\DataAbstractionLayer\Search\Grouping\FieldGrouping;
  8. use Shopware\Core\Framework\DataAbstractionLayer\Search\Query\ScoreQuery;
  9. use Shopware\Core\Framework\DataAbstractionLayer\Search\Sorting\FieldSorting;
  10. use Shopware\Core\Framework\Struct\Struct;
  11. class Criteria extends Struct
  12. {
  13.     /**
  14.      * no total count will be selected. Should be used if no pagination required (fastest)
  15.      */
  16.     public const TOTAL_COUNT_MODE_NONE 0;
  17.     /**
  18.      * exact total count will be selected. Should be used if an exact pagination is required (slow)
  19.      */
  20.     public const TOTAL_COUNT_MODE_EXACT 1;
  21.     /**
  22.      * fetches limit * 5 + 1. Should be used if pagination can work with "next page exists" (fast)
  23.      */
  24.     public const TOTAL_COUNT_MODE_NEXT_PAGES 2;
  25.     /**
  26.      * @deprecated tag:v6.3.0 - Use `includes` instead
  27.      *
  28.      * @var array|null
  29.      */
  30.     protected $source;
  31.     /**
  32.      * @var FieldSorting[]
  33.      */
  34.     protected $sorting = [];
  35.     /**
  36.      * @var Filter[]
  37.      */
  38.     protected $filters = [];
  39.     /**
  40.      * @var Filter[]
  41.      */
  42.     protected $postFilters = [];
  43.     /**
  44.      * @var Aggregation[]
  45.      */
  46.     protected $aggregations = [];
  47.     /**
  48.      * @var ScoreQuery[]
  49.      */
  50.     protected $queries = [];
  51.     /**
  52.      * @var FieldGrouping[]
  53.      */
  54.     protected $groupFields = [];
  55.     /**
  56.      * @var int|null
  57.      */
  58.     protected $offset;
  59.     /**
  60.      * @var int|null
  61.      */
  62.     protected $limit;
  63.     /**
  64.      * @var int
  65.      */
  66.     protected $totalCountMode self::TOTAL_COUNT_MODE_NONE;
  67.     /**
  68.      * @var Criteria[]
  69.      */
  70.     protected $associations = [];
  71.     /**
  72.      * @var string[]
  73.      */
  74.     protected $ids;
  75.     /**
  76.      * @var array
  77.      */
  78.     protected $states = [];
  79.     /**
  80.      * @var bool
  81.      */
  82.     protected $inherited false;
  83.     /**
  84.      * @var string|null
  85.      */
  86.     protected $term;
  87.     /**
  88.      * @var array|null
  89.      */
  90.     protected $includes;
  91.     /**
  92.      * @throws InconsistentCriteriaIdsException
  93.      */
  94.     public function __construct(array $ids = [])
  95.     {
  96.         if (\count($ids) > \count(array_filter($ids))) {
  97.             throw new InconsistentCriteriaIdsException();
  98.         }
  99.         $this->ids $ids;
  100.     }
  101.     public function getIds(): array
  102.     {
  103.         return $this->ids;
  104.     }
  105.     public function getOffset(): ?int
  106.     {
  107.         return $this->offset;
  108.     }
  109.     public function getLimit(): ?int
  110.     {
  111.         return $this->limit;
  112.     }
  113.     public function getTotalCountMode(): int
  114.     {
  115.         return $this->totalCountMode;
  116.     }
  117.     /**
  118.      * @return FieldSorting[]
  119.      */
  120.     public function getSorting(): array
  121.     {
  122.         return $this->sorting;
  123.     }
  124.     /**
  125.      * @return Aggregation[]
  126.      */
  127.     public function getAggregations(): array
  128.     {
  129.         return $this->aggregations;
  130.     }
  131.     public function getAggregation(string $name): ?Aggregation
  132.     {
  133.         return $this->aggregations[$name] ?? null;
  134.     }
  135.     /**
  136.      * @return Filter[]
  137.      */
  138.     public function getFilters(): array
  139.     {
  140.         return $this->filters;
  141.     }
  142.     public function hasEqualsFilter($field): bool
  143.     {
  144.         return count(array_filter($this->filters, static function (Filter $filter) use ($field) {
  145.             /* EqualsFilter $filter */
  146.             return $filter instanceof EqualsFilter && $filter->getField() === $field;
  147.         })) > 0;
  148.     }
  149.     /**
  150.      * @return Filter[]
  151.      */
  152.     public function getPostFilters(): array
  153.     {
  154.         return $this->postFilters;
  155.     }
  156.     /**
  157.      * @return ScoreQuery[]
  158.      */
  159.     public function getQueries(): array
  160.     {
  161.         return $this->queries;
  162.     }
  163.     public function getAssociations(): array
  164.     {
  165.         return $this->associations;
  166.     }
  167.     /**
  168.      * Returns the criteria for the provided association path. Also supports nested paths
  169.      *
  170.      * e.g `$criteria->getAssociation('categories.media.thumbnails')`
  171.      *
  172.      * @throws InconsistentCriteriaIdsException
  173.      */
  174.     public function getAssociation(string $path): Criteria
  175.     {
  176.         $parts explode('.'$path);
  177.         $criteria $this;
  178.         foreach ($parts as $part) {
  179.             if ($part === 'extensions') {
  180.                 continue;
  181.             }
  182.             if (!$criteria->hasAssociation($part)) {
  183.                 $criteria->associations[$part] = new Criteria();
  184.             }
  185.             $criteria $criteria->associations[$part];
  186.         }
  187.         return $criteria;
  188.     }
  189.     public function addFilter(Filter ...$queries): self
  190.     {
  191.         foreach ($queries as $query) {
  192.             $this->filters[] = $query;
  193.         }
  194.         return $this;
  195.     }
  196.     public function addSorting(FieldSorting ...$sorting): self
  197.     {
  198.         foreach ($sorting as $sort) {
  199.             $this->sorting[] = $sort;
  200.         }
  201.         return $this;
  202.     }
  203.     public function addAggregation(Aggregation ...$aggregations): self
  204.     {
  205.         foreach ($aggregations as $aggregation) {
  206.             $this->aggregations[$aggregation->getName()] = $aggregation;
  207.         }
  208.         return $this;
  209.     }
  210.     public function addPostFilter(Filter ...$queries): self
  211.     {
  212.         foreach ($queries as $query) {
  213.             $this->postFilters[] = $query;
  214.         }
  215.         return $this;
  216.     }
  217.     public function addQuery(ScoreQuery ...$queries): self
  218.     {
  219.         foreach ($queries as $query) {
  220.             $this->queries[] = $query;
  221.         }
  222.         return $this;
  223.     }
  224.     /**
  225.      * Add for each part of the provided path an association
  226.      *
  227.      * e.g
  228.      *
  229.      * $criteria->addAssociation('categories.media.thumbnails')
  230.      *
  231.      * @throws InconsistentCriteriaIdsException
  232.      *
  233.      * @return Criteria
  234.      */
  235.     public function addAssociation(string $path): self
  236.     {
  237.         $parts explode('.'$path);
  238.         $criteria $this;
  239.         foreach ($parts as $part) {
  240.             if (\mb_strtolower($part) === 'extensions') {
  241.                 continue;
  242.             }
  243.             $criteria $criteria->getAssociation($part);
  244.         }
  245.         return $this;
  246.     }
  247.     /**
  248.      * Allows to add multiple associations paths
  249.      *
  250.      * e.g.:
  251.      *
  252.      * $criteria->addAssociations([
  253.      *      'prices',
  254.      *      'cover.media',
  255.      *      'categories.cover.media'
  256.      * ]);
  257.      *
  258.      * @throws InconsistentCriteriaIdsException
  259.      *
  260.      * @return Criteria
  261.      */
  262.     public function addAssociations(array $paths): self
  263.     {
  264.         foreach ($paths as $path) {
  265.             $this->addAssociation($path);
  266.         }
  267.         return $this;
  268.     }
  269.     public function hasAssociation(string $field): bool
  270.     {
  271.         return isset($this->associations[$field]);
  272.     }
  273.     public function resetSorting(): self
  274.     {
  275.         $this->sorting = [];
  276.         return $this;
  277.     }
  278.     public function resetAssociations(): self
  279.     {
  280.         $this->associations = [];
  281.         return $this;
  282.     }
  283.     public function resetQueries(): self
  284.     {
  285.         $this->queries = [];
  286.         return $this;
  287.     }
  288.     public function resetFilters(): self
  289.     {
  290.         $this->filters = [];
  291.         return $this;
  292.     }
  293.     public function resetPostFilters(): self
  294.     {
  295.         $this->postFilters = [];
  296.         return $this;
  297.     }
  298.     public function resetAggregations(): self
  299.     {
  300.         $this->aggregations = [];
  301.         return $this;
  302.     }
  303.     public function setTotalCountMode(int $totalCountMode): self
  304.     {
  305.         $this->totalCountMode $totalCountMode;
  306.         return $this;
  307.     }
  308.     public function setLimit(?int $limit): self
  309.     {
  310.         $this->limit $limit;
  311.         return $this;
  312.     }
  313.     public function setOffset(?int $offset): self
  314.     {
  315.         $this->offset $offset;
  316.         return $this;
  317.     }
  318.     public function getAggregationQueryFields(): array
  319.     {
  320.         return $this->collectFields([
  321.             $this->filters,
  322.             $this->queries,
  323.         ]);
  324.     }
  325.     public function getSearchQueryFields(): array
  326.     {
  327.         return $this->collectFields([
  328.             $this->filters,
  329.             $this->postFilters,
  330.             $this->sorting,
  331.             $this->queries,
  332.             $this->groupFields,
  333.         ]);
  334.     }
  335.     public function getFilterFields(): array
  336.     {
  337.         return $this->collectFields([
  338.             $this->filters,
  339.             $this->postFilters,
  340.         ]);
  341.     }
  342.     public function getAllFields(): array
  343.     {
  344.         return $this->collectFields([
  345.             $this->filters,
  346.             $this->postFilters,
  347.             $this->sorting,
  348.             $this->queries,
  349.             $this->groupFields,
  350.             $this->aggregations,
  351.         ]);
  352.     }
  353.     public function setIds(array $ids): self
  354.     {
  355.         $this->ids $ids;
  356.         return $this;
  357.     }
  358.     public function addState(string $state): self
  359.     {
  360.         $this->states[$state] = true;
  361.         return $this;
  362.     }
  363.     public function hasState(string $state): bool
  364.     {
  365.         return isset($this->states[$state]);
  366.     }
  367.     public function getTerm(): ?string
  368.     {
  369.         return $this->term;
  370.     }
  371.     public function setTerm(?string $term): self
  372.     {
  373.         $this->term $term;
  374.         return $this;
  375.     }
  376.     public function cloneForRead(array $ids = []): Criteria
  377.     {
  378.         $self = new self($ids);
  379.         $associations = [];
  380.         foreach ($this->associations as $name => $association) {
  381.             $associations[$name] = clone $association;
  382.         }
  383.         $self->associations $associations;
  384.         return $self;
  385.     }
  386.     public function addGroupField(FieldGrouping $grouping): self
  387.     {
  388.         $this->groupFields[] = $grouping;
  389.         return $this;
  390.     }
  391.     /**
  392.      * @return FieldGrouping[]
  393.      */
  394.     public function getGroupFields(): array
  395.     {
  396.         return $this->groupFields;
  397.     }
  398.     public function resetGroupFields(): self
  399.     {
  400.         $this->groupFields = [];
  401.         return $this;
  402.     }
  403.     public function getSource(): ?array
  404.     {
  405.         return $this->source;
  406.     }
  407.     public function setSource(?array $source): void
  408.     {
  409.         $this->source $source;
  410.     }
  411.     public function setIncludes(?array $includes): void
  412.     {
  413.         $this->includes $includes;
  414.     }
  415.     public function getIncludes()
  416.     {
  417.         return $this->includes;
  418.     }
  419.     public function getApiAlias(): string
  420.     {
  421.         return 'dal_criteria';
  422.     }
  423.     public function useIdSorting(): bool
  424.     {
  425.         if (empty($this->getIds())) {
  426.             return false;
  427.         }
  428.         // manual sorting provided
  429.         if (!empty($this->getSorting())) {
  430.             return false;
  431.         }
  432.         // result will be sorted by interpreted search term and the calculated ranking
  433.         if (!empty($this->getTerm())) {
  434.             return false;
  435.         }
  436.         // result will be sorted by calculated ranking
  437.         if (!empty($this->getQueries())) {
  438.             return false;
  439.         }
  440.         return true;
  441.     }
  442.     private function collectFields(array $parts): array
  443.     {
  444.         $fields = [];
  445.         foreach ($parts as $part) {
  446.             /** @var CriteriaPartInterface $item */
  447.             foreach ($part as $item) {
  448.                 foreach ($item->getFields() as $field) {
  449.                     $fields[] = $field;
  450.                 }
  451.             }
  452.         }
  453.         return $fields;
  454.     }
  455. }