CRM/Core/DAO/AllCoreTables.php

   1 <?php
   2
   3 /*
   4  +--------------------------------------------------------------------+
   5  | Copyright CiviCRM LLC. All rights reserved.                        |
   6  |                                                                    |
   7  | This work is published under the GNU AGPLv3 license with some      |
   8  | permitted exceptions and without any warranty. For full license    |
   9  | and copyright information, see https://civicrm.org/licensing       |
  10  +--------------------------------------------------------------------+
  11  */
  12
  13 /**
  14  *
  15  * @package CRM
  16  * @copyright CiviCRM LLC https://civicrm.org/licensing
  17  */
  18 class CRM_Core_DAO_AllCoreTables {
  19
  20   private static $tables = NULL;
  21   private static $daoToClass = NULL;
  22   private static $entityTypes = NULL;
  23
  24   /**
  25    * Initialise.
  26    *
  27    * @param bool $fresh
  28    */
  29   public static function init($fresh = FALSE) {
  30     static $init = FALSE;
  31     if ($init && !$fresh) {
  32       return;
  33     }
  34     Civi::$statics[__CLASS__] = [];
  35
  36     $file = preg_replace('/\.php$/', '.data.php', __FILE__);
  37     $entityTypes = require $file;
  38     CRM_Utils_Hook::entityTypes($entityTypes);
  39
  40     self::$entityTypes = [];
  41     self::$tables = [];
  42     self::$daoToClass = [];
  43     foreach ($entityTypes as $entityType) {
  44       self::registerEntityType(
  45         $entityType['name'],
  46         $entityType['class'],
  47         $entityType['table'],
  48         $entityType['fields_callback'] ?? NULL,
  49         $entityType['links_callback'] ?? NULL
  50       );
  51     }
  52
  53     $init = TRUE;
  54   }
  55
  56   /**
  57    * (Quasi-Private) Do not call externally (except for unit-testing)
  58    *
  59    * @param string $briefName
  60    * @param string $className
  61    * @param string $tableName
  62    * @param string $fields_callback
  63    * @param string $links_callback
  64    */
  65   public static function registerEntityType($briefName, $className, $tableName, $fields_callback = NULL, $links_callback = NULL) {
  66     self::$daoToClass[$briefName] = $className;
  67     self::$tables[$tableName] = $className;
  68     self::$entityTypes[$briefName] = [
  69       'name' => $briefName,
  70       'class' => $className,
  71       'table' => $tableName,
  72       'fields_callback' => $fields_callback,
  73       'links_callback' => $links_callback,
  74     ];
  75   }
  76
  77   /**
  78    * @return array
  79    *   Ex: $result['Contact']['table'] == 'civicrm_contact';
  80    */
  81   public static function get() {
  82     self::init();
  83     return self::$entityTypes;
  84   }
  85
  86   /**
  87    * @return array
  88    *   List of SQL table names.
  89    */
  90   public static function tables() {
  91     self::init();
  92     return self::$tables;
  93   }
  94
  95   /**
  96    * @return array
  97    *   List of indices.
  98    */
  99   public static function indices($localize = TRUE) {
 100     $indices = [];
 101     self::init();
 102     foreach (self::$daoToClass as $class) {
 103       if (is_callable([$class, 'indices'])) {
 104         $indices[$class::getTableName()] = $class::indices($localize);
 105       }
 106     }
 107     return $indices;
 108   }
 109
 110   /**
 111    * Modify indices to account for localization options.
 112    *
 113    * @param string $class DAO class
 114    * @param array $originalIndices index definitions before localization
 115    *
 116    * @return array
 117    *   index definitions after localization
 118    */
 119   public static function multilingualize($class, $originalIndices) {
 120     $locales = CRM_Core_I18n::getMultilingual();
 121     if (!$locales) {
 122       return $originalIndices;
 123     }
 124     $classFields = $class::fields();
 125
 126     $finalIndices = [];
 127     foreach ($originalIndices as $index) {
 128       if ($index['localizable']) {
 129         foreach ($locales as $locale) {
 130           $localIndex = $index;
 131           $localIndex['name'] .= "_" . $locale;
 132           $fields = [];
 133           foreach ($localIndex['field'] as $field) {
 134             $baseField = explode('(', $field);
 135             if ($classFields[$baseField[0]]['localizable']) {
 136               // field name may have eg (3) at end for prefix length
 137               // last_name => last_name_fr_FR
 138               // last_name(3) => last_name_fr_FR(3)
 139               $fields[] = preg_replace('/^([^(]+)(\(\d+\)|)$/', '${1}_' . $locale . '${2}', $field);
 140             }
 141             else {
 142               $fields[] = $field;
 143             }
 144           }
 145           $localIndex['field'] = $fields;
 146           $finalIndices[$localIndex['name']] = $localIndex;
 147         }
 148       }
 149       else {
 150         $finalIndices[$index['name']] = $index;
 151       }
 152     }
 153     CRM_Core_BAO_SchemaHandler::addIndexSignature(self::getTableForClass($class), $finalIndices);
 154     return $finalIndices;
 155   }
 156
 157   /**
 158    * @return array
 159    *   Mapping from brief-names to class-names.
 160    *   Ex: $result['Contact'] == 'CRM_Contact_DAO_Contact'.
 161    */
 162   public static function daoToClass() {
 163     self::init();
 164     return self::$daoToClass;
 165   }
 166
 167   /**
 168    * @return array
 169    *   Mapping from table-names to class-names.
 170    *   Ex: $result['civicrm_contact'] == 'CRM_Contact_DAO_Contact'.
 171    */
 172   public static function getCoreTables() {
 173     return self::tables();
 174   }
 175
 176   /**
 177    * Determine whether $tableName is a core table.
 178    *
 179    * @param string $tableName
 180    * @return bool
 181    */
 182   public static function isCoreTable($tableName) {
 183     return array_key_exists($tableName, self::tables());
 184   }
 185
 186   /**
 187    * Get the DAO for a BAO class.
 188    *
 189    * @param string $baoName
 190    *
 191    * @return string|CRM_Core_DAO
 192    */
 193   public static function getCanonicalClassName($baoName) {
 194     return str_replace('_BAO_', '_DAO_', $baoName);
 195   }
 196
 197   /**
 198    * Get the BAO for a DAO class.
 199    *
 200    * @param string $daoName
 201    *
 202    * @return string|CRM_Core_DAO
 203    */
 204   public static function getBAOClassName($daoName) {
 205     $baoName = str_replace('_DAO_', '_BAO_', $daoName);
 206     return $daoName === $baoName || class_exists($baoName) ? $baoName : $daoName;
 207   }
 208
 209   /**
 210    * Convert possibly underscore separated words to camel case with special handling for 'UF'
 211    * e.g membership_payment returns MembershipPayment
 212    *
 213    * @param string $name
 214    * @param bool $legacyV3
 215    * @return string
 216    */
 217   public static function convertEntityNameToCamel(string $name, $legacyV3 = FALSE): string {
 218     // This map only applies to APIv3
 219     $map = [
 220       'acl' => 'Acl',
 221       'ACL' => 'Acl',
 222       'im' => 'Im',
 223       'IM' => 'Im',
 224     ];
 225     if ($legacyV3 && isset($map[$name])) {
 226       return $map[$name];
 227     }
 228
 229     $fragments = explode('_', $name);
 230     foreach ($fragments as & $fragment) {
 231       $fragment = ucfirst($fragment);
 232       // Special case: UFGroup, UFJoin, UFMatch, UFField (if passed in without underscores)
 233       if (strpos($fragment, 'Uf') === 0 && strlen($name) > 2) {
 234         $fragment = 'UF' . ucfirst(substr($fragment, 2));
 235       }
 236     }
 237     // Special case: UFGroup, UFJoin, UFMatch, UFField (if passed in underscore-separated)
 238     if ($fragments[0] === 'Uf') {
 239       $fragments[0] = 'UF';
 240     }
 241     return implode('', $fragments);
 242   }
 243
 244   /**
 245    * Convert CamelCase to snake_case, with special handling for some entity names.
 246    *
 247    * Eg. Activity returns activity
 248    *     UFGroup returns uf_group
 249    *     OptionValue returns option_value
 250    *
 251    * @param string $name
 252    *
 253    * @return string
 254    */
 255   public static function convertEntityNameToLower(string $name): string {
 256     if ($name === strtolower($name)) {
 257       return $name;
 258     }
 259     if ($name === 'PCP' || $name === 'IM' || $name === 'ACL') {
 260       return strtolower($name);
 261     }
 262     return strtolower(ltrim(str_replace('U_F',
 263       'uf',
 264       // That's CamelCase, beside an odd UFCamel that is expected as uf_camel
 265       preg_replace('/(?=[A-Z])/', '_$0', $name)
 266     ), '_'));
 267   }
 268
 269   /**
 270    * Get a list of all DAO classes.
 271    *
 272    * @return array
 273    *   List of class names.
 274    */
 275   public static function getClasses() {
 276     return array_values(self::daoToClass());
 277   }
 278
 279   /**
 280    * Get a list of all extant BAO classes.
 281    *
 282    * @return array
 283    *   Ex: ['Contact' => 'CRM_Contact_BAO_Contact']
 284    */
 285   public static function getBaoClasses() {
 286     $r = [];
 287     foreach (\CRM_Core_DAO_AllCoreTables::daoToClass() as $entity => $daoClass) {
 288       $baoClass = str_replace('_DAO_', '_BAO_', $daoClass);
 289       if (class_exists($baoClass)) {
 290         $r[$entity] = $baoClass;
 291       }
 292     }
 293     return $r;
 294   }
 295
 296   /**
 297    * Get the classname for the table.
 298    *
 299    * @param string $tableName
 300    * @return string|CRM_Core_DAO|NULL
 301    */
 302   public static function getClassForTable($tableName) {
 303     //CRM-19677: on multilingual setup, trim locale from $tableName to fetch class name
 304     if (CRM_Core_I18n::isMultilingual()) {
 305       global $dbLocale;
 306       $tableName = str_replace($dbLocale, '', $tableName);
 307     }
 308     return CRM_Utils_Array::value($tableName, self::tables());
 309   }
 310
 311   /**
 312    * Given a brief-name, determine the full class-name.
 313    *
 314    * @param string $briefName
 315    *   Ex: 'Contact'.
 316    * @return string|CRM_Core_DAO|NULL
 317    *   Ex: 'CRM_Contact_DAO_Contact'.
 318    */
 319   public static function getFullName($briefName) {
 320     self::init();
 321     return self::$entityTypes[$briefName]['class'] ?? NULL;
 322   }
 323
 324   /**
 325    * Given a full class-name, determine the brief-name.
 326    *
 327    * @param string $className
 328    *   Ex: 'CRM_Contact_DAO_Contact'.
 329    * @return string|NULL
 330    *   Ex: 'Contact'.
 331    */
 332   public static function getBriefName($className) {
 333     $className = self::getCanonicalClassName($className);
 334     return array_search($className, self::daoToClass(), TRUE) ?: NULL;
 335   }
 336
 337   /**
 338    * @param string $className DAO or BAO name
 339    * @return string|FALSE SQL table name
 340    */
 341   public static function getTableForClass($className) {
 342     return array_search(self::getCanonicalClassName($className),
 343       self::tables());
 344   }
 345
 346   /**
 347    * Convert the entity name into a table name.
 348    *
 349    * @param string $briefName
 350    *
 351    * @return FALSE|string
 352    */
 353   public static function getTableForEntityName($briefName) {
 354     self::init();
 355     return self::$entityTypes[$briefName]['table'];
 356   }
 357
 358   /**
 359    * Convert table name to brief entity name.
 360    *
 361    * @param string $tableName
 362    *
 363    * @return FALSE|string
 364    */
 365   public static function getEntityNameForTable(string $tableName) {
 366     self::init();
 367     $matches = CRM_Utils_Array::findAll(self::$entityTypes, ['table' => $tableName]);
 368     return $matches ? $matches[0]['name'] : NULL;
 369   }
 370
 371   /**
 372    * Reinitialise cache.
 373    */
 374   public static function reinitializeCache() {
 375     self::init(TRUE);
 376   }
 377
 378   /**
 379    * (Quasi-Private) Do not call externally. For use by DAOs.
 380    *
 381    * @param string $dao
 382    *   Ex: 'CRM_Core_DAO_Address'.
 383    * @param string $labelName
 384    *   Ex: 'address'.
 385    * @param bool $prefix
 386    * @param array $foreignDAOs
 387    * @return array
 388    */
 389   public static function getExports($dao, $labelName, $prefix, $foreignDAOs) {
 390     // Bug-level compatibility -- or sane behavior?
 391     $cacheKey = $dao . ':export';
 392     // $cacheKey = $dao . ':' . ($prefix ? 'export-prefix' : 'export');
 393
 394     if (!isset(Civi::$statics[__CLASS__][$cacheKey])) {
 395       $exports = [];
 396       $fields = $dao::fields();
 397
 398       foreach ($fields as $name => $field) {
 399         if (!empty($field['export'])) {
 400           if ($prefix) {
 401             $exports[$labelName] = & $fields[$name];
 402           }
 403           else {
 404             $exports[$name] = & $fields[$name];
 405           }
 406         }
 407       }
 408
 409       foreach ($foreignDAOs as $foreignDAO) {
 410         $exports = array_merge($exports, $foreignDAO::export(TRUE));
 411       }
 412
 413       Civi::$statics[__CLASS__][$cacheKey] = $exports;
 414     }
 415     return Civi::$statics[__CLASS__][$cacheKey];
 416   }
 417
 418   /**
 419    * (Quasi-Private) Do not call externally. For use by DAOs.
 420    *
 421    * @param string $dao
 422    *   Ex: 'CRM_Core_DAO_Address'.
 423    * @param string $labelName
 424    *   Ex: 'address'.
 425    * @param bool $prefix
 426    * @param array $foreignDAOs
 427    * @return array
 428    */
 429   public static function getImports($dao, $labelName, $prefix, $foreignDAOs) {
 430     // Bug-level compatibility -- or sane behavior?
 431     $cacheKey = $dao . ':import';
 432     // $cacheKey = $dao . ':' . ($prefix ? 'import-prefix' : 'import');
 433
 434     if (!isset(Civi::$statics[__CLASS__][$cacheKey])) {
 435       $imports = [];
 436       $fields = $dao::fields();
 437
 438       foreach ($fields as $name => $field) {
 439         if (!empty($field['import'])) {
 440           if ($prefix) {
 441             $imports[$labelName] = & $fields[$name];
 442           }
 443           else {
 444             $imports[$name] = & $fields[$name];
 445           }
 446         }
 447       }
 448
 449       foreach ($foreignDAOs as $foreignDAO) {
 450         $imports = array_merge($imports, $foreignDAO::import(TRUE));
 451       }
 452
 453       Civi::$statics[__CLASS__][$cacheKey] = $imports;
 454     }
 455     return Civi::$statics[__CLASS__][$cacheKey];
 456   }
 457
 458   /**
 459    * (Quasi-Private) Do not call externally. For use by DAOs.
 460    *
 461    * Apply any third-party alterations to the `fields()`.
 462    *
 463    * TODO: This function should probably take briefName as the key instead of className
 464    * because the latter is not always unique (e.g. virtual entities)
 465    *
 466    * @param string $className
 467    * @param string $event
 468    * @param mixed $values
 469    */
 470   public static function invoke($className, $event, &$values) {
 471     self::init();
 472     $briefName = self::getBriefName($className);
 473     if (isset(self::$entityTypes[$briefName][$event])) {
 474       foreach (self::$entityTypes[$briefName][$event] as $filter) {
 475         $args = [$className, &$values];
 476         \Civi\Core\Resolver::singleton()->call($filter, $args);
 477       }
 478     }
 479   }
 480
 481 }