CRM/Core/Component.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  * Component stores all the static and dynamic information of the various
  30  * CiviCRM components
  31  *
  32  * @package CRM
  33  * @copyright CiviCRM LLC (c) 2004-2019
  34  * $Id$
  35  *
  36  */
  37 class CRM_Core_Component {
  38
  39   /**
  40    * End part (filename) of the component information class'es name
  41    * that needs to be present in components main directory.
  42    */
  43   const COMPONENT_INFO_CLASS = 'Info';
  44
  45   static $_contactSubTypes = NULL;
  46
  47   /**
  48    * @param bool $force
  49    *
  50    * @return CRM_Core_Component_Info[]
  51    */
  52   private static function &_info($force = FALSE) {
  53     if (!isset(Civi::$statics[__CLASS__]['info'])|| $force) {
  54       Civi::$statics[__CLASS__]['info'] = array();
  55       $c = array();
  56
  57       $config = CRM_Core_Config::singleton();
  58       $c = self::getComponents();
  59
  60       foreach ($c as $name => $comp) {
  61         if (in_array($name, $config->enableComponents)) {
  62           Civi::$statics[__CLASS__]['info'][$name] = $comp;
  63         }
  64       }
  65     }
  66
  67     return Civi::$statics[__CLASS__]['info'];
  68   }
  69
  70   /**
  71    * @param string $name
  72    * @param null $attribute
  73    *
  74    * @return mixed
  75    */
  76   public static function get($name, $attribute = NULL) {
  77     $comp = CRM_Utils_Array::value($name, self::_info());
  78     if ($attribute) {
  79       return CRM_Utils_Array::value($attribute, $comp->info);
  80     }
  81     return $comp;
  82   }
  83
  84   /**
  85    * @param bool $force
  86    *
  87    * @return CRM_Core_Component_Info[]
  88    * @throws Exception
  89    */
  90   public static function &getComponents($force = FALSE) {
  91     if (!isset(Civi::$statics[__CLASS__]['all']) || $force) {
  92       Civi::$statics[__CLASS__]['all'] = array();
  93
  94       $cr = new CRM_Core_DAO_Component();
  95       $cr->find(FALSE);
  96       while ($cr->fetch()) {
  97         $infoClass = $cr->namespace . '_' . self::COMPONENT_INFO_CLASS;
  98         $infoClassFile = str_replace('_', DIRECTORY_SEPARATOR, $infoClass) . '.php';
  99         if (!CRM_Utils_File::isIncludable($infoClassFile)) {
 100           continue;
 101         }
 102         require_once $infoClassFile;
 103         $infoObject = new $infoClass($cr->name, $cr->namespace, $cr->id);
 104         if ($infoObject->info['name'] !== $cr->name) {
 105           CRM_Core_Error::fatal("There is a discrepancy between name in component registry and in info file ({$cr->name}).");
 106         }
 107         Civi::$statics[__CLASS__]['all'][$cr->name] = $infoObject;
 108         unset($infoObject);
 109       }
 110     }
 111
 112     return Civi::$statics[__CLASS__]['all'];
 113   }
 114
 115   /**
 116    * @return array
 117    *   Array(string $name => int $id).
 118    */
 119   public static function &getComponentIDs() {
 120     $componentIDs = array();
 121
 122     $cr = new CRM_Core_DAO_Component();
 123     $cr->find(FALSE);
 124     while ($cr->fetch()) {
 125       $componentIDs[$cr->name] = $cr->id;
 126     }
 127
 128     return $componentIDs;
 129   }
 130
 131
 132   /**
 133    * @param bool $force
 134    *
 135    * @return CRM_Core_Component_Info[]
 136    */
 137   static public function &getEnabledComponents($force = FALSE) {
 138     return self::_info($force);
 139   }
 140
 141   static public function flushEnabledComponents() {
 142     unset(Civi::$statics[__CLASS__]);
 143   }
 144
 145   /**
 146    * @param bool $translated
 147    *
 148    * @return array
 149    */
 150   public static function &getNames($translated = FALSE) {
 151     $allComponents = self::getComponents();
 152
 153     $names = array();
 154     foreach ($allComponents as $name => $comp) {
 155       if ($translated) {
 156         $names[$comp->componentID] = $comp->info['translatedName'];
 157       }
 158       else {
 159         $names[$comp->componentID] = $name;
 160       }
 161     }
 162     return $names;
 163   }
 164
 165   /**
 166    * @param $args
 167    * @param $type
 168    *
 169    * @return bool
 170    */
 171   public static function invoke(&$args, $type) {
 172     $info = self::_info();
 173     $config = CRM_Core_Config::singleton();
 174
 175     $firstArg = CRM_Utils_Array::value(1, $args, '');
 176     $secondArg = CRM_Utils_Array::value(2, $args, '');
 177     foreach ($info as $name => $comp) {
 178       if (in_array($name, $config->enableComponents) &&
 179         (($comp->info['url'] === $firstArg && $type == 'main') ||
 180           ($comp->info['url'] === $secondArg && $type == 'admin')
 181         )
 182       ) {
 183         if ($type == 'main') {
 184           // also set the smarty variables to the current component
 185           $template = CRM_Core_Smarty::singleton();
 186           $template->assign('activeComponent', $name);
 187           if (!empty($comp->info[$name]['formTpl'])) {
 188             $template->assign('formTpl', $comp->info[$name]['formTpl']);
 189           }
 190           if (!empty($comp->info[$name]['css'])) {
 191             $styleSheets = '<style type="text/css">@import url(' . "{$config->resourceBase}css/{$comp->info[$name]['css']});</style>";
 192             CRM_Utils_System::addHTMLHead($styleSheet);
 193           }
 194         }
 195         $inv = $comp->getInvokeObject();
 196         $inv->$type($args);
 197         return TRUE;
 198       }
 199     }
 200     return FALSE;
 201   }
 202
 203   /**
 204    * @return array
 205    */
 206   public static function xmlMenu() {
 207
 208     // lets build the menu for all components
 209     $info = self::getComponents(TRUE);
 210
 211     $files = array();
 212     foreach ($info as $name => $comp) {
 213       $files = array_merge($files,
 214         $comp->menuFiles()
 215       );
 216     }
 217
 218     return $files;
 219   }
 220
 221   /**
 222    * @return array
 223    */
 224   public static function &menu() {
 225     $info = self::_info();
 226     $items = array();
 227     foreach ($info as $name => $comp) {
 228       $mnu = $comp->getMenuObject();
 229
 230       $ret = $mnu->permissioned();
 231       $items = array_merge($items, $ret);
 232
 233       $ret = $mnu->main($task);
 234       $items = array_merge($items, $ret);
 235     }
 236     return $items;
 237   }
 238
 239   /**
 240    * @param string $componentName
 241    *
 242    * @return mixed
 243    */
 244   public static function getComponentID($componentName) {
 245     $info = self::_info();
 246     if (!empty($info[$componentName])) {
 247       return $info[$componentName]->componentID;
 248     }
 249     else {
 250       return;
 251     }
 252   }
 253
 254   /**
 255    * @param int $componentID
 256    *
 257    * @return int|null|string
 258    */
 259   public static function getComponentName($componentID) {
 260     $info = self::_info();
 261
 262     $componentName = NULL;
 263     foreach ($info as $compName => $component) {
 264       if ($component->componentID == $componentID) {
 265         $componentName = $compName;
 266         break;
 267       }
 268     }
 269
 270     return $componentName;
 271   }
 272
 273   /**
 274    * @return array
 275    */
 276   public static function &getQueryFields($checkPermission = TRUE) {
 277     $info = self::_info();
 278     $fields = array();
 279     foreach ($info as $name => $comp) {
 280       if ($comp->usesSearch()) {
 281         $bqr = $comp->getBAOQueryObject();
 282         $flds = $bqr->getFields($checkPermission);
 283         $fields = array_merge($fields, $flds);
 284       }
 285     }
 286     return $fields;
 287   }
 288
 289   /**
 290    * @param $query
 291    * @param string $fnName
 292    */
 293   public static function alterQuery(&$query, $fnName) {
 294     $info = self::_info();
 295
 296     foreach ($info as $name => $comp) {
 297       if ($comp->usesSearch()) {
 298         $bqr = $comp->getBAOQueryObject();
 299         $bqr->$fnName($query);
 300       }
 301     }
 302   }
 303
 304   /**
 305    * @param string $fieldName
 306    * @param $mode
 307    * @param $side
 308    *
 309    * @return null
 310    */
 311   public static function from($fieldName, $mode, $side) {
 312     $info = self::_info();
 313
 314     $from = NULL;
 315     foreach ($info as $name => $comp) {
 316       if ($comp->usesSearch()) {
 317         $bqr = $comp->getBAOQueryObject();
 318         $from = $bqr->from($fieldName, $mode, $side);
 319         if ($from) {
 320           return $from;
 321         }
 322       }
 323     }
 324     return $from;
 325   }
 326
 327   /**
 328    * @param $mode
 329    * @param bool $includeCustomFields
 330    *
 331    * @return null
 332    */
 333   public static function &defaultReturnProperties(
 334     $mode,
 335     $includeCustomFields = TRUE
 336   ) {
 337     $info = self::_info();
 338
 339     $properties = NULL;
 340     foreach ($info as $name => $comp) {
 341       if ($comp->usesSearch()) {
 342         $bqr = $comp->getBAOQueryObject();
 343         $properties = $bqr->defaultReturnProperties($mode, $includeCustomFields);
 344         if ($properties) {
 345           return $properties;
 346         }
 347       }
 348     }
 349     return $properties;
 350   }
 351
 352   /**
 353    * @param CRM_Core_Form $form
 354    */
 355   public static function &buildSearchForm(&$form) {
 356     $info = self::_info();
 357
 358     foreach ($info as $name => $comp) {
 359       if ($comp->usesSearch()) {
 360         $bqr = $comp->getBAOQueryObject();
 361         $bqr->buildSearchForm($form);
 362       }
 363     }
 364   }
 365
 366   /**
 367    * @param $row
 368    * @param int $id
 369    */
 370   public static function searchAction(&$row, $id) {
 371     $info = self::_info();
 372
 373     foreach ($info as $name => $comp) {
 374       if ($comp->usesSearch()) {
 375         $bqr = $comp->getBAOQueryObject();
 376         $bqr->searchAction($row, $id);
 377       }
 378     }
 379   }
 380
 381   /**
 382    * @return array|null
 383    */
 384   public static function &contactSubTypes() {
 385     if (self::$_contactSubTypes == NULL) {
 386       self::$_contactSubTypes = array();
 387     }
 388     return self::$_contactSubTypes;
 389   }
 390
 391
 392   /**
 393    * @param $subType
 394    * @param $op
 395    *
 396    * @return null
 397    */
 398   public static function &contactSubTypeProperties($subType, $op) {
 399     $properties = self::contactSubTypes();
 400     if (array_key_exists($subType, $properties) &&
 401       array_key_exists($op, $properties[$subType])
 402     ) {
 403       return $properties[$subType][$op];
 404     }
 405     return CRM_Core_DAO::$_nullObject;
 406   }
 407
 408   /**
 409    * Handle table dependencies of components.
 410    *
 411    * @param array $tables
 412    *   Array of tables.
 413    *
 414    */
 415   public static function tableNames(&$tables) {
 416     $info = self::_info();
 417
 418     foreach ($info as $name => $comp) {
 419       if ($comp->usesSearch()) {
 420         $bqr = $comp->getBAOQueryObject();
 421         $bqr->tableNames($tables);
 422       }
 423     }
 424   }
 425
 426   /**
 427    * Get components info from info file.
 428    *
 429    * @param string $crmFolderDir
 430    *
 431    * @return array
 432    */
 433   public static function getComponentsFromFile($crmFolderDir) {
 434     $components = array();
 435     //traverse CRM folder and check for Info file
 436     if (is_dir($crmFolderDir) && $dir = opendir($crmFolderDir)) {
 437       while ($subDir = readdir($dir)) {
 438         // skip the extensions diretory since it has an Info.php file also
 439         if ($subDir == 'Extension') {
 440           continue;
 441         }
 442
 443         $infoFile = $crmFolderDir . "/{$subDir}/" . self::COMPONENT_INFO_CLASS . '.php';
 444         if (file_exists($infoFile)) {
 445           $infoClass = 'CRM_' . $subDir . '_' . self::COMPONENT_INFO_CLASS;
 446           require_once str_replace('_', DIRECTORY_SEPARATOR, $infoClass) . '.php';
 447           $infoObject = new $infoClass(NULL, NULL, NULL);
 448           $components[$infoObject->info['name']] = $infoObject;
 449           unset($infoObject);
 450         }
 451       }
 452     }
 453
 454     return $components;
 455   }
 456
 457 }