CRM/Core/Config.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 5                                                  |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2019                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  * Config handles all the run time configuration changes that the system needs to deal with.
  30  *
  31  * Typically we'll have different values for a user's sandbox, a qa sandbox and a production area.
  32  * The default values in general, should reflect production values (minimizes chances of screwing up)
  33  *
  34  * @package CRM
  35  * @copyright CiviCRM LLC (c) 2004-2019
  36  */
  37
  38 require_once 'Log.php';
  39 require_once 'Mail.php';
  40
  41 require_once 'api/api.php';
  42
  43 /**
  44  * Class CRM_Core_Config
  45  *
  46  * @property CRM_Utils_System_Base $userSystem
  47  * @property CRM_Core_Permission_Base $userPermissionClass
  48  * @property array $enableComponents
  49  * @property array $languageLimit
  50  * @property bool $debug
  51  * @property bool $doNotResetCache
  52  * @property string $maxFileSize
  53  * @property string $defaultCurrency
  54  * @property string $defaultCurrencySymbol
  55  * @property string $lcMessages
  56  * @property string $fieldSeparator
  57  * @property string $userFramework
  58  * @property string $verpSeparator
  59  * @property string $dateFormatFull
  60  * @property string $resourceBase
  61  * @property string $dsn
  62  * @property string $customTemplateDir
  63  * @property string $defaultContactCountry
  64  * @property string $defaultContactStateProvince
  65  * @property string $monetaryDecimalPoint
  66  * @property string $monetaryThousandSeparator
  67  * @property array fiscalYearStart
  68  */
  69 class CRM_Core_Config extends CRM_Core_Config_MagicMerge {
  70
  71   /**
  72    * The handle to the log that we are using
  73    * @var object
  74    */
  75   private static $_log = NULL;
  76
  77   /**
  78    * We only need one instance of this object. So we use the singleton
  79    * pattern and cache the instance in this variable
  80    *
  81    * @var CRM_Core_Config
  82    */
  83   private static $_singleton = NULL;
  84
  85   /**
  86    * The constructor. Sets domain id if defined, otherwise assumes
  87    * single instance installation.
  88    */
  89   public function __construct() {
  90     parent::__construct();
  91   }
  92
  93   /**
  94    * Singleton function used to manage this object.
  95    *
  96    * @param bool $loadFromDB
  97    *   whether to load from the database.
  98    * @param bool $force
  99    *   whether to force a reconstruction.
 100    *
 101    * @return CRM_Core_Config
 102    */
 103   public static function &singleton($loadFromDB = TRUE, $force = FALSE) {
 104     if (self::$_singleton === NULL || $force) {
 105       $GLOBALS['civicrm_default_error_scope'] = CRM_Core_TemporaryErrorScope::create(['CRM_Core_Error', 'handle']);
 106       $errorScope = CRM_Core_TemporaryErrorScope::create(['CRM_Core_Error', 'simpleHandler']);
 107
 108       if (defined('E_DEPRECATED')) {
 109         error_reporting(error_reporting() & ~E_DEPRECATED);
 110       }
 111
 112       self::$_singleton = new CRM_Core_Config();
 113       \Civi\Core\Container::boot($loadFromDB);
 114       if ($loadFromDB && self::$_singleton->dsn) {
 115         $domain = \CRM_Core_BAO_Domain::getDomain();
 116         \CRM_Core_BAO_ConfigSetting::applyLocale(\Civi::settings($domain->id), $domain->locales);
 117
 118         unset($errorScope);
 119
 120         CRM_Utils_Hook::config(self::$_singleton);
 121         self::$_singleton->authenticate();
 122
 123         // Extreme backward compat: $config binds to active domain at moment of setup.
 124         self::$_singleton->getSettings();
 125
 126         Civi::service('settings_manager')->useDefaults();
 127
 128         self::$_singleton->handleFirstRun();
 129       }
 130     }
 131     return self::$_singleton;
 132   }
 133
 134   /**
 135    * Returns the singleton logger for the application.
 136    *
 137    * @deprecated
 138    * @return object
 139    * @see Civi::log()
 140    */
 141   public static function &getLog() {
 142     if (!isset(self::$_log)) {
 143       self::$_log = Log::singleton('display');
 144     }
 145
 146     return self::$_log;
 147   }
 148
 149   /**
 150    * Retrieve a mailer to send any mail from the application.
 151    *
 152    * @return Mail
 153    * @deprecated
 154    * @see Civi::service()
 155    */
 156   public static function getMailer() {
 157     return Civi::service('pear_mail');
 158   }
 159
 160   /**
 161    * Deletes the web server writable directories.
 162    *
 163    * @param int $value
 164    *   1: clean templates_c, 2: clean upload, 3: clean both
 165    * @param bool $rmdir
 166    */
 167   public function cleanup($value, $rmdir = TRUE) {
 168     $value = (int ) $value;
 169
 170     if ($value & 1) {
 171       // clean templates_c
 172       CRM_Utils_File::cleanDir($this->templateCompileDir, $rmdir);
 173       CRM_Utils_File::createDir($this->templateCompileDir);
 174     }
 175     if ($value & 2) {
 176       // clean upload dir
 177       CRM_Utils_File::cleanDir($this->uploadDir);
 178       CRM_Utils_File::createDir($this->uploadDir);
 179     }
 180
 181     // Whether we delete/create or simply preserve directories, we should
 182     // certainly make sure the restrictions are enforced.
 183     foreach ([
 184       $this->templateCompileDir,
 185       $this->uploadDir,
 186       $this->configAndLogDir,
 187       $this->customFileUploadDir,
 188     ] as $dir) {
 189       if ($dir && is_dir($dir)) {
 190         CRM_Utils_File::restrictAccess($dir);
 191       }
 192     }
 193   }
 194
 195   /**
 196    * Verify that the needed parameters are not null in the config.
 197    *
 198    * @param CRM_Core_Config $config (reference) the system config object
 199    * @param array $required (reference) the parameters that need a value
 200    *
 201    * @return bool
 202    */
 203   public static function check(&$config, &$required) {
 204     foreach ($required as $name) {
 205       if (CRM_Utils_System::isNull($config->$name)) {
 206         return FALSE;
 207       }
 208     }
 209     return TRUE;
 210   }
 211
 212   /**
 213    * Reset the serialized array and recompute.
 214    * use with care
 215    */
 216   public function reset() {
 217     $query = "UPDATE civicrm_domain SET config_backend = null";
 218     CRM_Core_DAO::executeQuery($query);
 219   }
 220
 221   /**
 222    * This method should initialize auth sources.
 223    */
 224   public function authenticate() {
 225     // make sure session is always initialised
 226     $session = CRM_Core_Session::singleton();
 227
 228     // for logging purposes, pass the userID to the db
 229     $userID = $session->get('userID');
 230     if ($userID) {
 231       CRM_Core_DAO::executeQuery('SET @civicrm_user_id = %1',
 232         [1 => [$userID, 'Integer']]
 233       );
 234     }
 235
 236     if ($session->get('userID') && !$session->get('authSrc')) {
 237       $session->set('authSrc', CRM_Core_Permission::AUTH_SRC_LOGIN);
 238     }
 239
 240     // checksum source
 241     CRM_Contact_BAO_Contact_Permission::initChecksumAuthSrc();
 242   }
 243
 244   /**
 245    * One function to get domain ID.
 246    *
 247    * @param int $domainID
 248    * @param bool $reset
 249    *
 250    * @return int|null
 251    */
 252   public static function domainID($domainID = NULL, $reset = FALSE) {
 253     static $domain;
 254     if ($domainID) {
 255       $domain = $domainID;
 256     }
 257     if ($reset || empty($domain)) {
 258       $domain = defined('CIVICRM_DOMAIN_ID') ? CIVICRM_DOMAIN_ID : 1;
 259     }
 260
 261     return $domain;
 262   }
 263
 264   /**
 265    * Function to get environment.
 266    *
 267    * @param string $env
 268    * @param bool $reset
 269    *
 270    * @return string
 271    */
 272   public static function environment($env = NULL, $reset = FALSE) {
 273     if ($env) {
 274       $environment = $env;
 275     }
 276     if ($reset || empty($environment)) {
 277       $environment = Civi::settings()->get('environment');
 278     }
 279     if (!$environment) {
 280       $environment = 'Production';
 281     }
 282     return $environment;
 283   }
 284
 285   /**
 286    * Do general cleanup of caches, temp directories and temp tables
 287    * CRM-8739
 288    *
 289    * @param bool $sessionReset
 290    */
 291   public function cleanupCaches($sessionReset = TRUE) {
 292     // cleanup templates_c directory
 293     $this->cleanup(1, FALSE);
 294
 295     // clear all caches
 296     self::clearDBCache();
 297     Civi::cache('session')->clear();
 298     CRM_Utils_System::flushCache();
 299
 300     if ($sessionReset) {
 301       $session = CRM_Core_Session::singleton();
 302       $session->reset(2);
 303     }
 304   }
 305
 306   /**
 307    * Do general cleanup of module permissions.
 308    */
 309   public function cleanupPermissions() {
 310     $module_files = CRM_Extension_System::singleton()->getMapper()->getActiveModuleFiles();
 311     if ($this->userPermissionClass->isModulePermissionSupported()) {
 312       // Can store permissions -- so do it!
 313       $this->userPermissionClass->upgradePermissions(
 314         CRM_Core_Permission::basicPermissions()
 315       );
 316     }
 317     else {
 318       // Cannot store permissions -- warn if any modules require them
 319       $modules_with_perms = [];
 320       foreach ($module_files as $module_file) {
 321         $perms = $this->userPermissionClass->getModulePermissions($module_file['prefix']);
 322         if (!empty($perms)) {
 323           $modules_with_perms[] = $module_file['prefix'];
 324         }
 325       }
 326       if (!empty($modules_with_perms)) {
 327         CRM_Core_Session::setStatus(
 328           ts('Some modules define permissions, but the CMS cannot store them: %1', [1 => implode(', ', $modules_with_perms)]),
 329           ts('Permission Error'),
 330           'error'
 331         );
 332       }
 333     }
 334   }
 335
 336   /**
 337    * Flush information about loaded modules.
 338    */
 339   public function clearModuleList() {
 340     CRM_Extension_System::singleton()->getCache()->flush();
 341     CRM_Utils_Hook::singleton(TRUE);
 342     CRM_Core_PseudoConstant::getModuleExtensions(TRUE);
 343     CRM_Core_Module::getAll(TRUE);
 344   }
 345
 346   /**
 347    * Clear db cache.
 348    */
 349   public static function clearDBCache() {
 350     $queries = [
 351       'TRUNCATE TABLE civicrm_acl_cache',
 352       'TRUNCATE TABLE civicrm_acl_contact_cache',
 353       'TRUNCATE TABLE civicrm_cache',
 354       'TRUNCATE TABLE civicrm_prevnext_cache',
 355       'UPDATE civicrm_group SET cache_date = NULL',
 356       'TRUNCATE TABLE civicrm_group_contact_cache',
 357       'TRUNCATE TABLE civicrm_menu',
 358       'UPDATE civicrm_setting SET value = NULL WHERE name="navigation" AND contact_id IS NOT NULL',
 359     ];
 360
 361     foreach ($queries as $query) {
 362       CRM_Core_DAO::executeQuery($query);
 363     }
 364
 365     if ($adapter = CRM_Utils_Constant::value('CIVICRM_BAO_CACHE_ADAPTER')) {
 366       return $adapter::clearDBCache();
 367     }
 368
 369     // also delete all the import and export temp tables
 370     self::clearTempTables();
 371   }
 372
 373   /**
 374    * Clear leftover temporary tables.
 375    *
 376    * This is called on upgrade, during tests and site move, from the cron and via clear caches in the UI.
 377    *
 378    * Currently the UI clear caches does not pass a time interval - which may need review as it does risk
 379    * ripping the tables out from underneath a current action. This was considered but
 380    * out-of-scope for CRM-16167
 381    *
 382    * @param string|bool $timeInterval
 383    *   Optional time interval for mysql date function.g '2 day'. This can be used to prevent
 384    *   tables created recently from being deleted.
 385    */
 386   public static function clearTempTables($timeInterval = FALSE) {
 387
 388     $dao = new CRM_Core_DAO();
 389     $query = "
 390       SELECT TABLE_NAME as tableName
 391       FROM   INFORMATION_SCHEMA.TABLES
 392       WHERE  TABLE_SCHEMA = %1
 393       AND (
 394         TABLE_NAME LIKE 'civicrm_import_job_%'
 395         OR TABLE_NAME LIKE 'civicrm_report_temp%'
 396         OR TABLE_NAME LIKE 'civicrm_tmp_d%'
 397         )
 398     ";
 399     // NOTE: Cannot find use-cases where "civicrm_report_temp" would be durable. Could probably remove.
 400
 401     if ($timeInterval) {
 402       $query .= " AND CREATE_TIME < DATE_SUB(NOW(), INTERVAL {$timeInterval})";
 403     }
 404
 405     $tableDAO = CRM_Core_DAO::executeQuery($query, [1 => [$dao->database(), 'String']]);
 406     $tables = [];
 407     while ($tableDAO->fetch()) {
 408       $tables[] = $tableDAO->tableName;
 409     }
 410     if (!empty($tables)) {
 411       $table = implode(',', $tables);
 412       // drop leftover temporary tables
 413       CRM_Core_DAO::executeQuery("DROP TABLE $table");
 414     }
 415   }
 416
 417   /**
 418    * Check if running in upgrade mode.
 419    *
 420    * @param string $path
 421    *
 422    * @return bool
 423    */
 424   public static function isUpgradeMode($path = NULL) {
 425     if (defined('CIVICRM_UPGRADE_ACTIVE')) {
 426       return TRUE;
 427     }
 428
 429     if (!$path) {
 430       // note: do not re-initialize config here, since this function is part of
 431       // config initialization itself
 432       $urlVar = 'q';
 433       if (defined('CIVICRM_UF') && CIVICRM_UF == 'Joomla') {
 434         $urlVar = 'task';
 435       }
 436
 437       $path = CRM_Utils_Array::value($urlVar, $_GET);
 438     }
 439
 440     if ($path && preg_match('/^civicrm\/upgrade(\/.*)?$/', $path)) {
 441       return TRUE;
 442     }
 443
 444     if ($path && preg_match('/^civicrm\/ajax\/l10n-js/', $path)
 445       && !empty($_SERVER['HTTP_REFERER'])
 446     ) {
 447       $ref = parse_url($_SERVER['HTTP_REFERER']);
 448       if (
 449         (!empty($ref['path']) && preg_match('/civicrm\/upgrade/', $ref['path'])) ||
 450         (!empty($ref['query']) && preg_match('/civicrm\/upgrade/', urldecode($ref['query'])))
 451       ) {
 452         return TRUE;
 453       }
 454     }
 455
 456     return FALSE;
 457   }
 458
 459   /**
 460    * Is back office credit card processing enabled for this site - ie are there any installed processors that support
 461    * it?
 462    * This function is used for determining whether to show the submit credit card link, not for determining which processors to show, hence
 463    * it is a config var
 464    * @return bool
 465    */
 466   public static function isEnabledBackOfficeCreditCardPayments() {
 467     return CRM_Financial_BAO_PaymentProcessor::hasPaymentProcessorSupporting(['BackOffice']);
 468   }
 469
 470   /**
 471    * @deprecated
 472    */
 473   public function addressSequence() {
 474     CRM_Core_Error::deprecatedFunctionWarning('CRM_Utils_Address::sequence(Civi::settings()->get(\'address_format\')');
 475     return CRM_Utils_Address::sequence(Civi::settings()->get('address_format'));
 476   }
 477
 478   /**
 479    * @deprecated
 480    */
 481   public function defaultContactCountry() {
 482     CRM_Core_Error::deprecatedFunctionWarning('CRM_Core_BAO_Country::defaultContactCountry');
 483     return CRM_Core_BAO_Country::defaultContactCountry();
 484   }
 485
 486   /**
 487    * @deprecated
 488    */
 489   public function defaultContactCountryName() {
 490     CRM_Core_Error::deprecatedFunctionWarning('CRM_Core_BAO_Country::defaultContactCountryName');
 491     return CRM_Core_BAO_Country::defaultContactCountryName();
 492   }
 493
 494   /**
 495    * @deprecated
 496    *
 497    * @param string $defaultCurrency
 498    *
 499    * @return string
 500    */
 501   public function defaultCurrencySymbol($defaultCurrency = NULL) {
 502     CRM_Core_Error::deprecatedFunctionWarning('CRM_Core_BAO_Country::defaultCurrencySymbol');
 503     return CRM_Core_BAO_Country::defaultCurrencySymbol($defaultCurrency);
 504   }
 505
 506   /**
 507    * Resets the singleton, so that the next call to CRM_Core_Config::singleton()
 508    * reloads completely.
 509    *
 510    * While normally we could call the singleton function with $force = TRUE,
 511    * this function addresses a very specific use-case in the CiviCRM installer,
 512    * where we cannot yet force a reload, but we want to make sure that the next
 513    * call to this object gets a fresh start (ex: to initialize the DAO).
 514    */
 515   public function free() {
 516     self::$_singleton = NULL;
 517   }
 518
 519   /**
 520    * Conditionally fire an event during the first page run.
 521    *
 522    * The install system is currently implemented several times, so it's hard to add
 523    * new installation logic. We use a makeshift method to detect the first run.
 524    *
 525    * Situations to test:
 526    *  - New installation
 527    *  - Upgrade from an old version (predating first-run tracker)
 528    *  - Upgrade from an old version (with first-run tracking)
 529    */
 530   public function handleFirstRun() {
 531     // Ordinarily, we prefetch settings en masse and find that the system is already installed.
 532     // No extra SQL queries required.
 533     if (Civi::settings()->get('installed')) {
 534       return;
 535     }
 536
 537     // Q: How should this behave during testing?
 538     if (defined('CIVICRM_TEST')) {
 539       return;
 540     }
 541
 542     // If schema hasn't been loaded yet, then do nothing. Don't want to interfere
 543     // with the existing installers. NOTE: If we change the installer pageflow,
 544     // then we may want to modify this behavior.
 545     if (!CRM_Core_DAO::checkTableExists('civicrm_domain')) {
 546       return;
 547     }
 548
 549     // If we're handling an upgrade, then the system has already been used, so this
 550     // is not the first run.
 551     if (CRM_Core_Config::isUpgradeMode()) {
 552       return;
 553     }
 554     $dao = CRM_Core_DAO::executeQuery('SELECT version FROM civicrm_domain');
 555     while ($dao->fetch()) {
 556       if ($dao->version && version_compare($dao->version, CRM_Utils_System::version(), '<')) {
 557         return;
 558       }
 559     }
 560
 561     // The installation flag is stored in civicrm_setting, which is domain-aware. The
 562     // flag could have been stored under a different domain.
 563     $dao = CRM_Core_DAO::executeQuery('
 564       SELECT domain_id, value FROM civicrm_setting
 565       WHERE is_domain = 1 AND name = "installed"
 566     ');
 567     while ($dao->fetch()) {
 568       $value = unserialize($dao->value);
 569       if (!empty($value)) {
 570         Civi::settings()->set('installed', 1);
 571         return;
 572       }
 573     }
 574
 575     // OK, this looks new.
 576     Civi::service('dispatcher')->dispatch(\Civi\Core\Event\SystemInstallEvent::EVENT_NAME, new \Civi\Core\Event\SystemInstallEvent());
 577     Civi::settings()->set('installed', 1);
 578   }
 579
 580   /**
 581    * Is the system permitted to flush caches at the moment.
 582    */
 583   public static function isPermitCacheFlushMode() {
 584     return !CRM_Core_Config::singleton()->doNotResetCache;
 585   }
 586
 587   /**
 588    * Set cache clearing to enabled or disabled.
 589    *
 590    * This might be enabled at the start of a long running process
 591    * such as an import in order to delay clearing caches until the end.
 592    *
 593    * @param bool $enabled
 594    *   If true then caches can be cleared at this time.
 595    */
 596   public static function setPermitCacheFlushMode($enabled) {
 597     CRM_Core_Config::singleton()->doNotResetCache = $enabled ? 0 : 1;
 598   }
 599
 600 }