base.php

См. документацию.

<?php
namespace Bitrix\Report\VisualConstructor\RuntimeProvider;
 
 
use Bitrix\Report\VisualConstructor\Internal\Error\Error;
use Bitrix\Report\VisualConstructor\Internal\Error\IErrorable;
use Bitrix\Report\VisualConstructor\IProvidable;

abstract class Base implements IErrorable
{
    private $results = array();
    private $filters = array();
    private $errors = array();
    private $relations = array();

    abstract protected function availableFilterKeys();

    abstract protected function getManagerInstance();

    abstract protected function getEntitiesList();

    abstract protected function getIndices();

    private function isAvailableFilter($filterKey)
    {
        $availableFilterKeys = $this->availableFilterKeys();
 
        return in_array($filterKey, $availableFilterKeys);
    }

    public function addFilter($key, $value)
    {
        if ($this->isAvailableFilter($key))
        {
            $this->filters[$key][] = $this->normaliseFilterValue($value);
            return true;
        }
        else
        {
            $this->errors[] = new Error('Filter with key:' . $key . ' not available for this provider');
            return false;
        }
    }

    public function addRelation($key)
    {
        $this->relations[] = $key;
    }

    public function getFilters()
    {
        return $this->filters;
    }

    public function getRelations()
    {
        return $this->relations;
    }

    public function execute()
    {
        $this->callManager();
        $indices = $this->getIndices();
        $filteredEntityIds = $this->getFilteredValues($indices);
        $entities = $this->getEntitiesList();
        $result = array();
        $filters = $this->getFilters();
        if (!empty($filters))
        {
            $result = $this->applyFilters($entities, $filteredEntityIds);
        }
        else
        {
            foreach ($entities as $key => $entity)
            {
                $this->processAvailableRelations($entity);
                $result[] = $entity;
            }
        }
        $this->sortResults($result);
        $this->setResults($result);
 
        return $this;
    }

    protected function applyFilters($entities, $filteredEntityIds)
    {
        $result = [];
 
        foreach ($entities as $key => $entity)
        {
            if (in_array($key, $filteredEntityIds))
            {
                $this->processAvailableRelations($entity);
                $result[] = $entity;
            }
        }
 
        return $result;
    }
 
    protected function sortResults(&$result)
    {
        // do nothing
    }

    private function getFilteredValues($indices)
    {
        $filteredEntityIds = array();
        foreach ($this->getFilters() as $filterType => $filterValues)
        {
            if ($filterType !== 'primary')
            {
                $newFilterEntityIds = array();
                foreach ($filterValues as $filterKey)
                {
                    foreach ($filterKey as $filterValue)
                    {
                        if (isset($indices[$filterType][$filterValue]))
                        {
                            $newFilterEntityIds = array_merge($newFilterEntityIds, $indices[$filterType][$filterValue]);
                        }
                    }
                }
                if (!empty($filteredEntityIds))
                {
                    $filteredEntityIds = array_intersect($filteredEntityIds, $newFilterEntityIds);
                }
                else
                {
                    $filteredEntityIds = $newFilterEntityIds;
                }
            }
            else
            {
                if (!empty($filteredEntityIds))
                {
                    $filteredEntityIds = array_intersect($filteredEntityIds, $filterValues[0]);
                }
                else
                {
                    $filteredEntityIds = $filterValues[0];
                }
            }
        }
        return array_unique($filteredEntityIds);
    }

    public function getErrors()
    {
        return $this->errors;
    }

    private function normaliseFilterValue($value)
    {
        $result = is_array($value) ? array_unique($value) : array($value);
        return $result;
    }

    protected function processAvailableRelations($entity)
    {
        foreach ($this->getRelations() as $relationName)
        {
            $processMethodName = 'processWith' . ucfirst($relationName);
            call_user_func_array(array($this, $processMethodName), array($entity));
        }
    }
 
 
    protected function callManager()
    {
        $this->getManagerInstance()->call();
    }
 

    public function getFirstResult()
    {
        $results = $this->getResults();
        return array_shift($results);
    }
 

    public function getResults()
    {
        return $this->results;
    }

    public function setResults($results)
    {
        $this->results = $results;
    }
 
}