AbstractServiceCollection.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\Api;

use Magento\Framework\Data\Collection\EntityFactoryInterface;
use Magento\Framework\Exception\LocalizedException;

abstract class AbstractServiceCollection extends \Magento\Framework\Data\Collection
{
    protected $fieldFilters = [];

    protected $filterBuilder;

    protected $searchCriteriaBuilder;

    protected $sortOrderBuilder;

    public function __construct(
        EntityFactoryInterface $entityFactory,
        FilterBuilder $filterBuilder,
        SearchCriteriaBuilder $searchCriteriaBuilder,
        SortOrderBuilder $sortOrderBuilder
    ) {
        parent::__construct($entityFactory);
        $this->filterBuilder = $filterBuilder;
        $this->searchCriteriaBuilder = $searchCriteriaBuilder;
        $this->sortOrderBuilder = $sortOrderBuilder;
    }

    public function addFieldToFilter($field, $condition)
    {
        if (is_array($field) && is_array($condition) && count($field) != count($condition)) {
            throw new LocalizedException(
                new \Magento\Framework\Phrase(
                    'The field array failed to pass. The array must have a matching condition array.'
                )
            );
        } elseif (is_array($field) && !count($field) > 0) {
            throw new LocalizedException(
                new \Magento\Framework\Phrase(
                    'The array of fields failed to pass. The array must include at one field.'
                )
            );
        }
        $this->processFilters($field, $condition);
        return $this;
    }

    private function processFilters($field, $condition)
    {
        //test if we have multiple conditions per field
        $requiresMultipleFilterGroups = false;
        if (is_array($field) && is_array($condition)) {
            foreach ($condition as $cond) {
                if (is_array($cond) && count($cond) > 1) {
                    $requiresMultipleFilterGroups = true;
                    break;
                }
            }
        } elseif (is_array($condition)) {
            $requiresMultipleFilterGroups = true;
        }

        if ($requiresMultipleFilterGroups) {
            $this->addFilterGroupsForMultipleConditions($field, $condition);
        } else {
            $this->addFilterGroupsForSingleConditions($field, $condition);
        }
        return $this;
    }

    private function addFilterGroupsForSingleConditions($field, $condition)
    {
        $this->fieldFilters[] = ['field' => $field, 'condition' => $condition];
        return $this;
    }

    private function addFilterGroupsForMultipleConditions($field, $condition)
    {
        if (!is_array($field) && is_array($condition)) {
            foreach ($condition as $key => $value) {
                $this->fieldFilters[] = ['field' => $field, 'condition' => [$key => $value]];
            }
        } else {
            $cnt = 0;
            foreach ($condition as $cond) {
                if (is_array($cond)) {
                    //we Do want multiple groups in this case
                    foreach ($cond as $condKey => $condValue) {
                        $this->fieldFilters[] = [
                            'field' => array_slice($field, $cnt, 1, true),
                            'condition' => [$condKey => $condValue]
                        ];
                    }
                } else {
                    $this->fieldFilters[] = ['field' => array_slice($field, $cnt, 1, true), 'condition' => $cond];
                }
                $cnt++;
            }
        }
        return $this;
    }

    protected function getSearchCriteria()
    {
        foreach ($this->fieldFilters as $filter) {
            // array of fields, put filters in array to use 'or' group
            $filterGroup = [];
            if (!is_array($filter['field'])) {
                // just one field
                $filterGroup = [$this->createFilterData($filter['field'], $filter['condition'])];
            } else {
                foreach ($filter['field'] as $index => $field) {
                    $filterGroup[] = $this->createFilterData($field, $filter['condition'][$index]);
                }
            }
            $this->searchCriteriaBuilder->addFilters($filterGroup);
        }
        foreach ($this->_orders as $field => $direction) {
            $direction = ($direction == 'ASC') ? SortOrder::SORT_ASC : SortOrder::SORT_DESC;
            $sortOrder = $this->sortOrderBuilder->setField($field)->setDirection($direction)->create();
            $this->searchCriteriaBuilder->addSortOrder($sortOrder);
        }
        $this->searchCriteriaBuilder->setCurrentPage($this->_curPage);
        $this->searchCriteriaBuilder->setPageSize($this->_pageSize);
        return $this->searchCriteriaBuilder->create();
    }

    protected function createFilterData($field, $condition)
    {
        $this->filterBuilder->setField($field);

        if (is_array($condition)) {
            $this->filterBuilder->setValue(reset($condition));
            $this->filterBuilder->setConditionType(key($condition));
        } else {
            // not an array, just use eq as condition type and given value
            $this->filterBuilder->setConditionType('eq');
            $this->filterBuilder->setValue($condition);
        }
        return $this->filterBuilder->create();
    }
}