DumpConfigSourceAggregated.php

Go to the documentation of this file.

<?php
namespace Magento\Config\App\Config\Source;

use Magento\Config\Model\Config\Export\ExcludeList;
use Magento\Config\Model\Config\TypePool;
use Magento\Framework\App\Config\ConfigSourceInterface;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Framework\App\ObjectManager;

class DumpConfigSourceAggregated implements DumpConfigSourceInterface
{
    const RULE_TYPE_INCLUDE = 'include';

    const RULE_TYPE_EXCLUDE = 'exclude';

    private $typePool;

    private $sources;

    private $excludedFields;

    private $data;

    private $rules;

    public function __construct(
        ExcludeList $excludeList,
        array $sources = [],
        TypePool $typePool = null,
        array $rules = []
    ) {
        $this->sources = $sources;
        $this->typePool = $typePool ?: ObjectManager::getInstance()->get(TypePool::class);
        $this->rules = $rules;
    }

    public function get($path = '')
    {
        $path = (string)$path;
        $data = [];

        if (isset($this->data[$path])) {
            return $this->data[$path];
        }

        $this->sortSources();

        foreach ($this->sources as $sourceConfig) {
            $source = $sourceConfig['source'];
            $data = array_replace_recursive($data, $source->get($path));
        }

        $this->excludedFields = [];
        $this->filterChain($path, $data);

        return $this->data[$path] = $data;
    }

    private function filterChain($path, &$data)
    {
        foreach ($data as $subKey => &$subData) {
            $newPath = $path ? $path . '/' . $subKey : $subKey;
            $filteredPath = $this->filterPath($newPath);

            if (is_array($subData)) {
                $this->filterChain($newPath, $subData);
            } elseif ($this->isExcludedPath($filteredPath)) {
                $this->excludedFields[$newPath] = $filteredPath;
                unset($data[$subKey]);
            }

            if (empty($subData) && isset($data[$subKey]) && is_array($data[$subKey])) {
                unset($data[$subKey]);
            }
        }
    }

    private function isExcludedPath($path)
    {
        if (empty($path)) {
            return false;
        }

        $defaultRule = isset($this->rules['default']) ?
            $this->rules['default'] : self::RULE_TYPE_INCLUDE;

        foreach ($this->rules as $type => $rule) {
            if ($type === 'default') {
                continue;
            }

            if ($this->typePool->isPresent($path, $type)) {
                return $rule === self::RULE_TYPE_EXCLUDE;
            }
        }

        return $defaultRule === self::RULE_TYPE_EXCLUDE;
    }

    private function filterPath($path)
    {
        $parts = explode('/', $path);

        // Check if there are enough parts to recognize scope
        if (count($parts) < 3) {
            return null;
        }

        if ($parts[0] === ScopeConfigInterface::SCOPE_TYPE_DEFAULT) {
            unset($parts[0]);
        } else {
            unset($parts[0], $parts[1]);
        }

        return implode('/', $parts);
    }

    private function sortSources()
    {
        uasort($this->sources, function ($firstItem, $secondItem) {
            return $firstItem['sortOrder'] > $secondItem['sortOrder'];
        });
    }

    public function getExcludedFields()
    {
        $this->get();

        $fields = array_values($this->excludedFields);
        $fields = array_unique($fields);

        return $fields;
    }
}