ThemeList.php

Go to the documentation of this file.

<?php
namespace Magento\Framework\View\Design\Theme;

use Magento\Framework\Filesystem\Directory\ReadFactory;
use Magento\Framework\View\Design\ThemeInterface;

class ThemeList extends \Magento\Framework\Data\Collection implements ListInterface
{
    const CONSTRAINT_AREA = 'area';

    const CONSTRAINT_VENDOR = 'vendor';

    const CONSTRAINT_THEME_NAME = 'theme_name';

    protected $_itemObjectClass = ThemeInterface::class;

    protected $themeConfigFactory;

    private $constraints = [
        self::CONSTRAINT_AREA => [],
        self::CONSTRAINT_VENDOR => [],
        self::CONSTRAINT_THEME_NAME => [],
    ];

    private $themePackageList;

    private $dirReadFactory;

    public function __construct(
        \Magento\Framework\Data\Collection\EntityFactory $entityFactory,
        \Magento\Framework\Config\ThemeFactory $themeConfigFactory,
        ThemePackageList $themePackageList,
        ReadFactory $dirReadFactory
    ) {
        parent::__construct($entityFactory);
        $this->themeConfigFactory = $themeConfigFactory;
        $this->themePackageList = $themePackageList;
        $this->dirReadFactory = $dirReadFactory;
    }

    public function addConstraint($type, $value)
    {
        if (!isset($this->constraints[$type])) {
            throw new \UnexpectedValueException("Constraint '$type' is not supported");
        }
        if ($this->isLoaded()) {
            $this->clear();
        }
        $this->constraints[$type][] = $value;
        $this->constraints[$type] = array_unique($this->constraints[$type]);
    }

    public function resetConstraints()
    {
        foreach (array_keys($this->constraints) as $key) {
            $this->constraints[$key] = [];
        }
    }

    private function isAcceptable($constraintType, $value)
    {
        return empty($this->constraints[$constraintType]) || in_array($value, $this->constraints[$constraintType]);
    }

    public function loadData($printQuery = false, $logQuery = false)
    {
        if ($this->isLoaded()) {
            return $this;
        }

        $themes = [];
        foreach ($this->themePackageList->getThemes() as $themePackage) {
            if ($this->isAcceptable(self::CONSTRAINT_AREA, $themePackage->getArea())
                && $this->isAcceptable(self::CONSTRAINT_VENDOR, $themePackage->getVendor())
                && $this->isAcceptable(self::CONSTRAINT_THEME_NAME, $themePackage->getName())
            ) {
                $themes[] = $themePackage;
            }
        }

        $this->_loadFromFilesystem($themes);
        $this->resetConstraints();
        $this->_updateRelations()
            ->_renderFilters()
            ->_clearFilters();

        return $this;
    }

    protected function _updateRelations()
    {
        $themeItems = $this->getItems();
        foreach ($themeItems as $theme) {
            $parentThemePath = $theme->getData('parent_theme_path');
            if ($parentThemePath) {
                $themePath = $theme->getArea() . ThemeInterface::PATH_SEPARATOR . $parentThemePath;
                if (isset($themeItems[$themePath])) {
                    $theme->setParentTheme($themeItems[$themePath]);
                }
            }
        }
        return $this;
    }

    protected function _loadFromFilesystem(array $themes)
    {
        foreach ($themes as $themePackage) {
            $theme = $this->getNewEmptyItem()->addData($this->_prepareConfigurationData($themePackage));
            $this->addItem($theme);
        }
        $this->_setIsLoaded();

        return $this;
    }

    protected function _preparePathData($themePackage)
    {
        return [
            'theme_path_pieces' => [
                $themePackage->getVendor(),
                $themePackage->getName(),
            ]
        ];
    }

    protected function _prepareConfigurationData($themePackage)
    {
        $themeConfig = $this->_getConfigModel($themePackage);
        $pathData = $this->_preparePathData($themePackage);
        $media = $themeConfig->getMedia();

        $parentPathPieces = $themeConfig->getParentTheme();
        if (is_array($parentPathPieces) && count($parentPathPieces) == 1) {
            $pathPieces = $pathData['theme_path_pieces'];
            array_pop($pathPieces);
            $parentPathPieces = array_merge($pathPieces, $parentPathPieces);
        }

        $themePath = implode(ThemeInterface::PATH_SEPARATOR, $pathData['theme_path_pieces']);
        $themeCode = implode(ThemeInterface::CODE_SEPARATOR, $pathData['theme_path_pieces']);
        $parentPath = $parentPathPieces ? implode(ThemeInterface::PATH_SEPARATOR, $parentPathPieces) : null;

        return [
            'parent_id' => null,
            'type' => ThemeInterface::TYPE_PHYSICAL,
            'area' => $themePackage->getArea(),
            'theme_path' => $themePath,
            'code' => $themeCode,
            'theme_title' => $themeConfig->getThemeTitle(),
            'preview_image' => $media['preview_image'] ? $media['preview_image'] : null,
            'parent_theme_path' => $parentPath
        ];
    }

    protected function _renderFilters()
    {
        $filters = $this->getFilter([]);
        foreach ($this->getItems() as $itemKey => $theme) {
            $removeItem = false;
            foreach ($filters as $filter) {
                if ($filter['type'] == 'and' && $theme->getDataUsingMethod($filter['field']) != $filter['value']) {
                    $removeItem = true;
                }
            }
            if ($removeItem) {
                $this->removeItemByKey($itemKey);
            }
        }
        return $this;
    }

    protected function _clearFilters()
    {
        $this->_filters = [];
        return $this;
    }

    protected function _getConfigModel($themePackage)
    {
        $themeDir = $this->dirReadFactory->create($themePackage->getPath());
        if ($themeDir->isExist('theme.xml')) {
            $configContent = $themeDir->readFile('theme.xml');
        } else {
            $configContent = '';
        }
        return $this->themeConfigFactory->create(['configContent' => $configContent]);
    }

    protected function _getItemId(\Magento\Framework\DataObject $item)
    {
        return $item->getFullPath();
    }

    public function toOptionArray($addEmptyField = false)
    {
        $optionArray = $addEmptyField ? ['' => ''] : [];
        return $optionArray + $this->_toOptionArray('theme_id', 'theme_title');
    }

    public function hasTheme(ThemeInterface $theme)
    {
        $themeItems = $this->getItems();
        return $theme->getThemePath() && isset($themeItems[$theme->getFullPath()]);
    }

    public function getThemeByFullPath($fullPath)
    {
        list($area, $themePath) = explode('/', $fullPath, 2);
        $this->addConstraint(self::CONSTRAINT_AREA, $area);
        $this->addFilter('theme_path', $themePath);

        return $this->getFirstItem();
    }
}