vendor/pimcore/asset-metadata-class-definitions/src/Model/Configuration/Dao.php line 55

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under following license:
  6.  * - Pimcore Commercial License (PCL)
  7.  *
  8.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  9.  *  @license    http://www.pimcore.org/license     PCL
  10.  */
  11. namespace Pimcore\AssetMetadataClassDefinitionsBundle\Model\Configuration;
  12. use Pimcore\AssetMetadataClassDefinitionsBundle\Event\AssetMetadataConfigurationEvents;
  13. use Pimcore\AssetMetadataClassDefinitionsBundle\Event\Model\Asset\ConfigurationEvent;
  14. use Pimcore\AssetMetadataClassDefinitionsBundle\Model\Configuration;
  15. use Pimcore\Config;
  16. use Pimcore\File;
  17. use Pimcore\Model\Dao\AbstractDao;
  18. /**
  19.  * @property Configuration $model
  20.  */
  21. class Dao extends AbstractDao
  22. {
  23.     public const ROOT_PATH '/';
  24.     /**
  25.      * path to the configuration file
  26.      */
  27.     public const CONFIG_FILE 'assetmetadata-classdefinitions.php';
  28.     /**
  29.      * @var null|array
  30.      */
  31.     private static $_config null;
  32.     /**
  33.      * get a configuration by name.
  34.      *
  35.      * @param string $name
  36.      *
  37.      * @return Configuration|null
  38.      */
  39.     public static function getByName($name): ?Configuration
  40.     {
  41.         $list self::getList();
  42.         /** @var Configuration $item */
  43.         foreach ($list as $item) {
  44.             if ($item->getName() === $name) {
  45.                 $filename self::getConfigurationDirectory() . '/definition_' $name '.php';
  46.                 if (file_exists($filename)) {
  47.                     $definition = include($filename);
  48.                     $item->setTitle($definition->title);
  49.                     $item->setPrefix($definition->prefix);
  50.                     $item->setLayoutDefinitions($definition->layoutDefinitions);
  51.                 }
  52.                 return $item;
  53.             }
  54.         }
  55.         return null;
  56.     }
  57.     /**
  58.      * get a configuration by prefix.
  59.      *
  60.      * @param string $prefix
  61.      *
  62.      * @return Configuration|null
  63.      */
  64.     public static function getByPrefix($prefix): ?Configuration
  65.     {
  66.         $list self::getList(true);
  67.         /** @var Configuration $item */
  68.         foreach ($list as $item) {
  69.             if ($item->getPrefix() === $prefix) {
  70.                 $filename self::getConfigurationDirectory() . '/definition_' $item->getName() . '.php';
  71.                 if (file_exists($filename)) {
  72.                     $definition = include($filename);
  73.                     $item->setLayoutDefinitions($definition->layoutDefinitions);
  74.                 }
  75.                 return $item;
  76.             }
  77.         }
  78.         return null;
  79.     }
  80.     /**
  81.      * get the list of configurations.
  82.      *
  83.      * @param bool $includeDefinition
  84.      *
  85.      * @return Configuration[]
  86.      */
  87.     public static function getList($includeDefinition false): array
  88.     {
  89.         $config = &self::getConfig();
  90.         $configurations = [];
  91.         foreach ($config['list'] ?? [] as $item) {
  92.             $c = new Configuration($item['name'], $item['title']);
  93.             $c->setIcon($item['icon'] ?? null);
  94.             if ($includeDefinition) {
  95.                 $filename self::getConfigurationDirectory() . '/definition_' $c->getName() . '.php';
  96.                 if (file_exists($filename)) {
  97.                     $definition = include($filename);
  98.                     $c->setTitle($definition->title);
  99.                     $c->setPrefix($definition->prefix);
  100.                     $c->setLayoutDefinitions($definition->layoutDefinitions);
  101.                 }
  102.             }
  103.             $configurations[$c->getName()] = $c;
  104.         }
  105.         return $configurations;
  106.     }
  107.     /**
  108.      * get the whole configuration file content.
  109.      *
  110.      * @return array|mixed|null
  111.      */
  112.     private static function &getConfig()
  113.     {
  114.         if (self::$_config) {
  115.             return self::$_config;
  116.         }
  117.         $file Config::locateConfigFile(self::CONFIG_FILE);
  118.         $config null;
  119.         if (!file_exists($file)) {
  120.             $config self::defaultConfig();
  121.             self::writeConfig($config);
  122.         } else {
  123.             $config = include($file);
  124.         }
  125.         self::$_config $config;
  126.         return self::$_config;
  127.     }
  128.     /**
  129.      * get a default configuration.
  130.      *
  131.      * @return array
  132.      */
  133.     private static function defaultConfig(): array
  134.     {
  135.         return [
  136.             'list' => []
  137.         ];
  138.     }
  139.     /**
  140.      * write the configuration file.
  141.      *
  142.      * @param $config
  143.      */
  144.     private static function writeConfig($config): void
  145.     {
  146.         File::putPhpFile(Config::locateConfigFile(self::CONFIG_FILE), to_php_data_file_format($config));
  147.         // reset singleton var to force get updated config in current request when calling getConfig()
  148.         self::$_config null;
  149.     }
  150.     /**
  151.      * @param bool $create
  152.      *
  153.      * @return string
  154.      */
  155.     public static function getConfigurationDirectory($create false)
  156.     {
  157.         $dir PIMCORE_PRIVATE_VAR '/config/assetmetadata-definitions';
  158.         if ($create) {
  159.             if (!file_exists($dir)) {
  160.                 File::mkdir($dir);
  161.             }
  162.         }
  163.         return $dir;
  164.     }
  165.     /**
  166.      * save a configuration.
  167.      */
  168.     public function save(): void
  169.     {
  170.         // create dir on the fl
  171.         $this->getConfigurationDirectory(true);
  172.         /** @var string $definitionFile */
  173.         $definitionFile $this->getDefinitionFile();
  174.         /** @var bool $isUpdate */
  175.         $isUpdate file_exists($definitionFile);
  176.         if (!$isUpdate) {
  177.             \Pimcore::getEventDispatcher()->dispatch(
  178.                 new ConfigurationEvent($this->model),
  179.                 AssetMetadataConfigurationEvents::PRE_ADD
  180.             );
  181.         } else {
  182.             \Pimcore::getEventDispatcher()->dispatch(
  183.                 new ConfigurationEvent($this->model),
  184.                 AssetMetadataConfigurationEvents::PRE_UPDATE
  185.             );
  186.         }
  187.         $name $this->model->getName();
  188.         $config = &self::getConfig();
  189.         $clone = clone $this->model;
  190.         $config['list'][$name] = [
  191.             'name' => $this->model->name,
  192.             'title' => $this->model->title,
  193.             'icon' => $this->model->icon
  194.         ];
  195.         $export var_export($clonetrue);
  196.         $data '<?php ';
  197.         $data .= "\n\n";
  198.         $data .= "\nreturn " $export ";\n";
  199.         file_put_contents($definitionFile$data);
  200.         // necessary for include in getList function (when calling getList after save in current request), else include will serve the cached data without/old layoutDefinitions
  201.         if (function_exists('opcache_invalidate')) {
  202.             opcache_invalidate($definitionFiletrue);
  203.         }
  204.         self::writeConfig($config);
  205.         if ($isUpdate) {
  206.             \Pimcore::getEventDispatcher()->dispatch(
  207.                 new ConfigurationEvent($this->model),
  208.                 AssetMetadataConfigurationEvents::POST_UPDATE
  209.             );
  210.         } else {
  211.             \Pimcore::getEventDispatcher()->dispatch(
  212.                 new ConfigurationEvent($this->model),
  213.                 AssetMetadataConfigurationEvents::POST_ADD
  214.             );
  215.         }
  216.     }
  217.     /**
  218.      * @return string
  219.      */
  220.     public function getDefinitionFile()
  221.     {
  222.         $filename self::getConfigurationDirectory() . '/definition_' $this->model->getName() . '.php';
  223.         return $filename;
  224.     }
  225.     /**
  226.      * delete a configuration.
  227.      */
  228.     public function delete(): void
  229.     {
  230.         \Pimcore::getEventDispatcher()->dispatch(
  231.             new ConfigurationEvent($this->model),
  232.             AssetMetadataConfigurationEvents::PRE_DELETE
  233.         );
  234.         $name $this->model->getName();
  235.         $config = &self::getConfig();
  236.         unset($config['list'][$name]);
  237.         self::writeConfig($config);
  238.         $definitionFile $this->getDefinitionFile();
  239.         if (file_exists($definitionFile)) {
  240.             unlink($definitionFile);
  241.         }
  242.         \Pimcore::getEventDispatcher()->dispatch(
  243.             new ConfigurationEvent($this->model),
  244.             AssetMetadataConfigurationEvents::POST_DELETE
  245.         );
  246.     }
  247. }