vendor/numero2/contao-marketing-suite/src/Resources/contao/library/Contao/CMSConfig.php line 123

Open in your IDE?
  1. <?php
  3. /**
  4.  * Contao Open Source CMS
  5.  *
  6.  * Copyright (c) 2005-2020 Leo Feyer
  7.  *
  8.  * @package   Contao Marketing Suite
  9.  * @author    Benny Born <benny.born@numero2.de>
  10.  * @author    Michael Bösherz <michael.boesherz@numero2.de>
  11.  * @license   Commercial
  12.  * @copyright 2020 numero2 - Agentur für digitales Marketing
  13.  */
  16. namespace Contao;
  18. use numero2\MarketingSuite\Backend\License as voudu;
  21. class CMSConfig {
  24.     /**
  25.      * Object instance (Singleton)
  26.      * @var Config
  27.      */
  28.     protected static $objInstance;
  30.     /**
  31.      * Files object
  32.      * @var Files
  33.      */
  34.     protected $Files;
  36.     /**
  37.      * Top content
  38.      * @var string
  39.      */
  40.     protected $strTop = '';
  42.     /**
  43.      * Bottom content
  44.      * @var string
  45.      */
  46.     protected $strBottom = '';
  48.     /**
  49.      * Modification indicator
  50.      * @var boolean
  51.      */
  52.     protected $blnIsModified = false;
  54.     /**
  55.      * Local file existance
  56.      * @var boolean
  57.      */
  58.     protected static $blnHasLcf;
  60.     /**
  61.      * Data
  62.      * @var array
  63.      */
  64.     protected $arrData = [];
  66.     /**
  67.      * Cache
  68.      * @var array
  69.      */
  70.     protected $arrCache = [];
  73.     /**
  74.      * Prevent direct instantiation (Singleton)
  75.      */
  76.     protected function __construct() {}
  79.     /**
  80.      * Automatically save the local configuration
  81.      */
  82.     public function __destruct() {
  84.         if( $this->blnIsModified ) {
  85.             $this->save();
  86.         }
  87.     }
  90.     /**
  91.      * Prevent cloning of the object (Singleton)
  92.      */
  93.     final public function __clone() {}
  96.     /**
  97.      * Return the current object instance (Singleton)
  98.      *
  99.      * @return static The object instance
  100.      */
  101.     public static function getInstance() {
  103.         if( static::$objInstance === null ) {
  105.             static::$objInstance = new static();
  106.             static::$objInstance->initialize();
  107.         }
  109.         return static::$objInstance;
  110.     }
  113.     /**
  114.      * Load all configuration files
  115.      */
  116.     protected function initialize() {
  118.         if( static::$blnHasLcf === null ) {
  119.             static::preload();
  120.         }
  122.         $strCacheDir = \System::getContainer()->getParameter('kernel.cache_dir');
  123.         voudu::con();
  125.         if( file_exists($strCacheDir . '/contao/config/cmsconfig.php') ) {
  127.             include $strCacheDir . '/contao/config/cmsconfig.php';
  129.         } else {
  131.             try {
  133.                 $files = \System::getContainer()->get('contao.resource_locator')->locate('config/cmsconfig.php', null, false);
  135.             } catch (\InvalidArgumentException $e) {
  137.                 $files = [];
  138.             }
  140.             foreach( $files as $file ) {
  141.                 include $file;
  142.             }
  143.         }
  145.         // Include the local configuration file again
  146.         if( static::$blnHasLcf ) {
  147.             include TL_ROOT . '/system/config/cmsconfig.php';
  148.         }
  150.         \Controller::loadDataContainer('tl_cms_settings');
  151.         $oDCA = new \DC_CMSFile('tl_cms_settings');
  153.         foreach( $GLOBALS['TL_CMSCONFIG'] as $fieldKey => $fieldConfig ) {
  154.             if( empty($GLOBALS['TL_DCA']['tl_cms_settings']['fields'][$fieldKey]) ) {
  155.                 continue;
  156.             }
  158.             $fieldValue = static::get('fieldKey');
  160.             $oDCA->strField = $fieldKey;
  161.             $oDCA->strInputName = $fieldKey;
  162.             $oDCA->varValue = static::get('fieldKey');
  164.             if( !empty($GLOBALS['TL_DCA']['tl_cms_settings']['fields'][$fieldKey]['load_callback']) ) {
  165.                 if( is_array($GLOBALS['TL_DCA']['tl_cms_settings']['fields'][$fieldKey]['load_callback']) ) {
  167.                     $varValue = $fieldValue;
  169.                     foreach( $GLOBALS['TL_DCA']['tl_cms_settings']['fields'][$fieldKey]['load_callback'] as $callback ) {
  170.                         if( is_array($callback) ) {
  171.                             $class = \System::importStatic($callback[0]);
  172.                             $varValue = $class->{$callback[1]}($varValue, $oDCA);
  173.                         } else if( is_callable($callback) ) {
  174.                             $varValue = $callback($varValue, $oDCA);
  175.                         }
  176.                     }
  178.                     if( $fieldValue !== $varValue ) {
  179.                         static::set($fieldKey, $varValue);
  180.                         // static::persist($fieldKey, $varValue);
  181.                     }
  182.                 }
  183.             }
  184.         }
  185.     }
  188.     /**
  189.      * Mark the object as modified
  190.      */
  191.     protected function markModified() {
  193.         // Return if marked as modified already
  194.         if( $this->blnIsModified === true ) {
  195.             return;
  196.         }
  198.         $this->blnIsModified = true;
  200.         // Reset the top and bottom content (see #344)
  201.         $this->strTop = '';
  202.         $this->strBottom = '';
  204.         // Import the Files object (required in the destructor)
  205.         $this->Files = \Files::getInstance();
  207.         // Parse the local configuration file
  208.         if( static::$blnHasLcf ) {
  210.             $strMode = 'top';
  211.             $resFile = fopen(TL_ROOT . '/system/config/cmsconfig.php', 'rb');
  213.             while( !feof($resFile) ) {
  215.                 $strLine = fgets($resFile);
  216.                 $strTrim = trim($strLine);
  218.                 if( $strTrim == '?>' ) {
  219.                     continue;
  220.                 }
  222.                 if( $strTrim == '### INSTALL SCRIPT START ###' ) {
  224.                     $strMode = 'data';
  225.                     continue;
  226.                 }
  228.                 if( $strTrim == '### INSTALL SCRIPT STOP ###' ) {
  230.                     $strMode = 'bottom';
  231.                     continue;
  232.                 }
  234.                 if( $strMode == 'top' ) {
  236.                     $this->strTop .= $strLine;
  238.                 } else if( $strMode == 'bottom' ) {
  240.                     $this->strBottom .= $strLine;
  242.                 } else if( $strTrim != '' ) {
  244.                     $arrChunks = array_map('trim', explode('=', $strLine, 2));
  245.                     $this->arrData[$arrChunks[0]] = $arrChunks[1];
  246.                 }
  247.             }
  249.             fclose($resFile);
  250.         }
  251.     }
  254.     /**
  255.      * Save the local configuration file
  256.      */
  257.     public function save() {
  259.         if( $this->strTop == '' ) {
  260.             $this->strTop = '<?php';
  261.         }
  263.         $strFile  = trim($this->strTop) . "\n\n";
  264.         $strFile .= "### INSTALL SCRIPT START ###\n";
  266.         foreach( $this->arrData as $k=>$v ) {
  267.             $strFile .= "$k = $v\n";
  268.         }
  270.         $strFile .= "### INSTALL SCRIPT STOP ###\n";
  271.         $this->strBottom = trim($this->strBottom);
  273.         if( $this->strBottom != '' ) {
  274.             $strFile .= "\n" . $this->strBottom . "\n";
  275.         }
  277.         $strTemp = md5(uniqid(mt_rand(), true));
  279.         // Write to a temp file first
  280.         $objFile = fopen(TL_ROOT . '/system/tmp/' . $strTemp, 'wb');
  281.         fwrite($objFile, $strFile);
  282.         fclose($objFile);
  284.         // Make sure the file has been written (see #4483)
  285.         if( !filesize(TL_ROOT . '/system/tmp/' . $strTemp) ) {
  287.             \System::log('The local cms configuration file could not be written. Have your reached your quota limit?', __METHOD__, TL_ERROR);
  289.             return;
  290.         }
  292.         // Adjust the file permissions (see #8178)
  293.         $this->Files->chmod('system/tmp/' . $strTemp, \Config::get('defaultFileChmod'));
  295.         // Then move the file to its final destination
  296.         $this->Files->rename('system/tmp/' . $strTemp, 'system/config/cmsconfig.php');
  298.         // Reset the Zend OPcache
  299.         if( \function_exists('opcache_invalidate') ) {
  300.             opcache_invalidate(TL_ROOT . '/system/config/cmsconfig.php', true);
  301.         }
  303.         // Recompile the APC file (thanks to Trenker)
  304.         if( \function_exists('apc_compile_file') && !ini_get('apc.stat') ) {
  305.             apc_compile_file(TL_ROOT . '/system/config/cmsconfig.php');
  306.         }
  308.         $this->blnIsModified = false;
  309.     }
  312.     /**
  313.      * Add a configuration variable to the local configuration file
  314.      *
  315.      * @param string $strKey   The full variable name
  316.      * @param mixed  $varValue The configuration value
  317.      */
  318.     public function add( $strKey, $varValue ) {
  320.         $this->markModified();
  321.         $this->arrData[$strKey] = $this->escape($varValue) . ';';
  322.     }
  325.     /**
  326.      * Alias for Config::add()
  327.      *
  328.      * @param string $strKey   The full variable name
  329.      * @param mixed  $varValue The configuration value
  330.      */
  331.     public function update( $strKey, $varValue ) {
  333.         $this->add($strKey, $varValue);
  334.     }
  337.     /**
  338.      * Remove a configuration variable
  339.      *
  340.      * @param string $strKey The full variable name
  341.      */
  342.     public function delete( $strKey ) {
  344.         $this->markModified();
  345.         unset($this->arrData[$strKey]);
  346.     }
  349.     /**
  350.      * Check whether a configuration value exists
  351.      *
  352.      * @param string $strKey The short key
  353.      *
  354.      * @return boolean True if the configuration value exists
  355.      */
  356.     public static function has( $strKey ) {
  358.         return array_key_exists($strKey, $GLOBALS['TL_CMSCONFIG']);
  359.     }
  362.     /**
  363.      * Return a configuration value
  364.      *
  365.      * @param string $strKey The short key
  366.      *
  367.      * @return mixed|null The configuration value
  368.      */
  369.     public static function get( $strKey ) {
  371.         if( isset($GLOBALS['TL_CMSCONFIG'][$strKey]) ) {
  372.             return $GLOBALS['TL_CMSCONFIG'][$strKey];
  373.         }
  375.         return null;
  376.     }
  379.     /**
  380.      * Temporarily set a configuration value
  381.      *
  382.      * @param string $strKey The short key
  383.      * @param string $varValue The configuration value
  384.      */
  385.     public static function set( $strKey, $varValue ) {
  387.         $GLOBALS['TL_CMSCONFIG'][$strKey] = $varValue;
  388.     }
  391.     /**
  392.      * Permanently set a configuration value
  393.      *
  394.      * @param string $strKey The short key or full variable name
  395.      * @param mixed  $varValue The configuration value
  396.      */
  397.     public static function persist( $strKey, $varValue ) {
  399.         $objConfig = static::getInstance();
  401.         if( strncmp($strKey, '$GLOBALS', 8) !== 0 ) {
  402.             $strKey = "\$GLOBALS['TL_CMSCONFIG']['$strKey']";
  403.         }
  405.         $objConfig->add($strKey, $varValue);
  406.     }
  409.     /**
  410.      * Permanently remove a configuration value
  411.      *
  412.      * @param string $strKey The short key or full variable name
  413.      */
  414.     public static function remove( $strKey ) {
  416.         $objConfig = static::getInstance();
  418.         if( strncmp($strKey, '$GLOBALS', 8) !== 0 ) {
  419.             $strKey = "\$GLOBALS['TL_CMSCONFIG']['$strKey']";
  420.         }
  422.         $objConfig->delete($strKey);
  423.     }
  426.     /**
  427.      * Preload the default and local configuration
  428.      */
  429.     public static function preload() {
  431.         $blnHasLcf = file_exists(TL_ROOT . '/system/config/cmsconfig.php');
  433.         // Include the local configuration file
  434.         if( $blnHasLcf === true ) {
  435.             include TL_ROOT . '/system/config/cmsconfig.php';
  436.         }
  438.         static::$blnHasLcf = $blnHasLcf;
  439.     }
  442.     /**
  443.      * Escape a value depending on its type
  444.      *
  445.      * @param mixed $varValue The value
  446.      *
  447.      * @return mixed The escaped value
  448.      */
  449.     protected function escape( $varValue ) {
  451.         if( is_numeric($varValue) && !preg_match('/e|^[+-]?0[^.]/', $varValue) && $varValue < PHP_INT_MAX ) {
  452.             return $varValue;
  453.         }
  455.         if( \is_bool($varValue) ) {
  456.             return $varValue ? 'true' : 'false';
  457.         }
  459.         if( $varValue == 'true' ) {
  460.             return 'true';
  461.         }
  463.         if( $varValue == 'false' ) {
  464.             return 'false';
  465.         }
  467.         return "'" . str_replace('\\"', '"', preg_replace('/[\n\r\t ]+/', ' ', addslashes($varValue))) . "'";
  468.     }
  469. }