vendor/metamodels/core/src/CoreBundle/Contao/Hooks/LoadDataContainer.php line 105

Open in your IDE?
  1. <?php
  3. /**
  4.  * This file is part of MetaModels/core.
  5.  *
  6.  * (c) 2012-2019 The MetaModels team.
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  *
  11.  * This project is provided in good faith and hope to be usable by anyone.
  12.  *
  13.  * @package    MetaModels/core
  14.  * @author     Christian Schiffler <c.schiffler@cyberspectrum.de>
  15.  * @author     Sven Baumann <baumann.sv@gmail.com>
  16.  * @copyright  2012-2019 The MetaModels team.
  17.  * @license    https://github.com/MetaModels/core/blob/master/LICENSE LGPL-3.0-or-later
  18.  * @filesource
  19.  */
  21. namespace MetaModels\CoreBundle\Contao\Hooks;
  23. use Contao\Controller;
  24. use Contao\CoreBundle\Framework\Adapter;
  25. use ContaoCommunityAlliance\DcGeneral\Data\ModelId;
  26. use MetaModels\CoreBundle\Assets\IconBuilder;
  27. use MetaModels\IFactory;
  28. use MetaModels\IMetaModel;
  29. use MetaModels\ViewCombination\ViewCombination;
  31. /**
  32.  * This class handles loading of the virtual data containers.
  33.  */
  34. class LoadDataContainer
  35. {
  36.     /**
  37.      * Adapter to the Contao\Controller class.
  38.      *
  39.      * @var Controller
  40.      */
  41.     private $controller;
  43.     /**
  44.      * The MetaModels factory.
  45.      *
  46.      * @var IFactory
  47.      */
  48.     private $factory;
  50.     /**
  51.      * The view combination.
  52.      *
  53.      * @var ViewCombination
  54.      */
  55.     private $combination;
  57.     /**
  58.      * The icon builder.
  59.      *
  60.      * @var IconBuilder
  61.      */
  62.     private $iconBuilder;
  64.     /**
  65.      * Create a new instance.
  66.      *
  67.      * @param IFactory        $factory           The MetaModels factory.
  68.      * @param ViewCombination $combination       The view combination provider.
  69.      * @param Adapter         $controllerAdapter The controller adapter to load languages and data containers.
  70.      * @param IconBuilder     $iconBuilder       The icon builder.
  71.      */
  72.     public function __construct(
  73.         IFactory $factory,
  74.         ViewCombination $combination,
  75.         Adapter $controllerAdapter,
  76.         IconBuilder $iconBuilder
  77.     ) {
  78.         $this->factory     = $factory;
  79.         $this->combination = $combination;
  80.         $this->controller  = $controllerAdapter;
  81.         $this->iconBuilder = $iconBuilder;
  82.     }
  84.     /**
  85.      * Load a data container.
  86.      *
  87.      * @param string $tableName The table name.
  88.      *
  89.      * @return void
  90.      */
  91.     public function onLoadDataContainer($tableName)
  92.     {
  93.         static $tableExists;
  94.         // Test that the tables have been created.
  95.         if (null === $tableExists) {
  96.             $tableExists = \System::getContainer()
  97.                 ->get('database_connection')
  98.                 ->getSchemaManager()
  99.                 ->tablesExist(['tl_metamodel']);
  100.         }
  101.         if (false === $tableExists) {
  102.             return;
  103.         }
  105.         $this->handleMetaModelTable($tableName);
  106.         $this->handleNonMetaModelTable($tableName);
  107.     }
  109.     /**
  110.      * Handle for MetaModel tables - this loads the base definition "tl_metamodel_item".
  111.      *
  112.      * @param string $tableName The table name.
  113.      *
  114.      * @return void
  115.      *
  116.      * @SuppressWarnings(PHPMD.Superglobals)
  117.      * @SuppressWarnings(PHPMD.CamelCaseVariableName)
  118.      */
  119.     private function handleMetaModelTable($tableName)
  120.     {
  121.         static $tableNames;
  122.         if (!$tableNames) {
  123.             $tableNames = $this->factory->collectNames();
  124.         }
  125.         // Not a MetaModel, get out now.
  126.         if (!in_array($tableName, $tableNames)) {
  127.             return;
  128.         }
  130.         $this->controller->loadLanguageFile('tl_metamodel_item');
  131.         $this->controller->loadDataContainer('tl_metamodel_item');
  132.         if (!isset($GLOBALS['TL_DCA'][$tableName])) {
  133.             $GLOBALS['TL_DCA'][$tableName] = [];
  134.         }
  136.         $GLOBALS['TL_DCA'][$tableName] = array_replace_recursive(
  137.             (array) $GLOBALS['TL_DCA']['tl_metamodel_item'],
  138.             (array) $GLOBALS['TL_DCA'][$tableName]
  139.         );
  140.     }
  142.     /**
  143.      * Handle for non MetaModel tables - this adds the child operations.
  144.      *
  145.      * @param string $tableName The table name.
  146.      *
  147.      * @return void
  148.      *
  149.      * @SuppressWarnings(PHPMD.Superglobals)
  150.      * @SuppressWarnings(PHPMD.CamelCaseVariableName)
  151.      */
  152.     private function handleNonMetaModelTable($tableName)
  153.     {
  154.         // Nothing to do for MetaModel tables.
  155.         if (substr($tableName, 0, 3) === 'mm_') {
  156.             return;
  157.         }
  159.         static $map;
  160.         if (!isset($map)) {
  161.             $map = $this->buildMap();
  162.         }
  164.         // No children for this table.
  165.         if (!isset($map[$tableName])) {
  166.             return;
  167.         }
  169.         $parentDCA = &$GLOBALS['TL_DCA'][$tableName];
  171.         $this->controller->loadLanguageFile('default');
  172.         foreach ($map[$tableName] as $metaModelTable => $inputScreen) {
  173.             $metaModel = $this->factory->getMetaModel($metaModelTable);
  174.             $caption   = $this->buildCaption($metaModel, $inputScreen);
  176.             $operationName                                   = 'edit_' . $metaModel->getTableName();
  177.             $parentDCA['list']['operations'][$operationName] = array
  178.             (
  179.                 'label'      => &$caption,
  180.                 'href'       => 'table=' . $metaModelTable,
  181.                 'icon'       => $this->iconBuilder->getBackendIcon($inputScreen['meta']['backendicon']),
  182.                 'attributes' => 'onclick="Backend.getScrollOffset()"',
  183.             );
  185.             // Is the destination table a metamodel with variants?
  186.             if ($metaModel->hasVariants()) {
  187.                 $parentDCA['list']['operations'][$operationName]['idparam'] = 'id_' . $tableName;
  188.             } else {
  189.                 $parentDCA['list']['operations'][$operationName]['idparam'] = 'pid';
  190.             }
  192.             // Compatibility with DC_Table.
  193.             if ($parentDCA['config']['dataContainer'] !== 'General') {
  194.                 $idParameter                                                        =
  195.                     $parentDCA['list']['operations'][$operationName]['idparam'];
  196.                 $parentDCA['list']['operations'][$operationName]['button_callback'] =
  197.                     function ($row, $href, $label, $name, $icon, $attributes, $table) use ($idParameter) {
  198.                         return $this->buildChildOperationButton(
  199.                             $idParameter,
  200.                             $row['id'],
  201.                             $href,
  202.                             $label,
  203.                             $name,
  204.                             $icon,
  205.                             $attributes,
  206.                             $table
  207.                         );
  208.                     };
  209.             }
  210.         }
  211.     }
  213.     /**
  214.      * Build the data container map.
  215.      *
  216.      * @return array
  217.      */
  218.     private function buildMap()
  219.     {
  220.         $map = [];
  221.         foreach ($this->combination->getParented() as $childName => $child) {
  222.             $map[$child['meta']['ptable']][$childName] = $child;
  223.         }
  225.         return $map;
  226.     }
  228.     /**
  229.      * Build the caption for a table.
  230.      *
  231.      * @param IMetaModel $metaModel   The MetaModel to build the caption for.
  232.      * @param array      $inputScreen The input screen information.
  233.      *
  234.      * @return array
  235.      *
  236.      * @SuppressWarnings(PHPMD.Superglobals)
  237.      * @SuppressWarnings(PHPMD.CamelCaseVariableName)
  238.      */
  239.     private function buildCaption($metaModel, $inputScreen): array
  240.     {
  241.         $caption = [
  242.             sprintf($GLOBALS['TL_LANG']['MSC']['metamodel_edit_as_child']['label'], $metaModel->getName()),
  243.             ''
  244.         ];
  246.         foreach ($inputScreen['label'] as $langCode => $label) {
  247.             if ($label !== '' && $langCode === $GLOBALS['TL_LANGUAGE']) {
  248.                 $caption = [
  249.                     $label,
  250.                     $inputScreen['description'][$langCode]
  251.                 ];
  252.             }
  253.         }
  255.         return $caption;
  256.     }
  258.     /**
  259.      * This method exists only for being compatible when MetaModels are being used as child table from DC_Table context.
  260.      *
  261.      * @param string $idParameter The id parameter in use.
  262.      *
  263.      * @param string $itemId      The current data row.
  264.      *
  265.      * @param string $href        The href to be appended.
  266.      *
  267.      * @param string $label       The operation label.
  268.      *
  269.      * @param string $name        The operation name.
  270.      *
  271.      * @param string $icon        The icon path.
  272.      *
  273.      * @param string $attributes  The button attributes.
  274.      *
  275.      * @param string $table       The table name.
  276.      *
  277.      * @return string
  278.      */
  279.     private function buildChildOperationButton($idParameter, $itemId, $href, $label, $name, $icon, $attributes, $table)
  280.     {
  281.         $modelId = ModelId::fromValues($table, $itemId);
  283.         $url = $href . '&amp;' . $idParameter . '=' . $modelId->getSerialized();
  284.         // If id parameter different, we have to override it in the URL.
  285.         if ('id' !== $idParameter) {
  286.             $url .= '&amp;id=';
  287.         }
  288.         $url = $this->controller->addToUrl($url);
  289.         // If id parameter different, we have to clean out the id in the URL now.
  290.         if ('id' !== $idParameter) {
  291.             $url = preg_replace('#(&amp;)id=(?:&amp;)?#', '$1', $url);
  292.         }
  294.         $title = sprintf($label ?: $name, $itemId);
  295.         return sprintf(
  296.             '<a href="%1$s" title="%2$s"%3$s>%4$s</a> ',
  297.             $url,
  298.             specialchars($title),
  299.             $attributes,
  300.             $this->iconBuilder->getBackendIconImageTag($icon, $label)
  301.         );
  302.     }
  303. }