CategoryRegistry.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Category;

use TYPO3\CMS\Core\SingletonInterface;
use TYPO3\CMS\Core\Utility\ArrayUtility;
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Lang\LanguageService;

class CategoryRegistry implements SingletonInterface {

    protected $registry = array();

    protected $extensions = array();

    protected $addedCategoryTabs = array();

    protected $template = '';

    static public function getInstance() {
        return GeneralUtility::makeInstance(__CLASS__);
    }

    public function __construct() {
        $this->template = str_repeat(PHP_EOL, 3) . 'CREATE TABLE %s (' . PHP_EOL
            . '  %s int(11) DEFAULT \'0\' NOT NULL' . PHP_EOL . ');' . str_repeat(PHP_EOL, 3);
    }

    public function add($extensionKey, $tableName, $fieldName = 'categories', array $options = array()) {
        $didRegister = FALSE;
        if (empty($tableName) || !is_string($tableName)) {
            throw new \InvalidArgumentException('No or invalid table name "' . $tableName . '" given.', 1369122038);
        }
        if (empty($extensionKey) || !is_string($extensionKey)) {
            throw new \InvalidArgumentException('No or invalid extension key "' . $extensionKey . '" given.', 1397836158);
        }

        if (!$this->isRegistered($tableName, $fieldName)) {
            $this->registry[$tableName][$fieldName] = $options;
            $this->extensions[$extensionKey][$tableName][$fieldName] = $fieldName;

            if (!isset($GLOBALS['TCA'][$tableName]['columns']) && isset($GLOBALS['TCA'][$tableName]['ctrl']['dynamicConfigFile'])) {
                // Handle deprecated old style dynamic TCA column loading.
                ExtensionManagementUtility::loadNewTcaColumnsConfigFiles();
            }

            if (isset($GLOBALS['TCA'][$tableName]['columns'])) {
                $this->applyTcaForTableAndField($tableName, $fieldName);
                $didRegister = TRUE;
            }
        }

        return $didRegister;
    }

    public function get() {
        \TYPO3\CMS\Core\Utility\GeneralUtility::logDeprecatedFunction();
        return $this->registry;
    }

    public function getExtensionKeys() {
        return array_keys($this->extensions);
    }

    public function getCategorizedTables() {
        return array_keys($this->registry);
    }

    public function getCategoryFieldsForTable(array &$configuration) {
        $table = '';
        // Define the table being looked up from the type of menu
        if ($configuration['row']['menu_type'] == 'categorized_pages') {
            $table = 'pages';
        } elseif ($configuration['row']['menu_type'] == 'categorized_content') {
            $table = 'tt_content';
        }
        // Return early if no table is defined
        if (empty($table)) {
            throw new \UnexpectedValueException('The given menu_type is not supported.', 1381823570);
        }
        // Loop on all registries and find entries for the correct table
        foreach ($this->registry as $tableName => $fields) {
            if ($tableName === $table) {
                foreach ($fields as $fieldName => $options) {
                    $fieldLabel = $this->getLanguageService()->sL($GLOBALS['TCA'][$tableName]['columns'][$fieldName]['label']);
                    $configuration['items'][] = array($fieldLabel, $fieldName);
                }
            }
        }
    }

    public function isRegistered($tableName, $fieldName = 'categories') {
        return isset($this->registry[$tableName][$fieldName]);
    }

    public function getDatabaseTableDefinitions() {
        $sql = '';
        foreach ($this->getExtensionKeys() as $extensionKey) {
            $sql .= $this->getDatabaseTableDefinition($extensionKey);
        }
        return $sql;
    }

    public function getDatabaseTableDefinition($extensionKey) {
        if (!isset($this->extensions[$extensionKey]) || !is_array($this->extensions[$extensionKey])) {
            return '';
        }
        $sql = '';

        foreach ($this->extensions[$extensionKey] as $tableName => $fields) {
            foreach ($fields as $fieldName) {
                $sql .= sprintf($this->template, $tableName, $fieldName);
            }
        }
        return $sql;
    }

    public function applyTca() {
        \TYPO3\CMS\Core\Utility\GeneralUtility::logDeprecatedFunction();
    }

    public function applyTcaForPreRegisteredTables() {
        $this->registerDefaultCategorizedTables();
        foreach ($this->registry as $tableName => $fields) {
            foreach ($fields as $fieldName => $_) {
                $this->applyTcaForTableAndField($tableName, $fieldName);
            }
        }
    }

    protected function applyTcaForTableAndField($tableName, $fieldName) {
        $this->addTcaColumn($tableName, $fieldName, $this->registry[$tableName][$fieldName]);
        $this->addToAllTCAtypes($tableName, $fieldName, $this->registry[$tableName][$fieldName]);
    }

    protected function registerDefaultCategorizedTables() {
        $defaultCategorizedTables = GeneralUtility::trimExplode(
            ',',
            $GLOBALS['TYPO3_CONF_VARS']['SYS']['defaultCategorizedTables'],
            TRUE
        );
        foreach ($defaultCategorizedTables as $defaultCategorizedTable) {
            if (!$this->isRegistered($defaultCategorizedTable)) {
                $this->add('core', $defaultCategorizedTable, 'categories');
            }
        }
    }

    protected function addToAllTCAtypes($tableName, $fieldName, array $options) {

        // Makes sure to add more TCA to an existing structure
        if (isset($GLOBALS['TCA'][$tableName]['columns'])) {

            if (empty($options['fieldList'])) {
                $fieldList = $this->addCategoryTab($tableName, $fieldName);
            } else {
                $fieldList = $options['fieldList'];
            }

            $typesList = '';
            if (!empty($options['typesList'])) {
                $typesList = $options['typesList'];
            }

            $position = '';
            if (!empty($options['position'])) {
                $position = $options['position'];
            }

            // Makes the new "categories" field to be visible in TSFE.
            ExtensionManagementUtility::addToAllTCAtypes($tableName, $fieldList, $typesList, $position);

        }
    }

    protected function addCategoryTab($tableName, $fieldName) {
        $fieldList = '';
        if (!in_array($tableName, $this->addedCategoryTabs)) {
            $fieldList .= '--div--;LLL:EXT:lang/locallang_tca.xlf:sys_category.tabs.category, ';
            $this->addedCategoryTabs[] = $tableName;
        }
        $fieldList .= $fieldName;
        return $fieldList;
    }

    protected function addTcaColumn($tableName, $fieldName, array $options) {
        // Makes sure to add more TCA to an existing structure
        if (isset($GLOBALS['TCA'][$tableName]['columns'])) {
            // Take specific label into account
            $label = 'LLL:EXT:lang/locallang_tca.xlf:sys_category.categories';
            if (!empty($options['label'])) {
                $label = $options['label'];
            }

            // Take specific value of exclude flag into account
            $exclude = TRUE;
            if (isset($options['exclude'])) {
                $exclude = (bool)$options['exclude'];
            }

            $fieldConfiguration = empty($options['fieldConfiguration']) ? array() : $options['fieldConfiguration'];

            $columns = array(
                $fieldName => array(
                    'exclude' => $exclude,
                    'label' => $label,
                    'config' =>  static::getTcaFieldConfiguration($tableName, $fieldName, $fieldConfiguration),
                ),
            );

            if (isset($options['l10n_mode'])) {
                $columns[$fieldName]['l10n_mode'] = $options['l10n_mode'];
            }
            if (isset($options['l10n_display'])) {
                $columns[$fieldName]['l10n_display'] = $options['l10n_display'];
            }
            if (isset($options['displayCond'])) {
                $columns[$fieldName]['displayCond'] = $options['displayCond'];
            }

            // Register opposite references for the foreign side of a relation
            if (empty($GLOBALS['TCA']['sys_category']['columns']['items']['config']['MM_oppositeUsage'][$tableName])) {
                $GLOBALS['TCA']['sys_category']['columns']['items']['config']['MM_oppositeUsage'][$tableName] = array();
            }
            if (!in_array($fieldName, $GLOBALS['TCA']['sys_category']['columns']['items']['config']['MM_oppositeUsage'][$tableName])) {
                $GLOBALS['TCA']['sys_category']['columns']['items']['config']['MM_oppositeUsage'][$tableName][] = $fieldName;
            }

            // Add field to interface list per default (unless the 'interface' property is FALSE)
            if (
                (!isset($options['interface']) || $options['interface'])
                && !empty($GLOBALS['TCA'][$tableName]['interface']['showRecordFieldList'])
                && !GeneralUtility::inList($GLOBALS['TCA'][$tableName]['interface']['showRecordFieldList'], $fieldName)
            ) {
                $GLOBALS['TCA'][$tableName]['interface']['showRecordFieldList'] .= ',' . $fieldName;
            }

            // Adding fields to an existing table definition
            ExtensionManagementUtility::addTCAcolumns($tableName, $columns);
        }
    }

    static public function getTcaFieldConfiguration($tableName, $fieldName = 'categories', array $fieldConfigurationOverride = array()) {
        // Forges a new field, default name is "categories"
        $fieldConfiguration = array(
            'type' => 'select',
            'foreign_table' => 'sys_category',
            'foreign_table_where' => ' AND sys_category.sys_language_uid IN (-1, 0) ORDER BY sys_category.sorting ASC',
            'MM' => 'sys_category_record_mm',
            'MM_opposite_field' => 'items',
            'MM_match_fields' => array(
                'tablenames' => $tableName,
                'fieldname' => $fieldName,
            ),
            'size' => 10,
            'autoSizeMax' => 50,
            'maxitems' => 9999,
            'renderMode' => 'tree',
            'treeConfig' => array(
                'parentField' => 'parent',
                'appearance' => array(
                    'expandAll' => TRUE,
                    'showHeader' => TRUE,
                    'maxLevels' => 99,
                ),
            ),
        );

        // Merge changes to TCA configuration
        if (!empty($fieldConfigurationOverride)) {
            ArrayUtility::mergeRecursiveWithOverrule(
                $fieldConfiguration,
                $fieldConfigurationOverride
            );
        }

        return $fieldConfiguration;
    }

    public function addCategoryDatabaseSchemaToTablesDefinition(array $sqlString) {
        $this->registerDefaultCategorizedTables();
        $sqlString[] = $this->getDatabaseTableDefinitions();
        return array('sqlString' => $sqlString);
    }

    public function addExtensionCategoryDatabaseSchemaToTablesDefinition(array $sqlString, $extensionKey) {
        $sqlString[] = $this->getDatabaseTableDefinition($extensionKey);
        return array('sqlString' => $sqlString, 'extensionKey' => $extensionKey);
    }

    protected function getLanguageService() {
        return $GLOBALS['LANG'];
    }
}