CRM/Core/PseudoConstant.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 /**
  13  *
  14  * Stores all constants and pseudo constants for CRM application.
  15  *
  16  * examples of constants are "Contact Type" which will always be either
  17  * 'Individual', 'Household', 'Organization'.
  18  *
  19  * pseudo constants are entities from the database whose values rarely
  20  * change. examples are list of countries, states, location types,
  21  * relationship types.
  22  *
  23  * currently we're getting the data from the underlying database. this
  24  * will be reworked to use caching.
  25  *
  26  * Note: All pseudoconstants should be uninitialized or default to NULL.
  27  * This provides greater consistency/predictability after flushing.
  28  *
  29  * @package CRM
  30  * @copyright CiviCRM LLC https://civicrm.org/licensing
  31  */
  32 class CRM_Core_PseudoConstant {
  33
  34   /**
  35    * Static cache for pseudoconstant arrays.
  36    * @var array
  37    */
  38   private static $cache;
  39
  40   /**
  41    * activity type
  42    * @var array
  43    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
  44    */
  45   private static $activityType;
  46
  47   /**
  48    * States, provinces
  49    * @var array
  50    */
  51   private static $stateProvince;
  52
  53   /**
  54    * Counties.
  55    * @var array
  56    */
  57   private static $county;
  58
  59   /**
  60    * States/provinces abbreviations
  61    * @var array
  62    */
  63   private static $stateProvinceAbbreviation = [];
  64
  65   /**
  66    * Country.
  67    * @var array
  68    */
  69   private static $country;
  70
  71   /**
  72    * CountryIsoCode.
  73    * @var array
  74    */
  75   private static $countryIsoCode;
  76
  77   /**
  78    * group
  79    * @var array
  80    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
  81    */
  82   private static $group;
  83
  84   /**
  85    * RelationshipType
  86    * @var array
  87    */
  88   private static $relationshipType = [];
  89
  90   /**
  91    * Civicrm groups that are not smart groups
  92    * @var array
  93    */
  94   private static $staticGroup;
  95
  96   /**
  97    * Currency codes
  98    * @var array
  99    */
 100   private static $currencyCode;
 101
 102   /**
 103    * Payment processor
 104    * @var array
 105    */
 106   private static $paymentProcessor;
 107
 108   /**
 109    * Payment processor types
 110    * @var array
 111    */
 112   private static $paymentProcessorType;
 113
 114   /**
 115    * World Region
 116    * @var array
 117    */
 118   private static $worldRegions;
 119
 120   /**
 121    * activity status
 122    * @var array
 123    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
 124    */
 125   private static $activityStatus;
 126
 127   /**
 128    * Visibility
 129    * @var array
 130    */
 131   private static $visibility;
 132
 133   /**
 134    * Greetings
 135    * @var array
 136    */
 137   private static $greeting;
 138
 139   /**
 140    * Extensions of type module
 141    * @var array
 142    */
 143   private static $extensions;
 144
 145   /**
 146    * Financial Account Type
 147    * @var array
 148    */
 149   private static $accountOptionValues;
 150
 151   /**
 152    * Low-level option getter, rarely accessed directly.
 153    * NOTE: Rather than calling this function directly use CRM_*_BAO_*::buildOptions()
 154    * @see https://docs.civicrm.org/dev/en/latest/framework/pseudoconstant/
 155    *
 156    * NOTE: If someone undertakes a refactoring of this, please consider the use-case of
 157    * the Setting.getoptions API. There is no DAO/field, but it would be nice to use the
 158    * same 'pseudoconstant' struct in *.settings.php. This means loosening the coupling
 159    * between $field lookup and the $pseudoconstant evaluation.
 160    *
 161    * @param string $daoName
 162    * @param string $fieldName
 163    * @param array $params
 164    * - name       string  name of the option group
 165    * - flip       boolean results are return in id => label format if false
 166    *                            if true, the results are reversed
 167    * - grouping   boolean if true, return the value in 'grouping' column (currently unsupported for tables other than option_value)
 168    * - localize   boolean if true, localize the results before returning
 169    * - condition  string|array add condition(s) to the sql query - will be concatenated using 'AND'
 170    * - keyColumn  string the column to use for 'id'
 171    * - labelColumn string the column to use for 'label'
 172    * - orderColumn string the column to use for sorting, defaults to 'weight' column if one exists, else defaults to labelColumn
 173    * - onlyActive boolean return only the action option values
 174    * - fresh      boolean ignore cache entries and go back to DB
 175    * @param string $context : Context string
 176    * @see CRM_Core_DAO::buildOptionsContext
 177    *
 178    * @return array|bool
 179    *   array on success, FALSE on error.
 180    *
 181    */
 182   public static function get($daoName, $fieldName, $params = [], $context = NULL) {
 183     CRM_Core_DAO::buildOptionsContext($context);
 184     $flip = !empty($params['flip']);
 185     // Historically this was 'false' but according to the notes in
 186     // CRM_Core_DAO::buildOptionsContext it should be context dependent.
 187     // timidly changing for 'search' only to fix world_region in search options.
 188     $localizeDefault = in_array($context, ['search']);
 189     // Merge params with defaults
 190     $params += [
 191       'grouping' => FALSE,
 192       'localize' => $localizeDefault,
 193       'onlyActive' => !($context == 'validate' || $context == 'get'),
 194       'fresh' => FALSE,
 195       'context' => $context,
 196     ];
 197     $entity = CRM_Core_DAO_AllCoreTables::getBriefName($daoName);
 198
 199     // Custom fields are not in the schema
 200     if (strpos($fieldName, 'custom_') === 0 && is_numeric($fieldName[7])) {
 201       $customField = new CRM_Core_BAO_CustomField();
 202       $customField->id = (int) substr($fieldName, 7);
 203       $options = $customField->getOptions($context);
 204       if ($options && $flip) {
 205         $options = array_flip($options);
 206       }
 207       return $options;
 208     }
 209
 210     // Core field: load schema
 211     $dao = new $daoName();
 212     $fieldSpec = $dao->getFieldSpec($fieldName);
 213
 214     // Return false if field doesn't exist.
 215     if (empty($fieldSpec)) {
 216       return FALSE;
 217     }
 218
 219     // Ensure we have the canonical name for this field
 220     $fieldName = $fieldSpec['name'] ?? $fieldName;
 221
 222     if (!empty($fieldSpec['pseudoconstant'])) {
 223       $pseudoconstant = $fieldSpec['pseudoconstant'];
 224
 225       // if callback is specified..
 226       if (!empty($pseudoconstant['callback'])) {
 227         $fieldOptions = call_user_func(Civi\Core\Resolver::singleton()->get($pseudoconstant['callback']), $context);
 228         //CRM-18223: Allow additions to field options via hook.
 229         CRM_Utils_Hook::fieldOptions($entity, $fieldName, $fieldOptions, $params);
 230         return $fieldOptions;
 231       }
 232
 233       // Merge params with schema defaults
 234       $params += [
 235         'condition' => $pseudoconstant['condition'] ?? [],
 236         'keyColumn' => $pseudoconstant['keyColumn'] ?? NULL,
 237         'labelColumn' => $pseudoconstant['labelColumn'] ?? NULL,
 238       ];
 239
 240       // Fetch option group from option_value table
 241       if (!empty($pseudoconstant['optionGroupName'])) {
 242         if ($context == 'validate') {
 243           $params['labelColumn'] = 'name';
 244         }
 245         if ($context == 'match') {
 246           $params['keyColumn'] = 'name';
 247         }
 248         // Call our generic fn for retrieving from the option_value table
 249         $options = CRM_Core_OptionGroup::values(
 250           $pseudoconstant['optionGroupName'],
 251           $flip,
 252           $params['grouping'],
 253           $params['localize'],
 254           $params['condition'] ? ' AND ' . implode(' AND ', (array) $params['condition']) : NULL,
 255           $params['labelColumn'] ? $params['labelColumn'] : 'label',
 256           $params['onlyActive'],
 257           $params['fresh'],
 258           $params['keyColumn'] ? $params['keyColumn'] : 'value',
 259           !empty($params['orderColumn']) ? $params['orderColumn'] : 'weight'
 260         );
 261         CRM_Utils_Hook::fieldOptions($entity, $fieldName, $options, $params);
 262         return $options;
 263       }
 264
 265       // Fetch options from other tables
 266       if (!empty($pseudoconstant['table'])) {
 267         CRM_Utils_Array::remove($params, 'flip', 'fresh');
 268         // Normalize params so the serialized cache string will be consistent.
 269         ksort($params);
 270         $cacheKey = $daoName . $fieldName . serialize($params);
 271         // Retrieve cached options
 272         if (isset(\Civi::$statics[__CLASS__][$cacheKey]) && empty($params['fresh'])) {
 273           $output = \Civi::$statics[__CLASS__][$cacheKey];
 274         }
 275         else {
 276           $output = self::renderOptionsFromTablePseudoconstant($pseudoconstant, $params, ($fieldSpec['localize_context'] ?? NULL), $context);
 277           CRM_Utils_Hook::fieldOptions($entity, $fieldName, $output, $params);
 278           \Civi::$statics[__CLASS__][$cacheKey] = $output;
 279         }
 280         return $flip ? array_flip($output) : $output;
 281       }
 282     }
 283
 284     // Return "Yes" and "No" for boolean fields
 285     elseif (CRM_Utils_Array::value('type', $fieldSpec) === CRM_Utils_Type::T_BOOLEAN) {
 286       $output = $context == 'validate' ? [0, 1] : CRM_Core_SelectValues::boolean();
 287       CRM_Utils_Hook::fieldOptions($entity, $fieldName, $output, $params);
 288       return $flip ? array_flip($output) : $output;
 289     }
 290     // If we're still here, it's an error. Return FALSE.
 291     return FALSE;
 292   }
 293
 294   /**
 295    * Fetch the translated label for a field given its key.
 296    *
 297    * @param string $baoName
 298    * @param string $fieldName
 299    * @param string|int $key
 300    *
 301    * TODO: Accept multivalued input?
 302    *
 303    * @return bool|null|string
 304    *   FALSE if the given field has no associated option list
 305    *   NULL if the given key has no corresponding option
 306    *   String if label is found
 307    */
 308   public static function getLabel($baoName, $fieldName, $key) {
 309     $values = $baoName::buildOptions($fieldName, 'get');
 310     if ($values === FALSE) {
 311       return FALSE;
 312     }
 313     return $values[$key] ?? NULL;
 314   }
 315
 316   /**
 317    * Fetch the machine name for a field given its key.
 318    *
 319    * @param string $baoName
 320    * @param string $fieldName
 321    * @param string|int $key
 322    *
 323    * @return bool|null|string
 324    *   FALSE if the given field has no associated option list
 325    *   NULL if the given key has no corresponding option
 326    *   String if label is found
 327    */
 328   public static function getName($baoName, $fieldName, $key) {
 329     $values = $baoName::buildOptions($fieldName, 'validate');
 330     if ($values === FALSE) {
 331       return FALSE;
 332     }
 333     return $values[$key] ?? NULL;
 334   }
 335
 336   /**
 337    * Fetch the key for a field option given its name.
 338    *
 339    * @param string $baoName
 340    * @param string $fieldName
 341    * @param string|int $value
 342    *
 343    * @return bool|null|string|int
 344    *   FALSE if the given field has no associated option list
 345    *   NULL if the given key has no corresponding option
 346    *   String|Number if key is found
 347    */
 348   public static function getKey($baoName, $fieldName, $value) {
 349     $values = $baoName::buildOptions($fieldName, 'validate');
 350     if ($values === FALSE) {
 351       return FALSE;
 352     }
 353     return CRM_Utils_Array::key($value, $values);
 354   }
 355
 356   /**
 357    * Lookup the admin page at which a field's option list can be edited
 358    * @param $fieldSpec
 359    * @return string|null
 360    */
 361   public static function getOptionEditUrl($fieldSpec) {
 362     // If it's an option group, that's easy
 363     if (!empty($fieldSpec['pseudoconstant']['optionGroupName'])) {
 364       return 'civicrm/admin/options/' . $fieldSpec['pseudoconstant']['optionGroupName'];
 365     }
 366     // For everything else...
 367     elseif (!empty($fieldSpec['pseudoconstant']['table'])) {
 368       $daoName = CRM_Core_DAO_AllCoreTables::getClassForTable($fieldSpec['pseudoconstant']['table']);
 369       if (!$daoName) {
 370         return NULL;
 371       }
 372       // We don't have good mapping so have to do a bit of guesswork from the menu
 373       list(, $parent, , $child) = explode('_', $daoName);
 374       $sql = "SELECT path FROM civicrm_menu
 375         WHERE page_callback LIKE '%CRM_Admin_Page_$child%' OR page_callback LIKE '%CRM_{$parent}_Page_$child%'
 376         ORDER BY page_callback
 377         LIMIT 1";
 378       return CRM_Core_DAO::singleValueQuery($sql);
 379     }
 380     return NULL;
 381   }
 382
 383   /**
 384    * @deprecated generic populate method.
 385    * All pseudoconstant functions that use this method are also @deprecated
 386    *
 387    * The static array $var is populated from the db
 388    * using the <b>$name DAO</b>.
 389    *
 390    * Note: any database errors will be trapped by the DAO.
 391    *
 392    * @param array $var
 393    *   The associative array we will fill.
 394    * @param string $name
 395    *   The name of the DAO.
 396    * @param bool $all
 397    *   Get all objects. default is to get only active ones.
 398    * @param string $retrieve
 399    *   The field that we are interested in (normally name, differs in some objects).
 400    * @param string $filter
 401    *   The field that we want to filter the result set with.
 402    * @param string $condition
 403    *   The condition that gets passed to the final query as the WHERE clause.
 404    *
 405    * @param bool $orderby
 406    * @param string $key
 407    * @param bool $force
 408    *
 409    * @return array
 410    */
 411   public static function populate(
 412     &$var,
 413     $name,
 414     $all = FALSE,
 415     $retrieve = 'name',
 416     $filter = 'is_active',
 417     $condition = NULL,
 418     $orderby = NULL,
 419     $key = 'id',
 420     $force = NULL
 421   ) {
 422     $cacheKey = CRM_Utils_Cache::cleanKey("CRM_PC_{$name}_{$all}_{$key}_{$retrieve}_{$filter}_{$condition}_{$orderby}");
 423     $cache = CRM_Utils_Cache::singleton();
 424     $var = $cache->get($cacheKey);
 425     if ($var !== NULL && empty($force)) {
 426       return $var;
 427     }
 428
 429     /* @var CRM_Core_DAO $object */
 430     $object = new $name();
 431
 432     $object->selectAdd();
 433     $object->selectAdd("$key, $retrieve");
 434     if ($condition) {
 435       $object->whereAdd($condition);
 436     }
 437
 438     if (!$orderby) {
 439       $object->orderBy($retrieve);
 440     }
 441     else {
 442       $object->orderBy($orderby);
 443     }
 444
 445     if (!$all) {
 446       $object->$filter = 1;
 447       $aclClauses = array_filter($name::getSelectWhereClause());
 448       foreach ($aclClauses as $clause) {
 449         $object->whereAdd($clause);
 450       }
 451     }
 452
 453     $object->find();
 454     $var = [];
 455     while ($object->fetch()) {
 456       $var[$object->$key] = $object->$retrieve;
 457     }
 458
 459     $cache->set($cacheKey, $var);
 460   }
 461
 462   /**
 463    * Flush given pseudoconstant so it can be reread from db.
 464    * nex time it's requested.
 465    *
 466    * @param bool|string $name pseudoconstant to be flushed
 467    */
 468   public static function flush($name = 'cache') {
 469     if (isset(self::$$name)) {
 470       self::$$name = NULL;
 471     }
 472     if ($name == 'cache') {
 473       CRM_Core_OptionGroup::flushAll();
 474       if (isset(\Civi::$statics[__CLASS__])) {
 475         unset(\Civi::$statics[__CLASS__]);
 476       }
 477     }
 478   }
 479
 480   /**
 481    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
 482    *
 483    * Get all Activty types.
 484    *
 485    * The static array activityType is returned
 486    *
 487    *
 488    * @return array
 489    *   array reference of all activity types.
 490    */
 491   public static function &activityType() {
 492     $args = func_get_args();
 493     $all = CRM_Utils_Array::value(0, $args, TRUE);
 494     $includeCaseActivities = CRM_Utils_Array::value(1, $args, FALSE);
 495     $reset = CRM_Utils_Array::value(2, $args, FALSE);
 496     $returnColumn = CRM_Utils_Array::value(3, $args, 'label');
 497     $includeCampaignActivities = CRM_Utils_Array::value(4, $args, FALSE);
 498     $onlyComponentActivities = CRM_Utils_Array::value(5, $args, FALSE);
 499     $index = (int) $all . '_' . $returnColumn . '_' . (int) $includeCaseActivities;
 500     $index .= '_' . (int) $includeCampaignActivities;
 501     $index .= '_' . (int) $onlyComponentActivities;
 502
 503     if (NULL === self::$activityType) {
 504       self::$activityType = [];
 505     }
 506
 507     if (!isset(self::$activityType[$index]) || $reset) {
 508       $condition = NULL;
 509       if (!$all) {
 510         $condition = 'AND filter = 0';
 511       }
 512       $componentClause = " v.component_id IS NULL";
 513       if ($onlyComponentActivities) {
 514         $componentClause = " v.component_id IS NOT NULL";
 515       }
 516
 517       $componentIds = [];
 518       $compInfo = CRM_Core_Component::getEnabledComponents();
 519
 520       // build filter for listing activity types only if their
 521       // respective components are enabled
 522       foreach ($compInfo as $compName => $compObj) {
 523         if ($compName == 'CiviCase') {
 524           if ($includeCaseActivities) {
 525             $componentIds[] = $compObj->componentID;
 526           }
 527         }
 528         elseif ($compName == 'CiviCampaign') {
 529           if ($includeCampaignActivities) {
 530             $componentIds[] = $compObj->componentID;
 531           }
 532         }
 533         else {
 534           $componentIds[] = $compObj->componentID;
 535         }
 536       }
 537
 538       if (count($componentIds)) {
 539         $componentIds = implode(',', $componentIds);
 540         $componentClause = " ($componentClause OR v.component_id IN ($componentIds))";
 541         if ($onlyComponentActivities) {
 542           $componentClause = " ( v.component_id IN ($componentIds ) )";
 543         }
 544       }
 545       $condition = $condition . ' AND ' . $componentClause;
 546
 547       self::$activityType[$index] = CRM_Core_OptionGroup::values('activity_type', FALSE, FALSE, FALSE, $condition, $returnColumn);
 548     }
 549     return self::$activityType[$index];
 550   }
 551
 552   /**
 553    * Get all the State/Province from database.
 554    *
 555    * The static array stateProvince is returned, and if it's
 556    * called the first time, the <b>State Province DAO</b> is used
 557    * to get all the States.
 558    *
 559    * Note: any database errors will be trapped by the DAO.
 560    *
 561    *
 562    * @param bool|int $id - Optional id to return
 563    *
 564    * @param bool $limit
 565    *
 566    * @return array
 567    *   array reference of all State/Provinces.
 568    */
 569   public static function &stateProvince($id = FALSE, $limit = TRUE) {
 570     if (($id && empty(self::$stateProvince[$id])) || !self::$stateProvince || !$id) {
 571       $whereClause = FALSE;
 572       if ($limit) {
 573         $countryIsoCodes = self::countryIsoCode();
 574         $limitCodes = CRM_Core_BAO_Country::provinceLimit();
 575         $limitIds = [];
 576         foreach ($limitCodes as $code) {
 577           $limitIds = array_merge($limitIds, array_keys($countryIsoCodes, $code));
 578         }
 579         if (!empty($limitIds)) {
 580           $whereClause = 'country_id IN (' . implode(', ', $limitIds) . ')';
 581         }
 582         else {
 583           $whereClause = FALSE;
 584         }
 585       }
 586       self::populate(self::$stateProvince, 'CRM_Core_DAO_StateProvince', TRUE, 'name', 'is_active', $whereClause);
 587
 588       // localise the province names if in an non-en_US locale
 589       $tsLocale = CRM_Core_I18n::getLocale();
 590       if ($tsLocale != '' and $tsLocale != 'en_US') {
 591         $i18n = CRM_Core_I18n::singleton();
 592         $i18n->localizeArray(self::$stateProvince, [
 593           'context' => 'province',
 594         ]);
 595         self::$stateProvince = CRM_Utils_Array::asort(self::$stateProvince);
 596       }
 597     }
 598     if ($id) {
 599       if (array_key_exists($id, self::$stateProvince)) {
 600         return self::$stateProvince[$id];
 601       }
 602       else {
 603         $result = NULL;
 604         return $result;
 605       }
 606     }
 607     return self::$stateProvince;
 608   }
 609
 610   /**
 611    * Get all the State/Province abbreviations from the database.
 612    *
 613    * Same as above, except gets the abbreviations instead of the names.
 614    *
 615    *
 616    * @param bool|int $id - Optional id to return
 617    *
 618    * @param bool $limit
 619    *
 620    * @return array
 621    *   array reference of all State/Province abbreviations.
 622    */
 623   public static function stateProvinceAbbreviation($id = FALSE, $limit = TRUE) {
 624     if ($id && is_numeric($id)) {
 625       if (!array_key_exists($id, (array) self::$stateProvinceAbbreviation)) {
 626         $query = "SELECT abbreviation
 627 FROM   civicrm_state_province
 628 WHERE  id = %1";
 629         $params = [
 630           1 => [
 631             $id,
 632             'Integer',
 633           ],
 634         ];
 635         self::$stateProvinceAbbreviation[$id] = CRM_Core_DAO::singleValueQuery($query, $params);
 636       }
 637       return self::$stateProvinceAbbreviation[$id];
 638     }
 639     else {
 640       $whereClause = FALSE;
 641
 642       if ($limit) {
 643         $countryIsoCodes = self::countryIsoCode();
 644         $limitCodes = CRM_Core_BAO_Country::provinceLimit();
 645         $limitIds = [];
 646         foreach ($limitCodes as $code) {
 647           $tmpArray = array_keys($countryIsoCodes, $code);
 648
 649           if (!empty($tmpArray)) {
 650             $limitIds[] = array_shift($tmpArray);
 651           }
 652         }
 653         if (!empty($limitIds)) {
 654           $whereClause = 'country_id IN (' . implode(', ', $limitIds) . ')';
 655         }
 656       }
 657       self::populate(self::$stateProvinceAbbreviation, 'CRM_Core_DAO_StateProvince', TRUE, 'abbreviation', 'is_active', $whereClause);
 658     }
 659
 660     return self::$stateProvinceAbbreviation;
 661   }
 662
 663   /**
 664    * Get all the State/Province abbreviations from the database for the specified country.
 665    *
 666    * @param int $countryID
 667    *
 668    * @return array
 669    *   array of all State/Province abbreviations for the given country.
 670    */
 671   public static function stateProvinceAbbreviationForCountry($countryID) {
 672     if (!isset(\Civi::$statics[__CLASS__]['stateProvinceAbbreviationForCountry'][$countryID])) {
 673       \Civi::$statics[__CLASS__]['stateProvinceAbbreviationForCountry'][$countryID] = [];
 674     }
 675     self::populate(\Civi::$statics[__CLASS__]['stateProvinceAbbreviationForCountry'][$countryID], 'CRM_Core_DAO_StateProvince', TRUE, 'abbreviation', 'is_active', "country_id = " . (int) $countryID, 'abbreviation');
 676     return \Civi::$statics[__CLASS__]['stateProvinceAbbreviationForCountry'][$countryID];
 677   }
 678
 679   /**
 680    * Get all the State/Province abbreviations from the database for the default country.
 681    *
 682    * @return array
 683    *   array of all State/Province abbreviations for the given country.
 684    */
 685   public static function stateProvinceAbbreviationForDefaultCountry() {
 686     return CRM_Core_PseudoConstant::stateProvinceAbbreviationForCountry(Civi::settings()->get('defaultContactCountry'));
 687   }
 688
 689   /**
 690    * Get all the countries from database.
 691    *
 692    * The static array country is returned, and if it's
 693    * called the first time, the <b>Country DAO</b> is used
 694    * to get all the countries.
 695    *
 696    * Note: any database errors will be trapped by the DAO.
 697    *
 698    *
 699    * @param bool|int $id - Optional id to return
 700    *
 701    * @param bool $applyLimit
 702    *
 703    * @return array|null
 704    *   array reference of all countries.
 705    */
 706   public static function country($id = FALSE, $applyLimit = TRUE) {
 707     if (($id && empty(self::$country[$id])) || !self::$country || !$id) {
 708
 709       $config = CRM_Core_Config::singleton();
 710       $limitCodes = [];
 711
 712       if ($applyLimit) {
 713         // limit the country list to the countries specified in CIVICRM_COUNTRY_LIMIT
 714         // (ensuring it's a subset of the legal values)
 715         // K/P: We need to fix this, i dont think it works with new setting files
 716         $limitCodes = CRM_Core_BAO_Country::countryLimit();
 717         if (!is_array($limitCodes)) {
 718           $limitCodes = [
 719             $config->countryLimit => 1,
 720           ];
 721         }
 722
 723         $limitCodes = array_intersect(self::countryIsoCode(), $limitCodes);
 724       }
 725
 726       if (count($limitCodes)) {
 727         $whereClause = "iso_code IN ('" . implode("', '", $limitCodes) . "')";
 728       }
 729       else {
 730         $whereClause = NULL;
 731       }
 732
 733       self::populate(self::$country, 'CRM_Core_DAO_Country', TRUE, 'name', 'is_active', $whereClause);
 734
 735       // if default country is set, percolate it to the top
 736       if (CRM_Core_BAO_Country::defaultContactCountry()) {
 737         $countryIsoCodes = self::countryIsoCode();
 738         $defaultID = array_search(CRM_Core_BAO_Country::defaultContactCountry(), $countryIsoCodes);
 739         if ($defaultID !== FALSE) {
 740           $default[$defaultID] = self::$country[$defaultID] ?? NULL;
 741           self::$country = $default + self::$country;
 742         }
 743       }
 744
 745       // localise the country names if in an non-en_US locale
 746       $tsLocale = CRM_Core_I18n::getLocale();
 747       if ($tsLocale != '' and $tsLocale != 'en_US') {
 748         $i18n = CRM_Core_I18n::singleton();
 749         $i18n->localizeArray(self::$country, [
 750           'context' => 'country',
 751         ]);
 752         self::$country = CRM_Utils_Array::asort(self::$country);
 753       }
 754     }
 755     if ($id) {
 756       if (array_key_exists($id, self::$country)) {
 757         return self::$country[$id];
 758       }
 759       else {
 760         return NULL;
 761       }
 762     }
 763     return self::$country;
 764   }
 765
 766   /**
 767    * Get all the country ISO Code abbreviations from the database.
 768    *
 769    * The static array countryIsoCode is returned, and if it's
 770    * called the first time, the <b>Country DAO</b> is used
 771    * to get all the countries' ISO codes.
 772    *
 773    * Note: any database errors will be trapped by the DAO.
 774    *
 775    *
 776    * @param bool $id
 777    *
 778    * @return array
 779    *   array reference of all country ISO codes.
 780    */
 781   public static function &countryIsoCode($id = FALSE) {
 782     if (!self::$countryIsoCode) {
 783       self::populate(self::$countryIsoCode, 'CRM_Core_DAO_Country', TRUE, 'iso_code');
 784     }
 785     if ($id) {
 786       if (array_key_exists($id, self::$countryIsoCode)) {
 787         return self::$countryIsoCode[$id];
 788       }
 789       else {
 790         return CRM_Core_DAO::$_nullObject;
 791       }
 792     }
 793     return self::$countryIsoCode;
 794   }
 795
 796   /**
 797    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
 798    *
 799    * Get all groups from database
 800    *
 801    * The static array group is returned, and if it's
 802    * called the first time, the <b>Group DAO</b> is used
 803    * to get all the groups.
 804    *
 805    * Note: any database errors will be trapped by the DAO.
 806    *
 807    * @param string $groupType
 808    *   Type of group(Access/Mailing).
 809    * @param bool $excludeHidden
 810    *   Exclude hidden groups.
 811    *
 812    *
 813    * @return array
 814    *   array reference of all groups.
 815    */
 816   public static function allGroup($groupType = NULL, $excludeHidden = TRUE) {
 817     if ($groupType === 'validate') {
 818       // validate gets passed through from getoptions. Handle in the deprecated
 819       // fn rather than change the new pattern.
 820       $groupType = NULL;
 821     }
 822     $condition = CRM_Contact_BAO_Group::groupTypeCondition($groupType, $excludeHidden);
 823     $groupKey = ($groupType ? $groupType : 'null') . !empty($excludeHidden);
 824
 825     if (!isset(Civi::$statics[__CLASS__]['groups']['allGroup'][$groupKey])) {
 826       self::populate(Civi::$statics[__CLASS__]['groups']['allGroup'][$groupKey], 'CRM_Contact_DAO_Group', FALSE, 'title', 'is_active', $condition);
 827     }
 828     return Civi::$statics[__CLASS__]['groups']['allGroup'][$groupKey];
 829   }
 830
 831   /**
 832    * Get all permissioned groups from database.
 833    *
 834    * The static array group is returned, and if it's
 835    * called the first time, the <b>Group DAO</b> is used
 836    * to get all the groups.
 837    *
 838    * Note: any database errors will be trapped by the DAO.
 839    *
 840    * @param string $groupType
 841    *   Type of group(Access/Mailing).
 842    * @param bool $excludeHidden
 843    *   Exclude hidden groups.
 844    *
 845    *
 846    * @return array
 847    *   array reference of all groups.
 848    */
 849   public static function group($groupType = NULL, $excludeHidden = TRUE) {
 850     return CRM_Core_Permission::group($groupType, $excludeHidden);
 851   }
 852
 853   /**
 854    * Fetch groups in a nested format suitable for use in select form element.
 855    * @param bool $checkPermissions
 856    * @param string|null $groupType
 857    * @param bool $excludeHidden
 858    * @return array
 859    */
 860   public static function nestedGroup(bool $checkPermissions = TRUE, $groupType = NULL, bool $excludeHidden = TRUE) {
 861     $groups = $checkPermissions ? self::group($groupType, $excludeHidden) : self::allGroup($groupType, $excludeHidden);
 862     return CRM_Contact_BAO_Group::getGroupsHierarchy($groups, NULL, '&nbsp;&nbsp;', TRUE);
 863   }
 864
 865   /**
 866    * Get all permissioned groups from database.
 867    *
 868    * The static array group is returned, and if it's
 869    * called the first time, the <b>Group DAO</b> is used
 870    * to get all the groups.
 871    *
 872    * Note: any database errors will be trapped by the DAO.
 873    *
 874    *
 875    * @param bool $onlyPublic
 876    * @param null $groupType
 877    * @param bool $excludeHidden
 878    *
 879    * @return array
 880    *   array reference of all groups.
 881    */
 882   public static function &staticGroup($onlyPublic = FALSE, $groupType = NULL, $excludeHidden = TRUE) {
 883     if (!self::$staticGroup) {
 884       $condition = 'saved_search_id = 0 OR saved_search_id IS NULL';
 885       if ($onlyPublic) {
 886         $condition .= " AND visibility != 'User and User Admin Only'";
 887       }
 888
 889       if ($groupType) {
 890         $condition .= ' AND ' . CRM_Contact_BAO_Group::groupTypeCondition($groupType);
 891       }
 892
 893       if ($excludeHidden) {
 894         $condition .= ' AND is_hidden != 1 ';
 895       }
 896
 897       self::populate(self::$staticGroup, 'CRM_Contact_DAO_Group', FALSE, 'title', 'is_active', $condition, 'title');
 898     }
 899
 900     return self::$staticGroup;
 901   }
 902
 903   /**
 904    * Get all Relationship Types  from database.
 905    *
 906    * The static array group is returned, and if it's
 907    * called the first time, the <b>RelationshipType DAO</b> is used
 908    * to get all the relationship types.
 909    *
 910    * Note: any database errors will be trapped by the DAO.
 911    *
 912    * @param string $valueColumnName
 913    *   Db column name/label.
 914    * @param bool $reset
 915    *   Reset relationship types if true.
 916    * @param bool $isActive
 917    *   Filter by is_active. NULL to disable.
 918    *
 919    * @return array
 920    *   array reference of all relationship types.
 921    */
 922   public static function relationshipType($valueColumnName = 'label', $reset = FALSE, $isActive = 1) {
 923     $cacheKey = $valueColumnName . '::' . $isActive;
 924     if (!isset(self::$relationshipType[$cacheKey]) || $reset) {
 925       self::$relationshipType[$cacheKey] = [];
 926
 927       //now we have name/label columns CRM-3336
 928       $column_a_b = "{$valueColumnName}_a_b";
 929       $column_b_a = "{$valueColumnName}_b_a";
 930
 931       $relationshipTypeDAO = new CRM_Contact_DAO_RelationshipType();
 932       $relationshipTypeDAO->selectAdd();
 933       $relationshipTypeDAO->selectAdd("id, {$column_a_b}, {$column_b_a}, contact_type_a, contact_type_b, contact_sub_type_a, contact_sub_type_b");
 934       if ($isActive !== NULL) {
 935         $relationshipTypeDAO->is_active = $isActive;
 936       }
 937       $relationshipTypeDAO->find();
 938       while ($relationshipTypeDAO->fetch()) {
 939
 940         self::$relationshipType[$cacheKey][$relationshipTypeDAO->id] = [
 941           'id' => $relationshipTypeDAO->id,
 942           $column_a_b => $relationshipTypeDAO->$column_a_b,
 943           $column_b_a => $relationshipTypeDAO->$column_b_a,
 944           'contact_type_a' => "$relationshipTypeDAO->contact_type_a",
 945           'contact_type_b' => "$relationshipTypeDAO->contact_type_b",
 946           'contact_sub_type_a' => "$relationshipTypeDAO->contact_sub_type_a",
 947           'contact_sub_type_b' => "$relationshipTypeDAO->contact_sub_type_b",
 948         ];
 949       }
 950     }
 951
 952     return self::$relationshipType[$cacheKey];
 953   }
 954
 955   /**
 956    * Name => Label pairs for all relationship types
 957    *
 958    * @return array
 959    */
 960   public static function relationshipTypeOptions() {
 961     $relationshipTypes = [];
 962     $relationshipLabels = self::relationshipType();
 963     foreach (self::relationshipType('name') as $id => $type) {
 964       $relationshipTypes[$type['name_a_b']] = $relationshipLabels[$id]['label_a_b'];
 965       if ($type['name_b_a'] && $type['name_b_a'] != $type['name_a_b']) {
 966         $relationshipTypes[$type['name_b_a']] = $relationshipLabels[$id]['label_b_a'];
 967       }
 968     }
 969     return $relationshipTypes;
 970   }
 971
 972   /**
 973    * Get all the ISO 4217 currency codes
 974    *
 975    * so far, we use this for validation only, so there's no point of putting this into the database
 976    *
 977    *
 978    * @return array
 979    *   array reference of all currency codes
 980    */
 981   public static function &currencyCode() {
 982     if (!self::$currencyCode) {
 983
 984       $query = "SELECT name FROM civicrm_currency";
 985       $dao = CRM_Core_DAO::executeQuery($query);
 986       $currencyCode = [];
 987       while ($dao->fetch()) {
 988         self::$currencyCode[] = $dao->name;
 989       }
 990     }
 991     return self::$currencyCode;
 992   }
 993
 994   /**
 995    * Get all the County from database.
 996    *
 997    * The static array county is returned, and if it's
 998    * called the first time, the <b>County DAO</b> is used
 999    * to get all the Counties.
1000    *
1001    * Note: any database errors will be trapped by the DAO.
1002    *
1003    *
1004    * @param bool|int $id - Optional id to return
1005    *
1006    * @return array
1007    *   array reference of all Counties
1008    */
1009   public static function &county($id = FALSE) {
1010     if (!self::$county) {
1011
1012       $config = CRM_Core_Config::singleton();
1013       // order by id so users who populate civicrm_county can have more control over sort by the order they load the counties
1014       self::populate(self::$county, 'CRM_Core_DAO_County', TRUE, 'name', NULL, NULL, 'id');
1015     }
1016     if ($id) {
1017       if (array_key_exists($id, self::$county)) {
1018         return self::$county[$id];
1019       }
1020       else {
1021         return CRM_Core_DAO::$_nullObject;
1022       }
1023     }
1024     return self::$county;
1025   }
1026
1027   /**
1028    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
1029    * Get all active payment processors
1030    *
1031    * The static array paymentProcessor is returned
1032    *
1033    *
1034    * @param bool $all
1035    *   Get payment processors - default is to get only active ones.
1036    * @param bool $test
1037    *   Get test payment processors.
1038    *
1039    * @param null $additionalCond
1040    *
1041    * @return array
1042    *   array of all payment processors
1043    */
1044   public static function paymentProcessor($all = FALSE, $test = FALSE, $additionalCond = NULL) {
1045     $condition = "is_test = ";
1046     $condition .= ($test) ? '1' : '0';
1047
1048     if ($additionalCond) {
1049       $condition .= " AND ( $additionalCond ) ";
1050     }
1051
1052     // CRM-7178. Make sure we only include payment processors valid in this
1053     // domain
1054     $condition .= " AND domain_id = " . CRM_Core_Config::domainID();
1055
1056     $cacheKey = $condition . '_' . (int) $all;
1057     if (!isset(self::$paymentProcessor[$cacheKey])) {
1058       self::populate(self::$paymentProcessor[$cacheKey], 'CRM_Financial_DAO_PaymentProcessor', $all, 'name', 'is_active', $condition, 'is_default desc, name');
1059     }
1060
1061     return self::$paymentProcessor[$cacheKey];
1062   }
1063
1064   /**
1065    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
1066    *
1067    * The static array paymentProcessorType is returned
1068    *
1069    *
1070    * @param bool $all
1071    *   Get payment processors - default is to get only active ones.
1072    *
1073    * @param int $id
1074    * @param string $return
1075    *
1076    * @return array
1077    *   array of all payment processor types
1078    */
1079   public static function &paymentProcessorType($all = FALSE, $id = NULL, $return = 'title') {
1080     $cacheKey = $id . '_' . $return;
1081     if (empty(self::$paymentProcessorType[$cacheKey])) {
1082       self::populate(self::$paymentProcessorType[$cacheKey], 'CRM_Financial_DAO_PaymentProcessorType', $all, $return, 'is_active', NULL, "is_default, $return", 'id');
1083     }
1084     if ($id && !empty(self::$paymentProcessorType[$cacheKey][$id])) {
1085       return self::$paymentProcessorType[$cacheKey][$id];
1086     }
1087     return self::$paymentProcessorType[$cacheKey];
1088   }
1089
1090   /**
1091    * Get all the World Regions from Database.
1092    *
1093    *
1094    * @param bool $id
1095    *
1096    * @return array
1097    *   array reference of all World Regions
1098    */
1099   public static function &worldRegion($id = FALSE) {
1100     if (!self::$worldRegions) {
1101       self::populate(self::$worldRegions, 'CRM_Core_DAO_Worldregion', TRUE, 'name', NULL, NULL, 'id');
1102     }
1103
1104     if ($id) {
1105       if (array_key_exists($id, self::$worldRegions)) {
1106         return self::$worldRegions[$id];
1107       }
1108       else {
1109         return CRM_Core_DAO::$_nullObject;
1110       }
1111     }
1112
1113     return self::$worldRegions;
1114   }
1115
1116   /**
1117    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
1118    *
1119    * Get all Activity Statuses.
1120    *
1121    * The static array activityStatus is returned
1122    *
1123    *
1124    * @param string $column
1125    *
1126    * @return array
1127    *   array reference of all activity statuses
1128    */
1129   public static function &activityStatus($column = 'label') {
1130     if (NULL === self::$activityStatus) {
1131       self::$activityStatus = [];
1132     }
1133     if (!array_key_exists($column, self::$activityStatus)) {
1134       self::$activityStatus[$column] = [];
1135
1136       self::$activityStatus[$column] = CRM_Core_OptionGroup::values('activity_status', FALSE, FALSE, FALSE, NULL, $column);
1137     }
1138
1139     return self::$activityStatus[$column];
1140   }
1141
1142   /**
1143    * @deprecated Please use the buildOptions() method in the appropriate BAO object.
1144    *
1145    * Get all Visibility levels.
1146    *
1147    * The static array visibility is returned
1148    *
1149    *
1150    * @param string $column
1151    *
1152    * @return array
1153    *   array reference of all Visibility levels.
1154    */
1155   public static function &visibility($column = 'label') {
1156     if (!isset(self::$visibility)) {
1157       self::$visibility = [];
1158     }
1159
1160     if (!isset(self::$visibility[$column])) {
1161       self::$visibility[$column] = CRM_Core_OptionGroup::values('visibility', FALSE, FALSE, FALSE, NULL, $column);
1162     }
1163
1164     return self::$visibility[$column];
1165   }
1166
1167   /**
1168    * @param int $countryID
1169    * @param string $field
1170    *
1171    * @return array
1172    */
1173   public static function &stateProvinceForCountry($countryID, $field = 'name') {
1174     static $_cache = NULL;
1175
1176     $cacheKey = "{$countryID}_{$field}";
1177     if (!$_cache) {
1178       $_cache = [];
1179     }
1180
1181     if (!empty($_cache[$cacheKey])) {
1182       return $_cache[$cacheKey];
1183     }
1184
1185     $query = "
1186 SELECT civicrm_state_province.{$field} name, civicrm_state_province.id id
1187   FROM civicrm_state_province
1188 WHERE country_id = %1
1189 ORDER BY name";
1190     $params = [
1191       1 => [
1192         $countryID,
1193         'Integer',
1194       ],
1195     ];
1196
1197     $dao = CRM_Core_DAO::executeQuery($query, $params);
1198
1199     $result = [];
1200     while ($dao->fetch()) {
1201       $result[$dao->id] = $dao->name;
1202     }
1203
1204     // localise the stateProvince names if in an non-en_US locale
1205     $config = CRM_Core_Config::singleton();
1206     $tsLocale = CRM_Core_I18n::getLocale();
1207     if ($tsLocale != '' and $tsLocale != 'en_US') {
1208       $i18n = CRM_Core_I18n::singleton();
1209       $i18n->localizeArray($result, [
1210         'context' => 'province',
1211       ]);
1212       $result = CRM_Utils_Array::asort($result);
1213     }
1214
1215     $_cache[$cacheKey] = $result;
1216
1217     CRM_Utils_Hook::buildStateProvinceForCountry($countryID, $result);
1218
1219     return $result;
1220   }
1221
1222   /**
1223    * @param int $stateID
1224    *
1225    * @return array
1226    */
1227   public static function &countyForState($stateID) {
1228     if (is_array($stateID)) {
1229       $states = implode(", ", $stateID);
1230       $query = "
1231     SELECT civicrm_county.name name, civicrm_county.id id, civicrm_state_province.abbreviation abbreviation
1232       FROM civicrm_county
1233       LEFT JOIN civicrm_state_province ON civicrm_county.state_province_id = civicrm_state_province.id
1234     WHERE civicrm_county.state_province_id in ( $states )
1235     ORDER BY civicrm_state_province.abbreviation, civicrm_county.name";
1236
1237       $dao = CRM_Core_DAO::executeQuery($query);
1238
1239       $result = [];
1240       while ($dao->fetch()) {
1241         $result[$dao->id] = $dao->abbreviation . ': ' . $dao->name;
1242       }
1243     }
1244     else {
1245
1246       static $_cache = NULL;
1247
1248       $cacheKey = "{$stateID}_name";
1249       if (!$_cache) {
1250         $_cache = [];
1251       }
1252
1253       if (!empty($_cache[$cacheKey])) {
1254         return $_cache[$cacheKey];
1255       }
1256
1257       $query = "
1258     SELECT civicrm_county.name name, civicrm_county.id id
1259       FROM civicrm_county
1260     WHERE state_province_id = %1
1261     ORDER BY name";
1262       $params = [
1263         1 => [
1264           $stateID,
1265           'Integer',
1266         ],
1267       ];
1268
1269       $dao = CRM_Core_DAO::executeQuery($query, $params);
1270
1271       $result = [];
1272       while ($dao->fetch()) {
1273         $result[$dao->id] = $dao->name;
1274       }
1275     }
1276
1277     return $result;
1278   }
1279
1280   /**
1281    * Given a state ID return the country ID, this allows
1282    * us to populate forms and values for downstream code
1283    *
1284    * @param int $stateID
1285    *
1286    * @return int|null
1287    *   the country id that the state belongs to
1288    */
1289   public static function countryIDForStateID($stateID) {
1290     if (empty($stateID)) {
1291       return NULL;
1292     }
1293
1294     $query = "
1295 SELECT country_id
1296 FROM   civicrm_state_province
1297 WHERE  id = %1
1298 ";
1299     $params = [1 => [$stateID, 'Integer']];
1300
1301     return CRM_Core_DAO::singleValueQuery($query, $params);
1302   }
1303
1304   /**
1305    * Get all types of Greetings.
1306    *
1307    * The static array of greeting is returned
1308    *
1309    *
1310    * @param $filter
1311    *   Get All Email Greetings - default is to get only active ones.
1312    *
1313    * @param string $columnName
1314    *
1315    * @return array
1316    *   array reference of all greetings.
1317    */
1318   public static function greeting($filter, $columnName = 'label') {
1319     if (!isset(Civi::$statics[__CLASS__]['greeting'])) {
1320       Civi::$statics[__CLASS__]['greeting'] = [];
1321     }
1322
1323     $index = $filter['greeting_type'] . '_' . $columnName;
1324
1325     // also add contactType to the array
1326     $contactType = $filter['contact_type'] ?? NULL;
1327     if ($contactType) {
1328       $index .= '_' . $contactType;
1329     }
1330
1331     if (empty(Civi::$statics[__CLASS__]['greeting'][$index])) {
1332       $filterCondition = NULL;
1333       if ($contactType) {
1334         $filterVal = 'v.filter =';
1335         switch ($contactType) {
1336           case 'Individual':
1337             $filterVal .= "1";
1338             break;
1339
1340           case 'Household':
1341             $filterVal .= "2";
1342             break;
1343
1344           case 'Organization':
1345             $filterVal .= "3";
1346             break;
1347         }
1348         $filterCondition .= "AND (v.filter = 0 OR {$filterVal}) ";
1349       }
1350
1351       Civi::$statics[__CLASS__]['greeting'][$index] = CRM_Core_OptionGroup::values($filter['greeting_type'], NULL, NULL, NULL, $filterCondition, $columnName);
1352     }
1353
1354     return Civi::$statics[__CLASS__]['greeting'][$index];
1355   }
1356
1357   /**
1358    * Get all extensions.
1359    *
1360    * The static array extensions
1361    *
1362    * FIXME: This is called by civix but not by any core code. We
1363    * should provide an API call which civix can use instead.
1364    *
1365    *
1366    * @return array
1367    *   array($fullyQualifiedName => $label) list of extensions
1368    */
1369   public static function &getExtensions() {
1370     if (!self::$extensions) {
1371       $compat = CRM_Extension_System::getCompatibilityInfo();
1372       self::$extensions = [];
1373       $sql = '
1374         SELECT full_name, label
1375         FROM civicrm_extension
1376         WHERE is_active = 1
1377       ';
1378       $dao = CRM_Core_DAO::executeQuery($sql);
1379       while ($dao->fetch()) {
1380         if (!empty($compat[$dao->full_name]['force-uninstall'])) {
1381           continue;
1382         }
1383         self::$extensions[$dao->full_name] = $dao->label;
1384       }
1385     }
1386
1387     return self::$extensions;
1388   }
1389
1390   /**
1391    * Get all options values.
1392    *
1393    * The static array option values is returned
1394    *
1395    *
1396    * @param string $optionGroupName
1397    *   Name of option group
1398    *
1399    * @param int $id
1400    * @param string $condition
1401    * @param string $column
1402    *   Whether to return 'name' or 'label'
1403    *
1404    * @return array
1405    *   array reference of all Option Values
1406    */
1407   public static function accountOptionValues($optionGroupName, $id = NULL, $condition = NULL, $column = 'label') {
1408     $cacheKey = $optionGroupName . '_' . $condition . '_' . $column;
1409     if (empty(self::$accountOptionValues[$cacheKey])) {
1410       self::$accountOptionValues[$cacheKey] = CRM_Core_OptionGroup::values($optionGroupName, FALSE, FALSE, FALSE, $condition, $column);
1411     }
1412     if ($id) {
1413       return self::$accountOptionValues[$cacheKey][$id] ?? NULL;
1414     }
1415
1416     return self::$accountOptionValues[$cacheKey];
1417   }
1418
1419   /**
1420    * Fetch the list of active extensions of type 'module'
1421    *
1422    * @param bool $fresh
1423    *   Whether to forcibly reload extensions list from canonical store.
1424    *
1425    * @return array
1426    *   array(array('prefix' => $, 'file' => $))
1427    */
1428   public static function getModuleExtensions($fresh = FALSE) {
1429     return CRM_Extension_System::singleton()->getMapper()->getActiveModuleFiles($fresh);
1430   }
1431
1432   /**
1433    * Get all tax rates.
1434    *
1435    * The static array tax rates is returned
1436    *
1437    * @return array
1438    *   array list of tax rates with the financial type
1439    */
1440   public static function getTaxRates() {
1441     if (!isset(Civi::$statics[__CLASS__]['taxRates'])) {
1442       Civi::$statics[__CLASS__]['taxRates'] = [];
1443       $option = civicrm_api3('option_value', 'get', [
1444         'sequential' => 1,
1445         'option_group_id' => 'account_relationship',
1446         'name' => 'Sales Tax Account is',
1447       ]);
1448       $value = [];
1449       if ($option['count'] !== 0) {
1450         if ($option['count'] > 1) {
1451           foreach ($option['values'] as $opt) {
1452             $value[] = $opt['value'];
1453           }
1454         }
1455         else {
1456           $value[] = $option['values'][0]['value'];
1457         }
1458         $where = 'AND efa.account_relationship IN (' . implode(', ', $value) . ' )';
1459       }
1460       else {
1461         $where = '';
1462       }
1463       $sql = "
1464         SELECT fa.tax_rate, efa.entity_id
1465         FROM civicrm_entity_financial_account efa
1466         INNER JOIN civicrm_financial_account fa ON fa.id = efa.financial_account_id
1467         WHERE efa.entity_table = 'civicrm_financial_type'
1468         {$where}
1469         AND fa.is_active = 1";
1470       $dao = CRM_Core_DAO::executeQuery($sql);
1471       while ($dao->fetch()) {
1472         Civi::$statics[__CLASS__]['taxRates'][$dao->entity_id] = $dao->tax_rate;
1473       }
1474     }
1475
1476     return Civi::$statics[__CLASS__]['taxRates'];
1477   }
1478
1479   /**
1480    * Get participant status class options.
1481    *
1482    * @return array
1483    */
1484   public static function emailOnHoldOptions() {
1485     return [
1486       '0' => ts('No'),
1487       '1' => ts('On Hold Bounce'),
1488       '2' => ts('On Hold Opt Out'),
1489     ];
1490   }
1491
1492   /**
1493    * Render the field options from the available pseudoconstant.
1494    *
1495    * Do not call this function directly or from untested code. Further cleanup is likely.
1496    *
1497    * @param array $pseudoconstant
1498    * @param array $params
1499    * @param string|null $localizeContext
1500    * @param string $context
1501    *
1502    * @return array|bool|mixed
1503    */
1504   public static function renderOptionsFromTablePseudoconstant($pseudoconstant, &$params = [], $localizeContext = NULL, $context = '') {
1505     $daoName = CRM_Core_DAO_AllCoreTables::getClassForTable($pseudoconstant['table']);
1506     if (!class_exists($daoName)) {
1507       return FALSE;
1508     }
1509     // Get list of fields for the option table
1510     /* @var CRM_Core_DAO $dao * */
1511     $dao = new $daoName();
1512     $availableFields = array_keys($dao->fieldKeys());
1513
1514     $select = 'SELECT %1 AS id, %2 AS label';
1515     $from = 'FROM %3';
1516     $wheres = [];
1517     $order = 'ORDER BY %2';
1518
1519     // Use machine name in certain contexts
1520     if ($context === 'validate' || $context === 'match') {
1521       $nameField = $context === 'validate' ? 'labelColumn' : 'keyColumn';
1522       if (!empty($pseudoconstant['nameColumn'])) {
1523         $params[$nameField] = $pseudoconstant['nameColumn'];
1524       }
1525       elseif (in_array('name', $availableFields)) {
1526         $params[$nameField] = 'name';
1527       }
1528     }
1529
1530     // Use abbrColum if context is abbreviate
1531     if ($context === 'abbreviate' && (in_array('abbreviation', $availableFields) || !empty($pseudoconstant['abbrColumn']))) {
1532       $params['labelColumn'] = $pseudoconstant['abbrColumn'] ?? 'abbreviation';
1533     }
1534
1535     // Condition param can be passed as an sql clause string or an array of clauses
1536     if (!empty($params['condition'])) {
1537       $wheres[] = implode(' AND ', (array) $params['condition']);
1538     }
1539     // onlyActive param will automatically filter on common flags
1540     if (!empty($params['onlyActive'])) {
1541       foreach (['is_active' => 1, 'is_deleted' => 0, 'is_test' => 0, 'is_hidden' => 0] as $flag => $val) {
1542         if (in_array($flag, $availableFields)) {
1543           $wheres[] = "$flag = $val";
1544         }
1545       }
1546     }
1547     // Filter domain specific options
1548     if (in_array('domain_id', $availableFields)) {
1549       $wheres[] = 'domain_id = ' . CRM_Core_Config::domainID() . ' OR  domain_id is NULL';
1550     }
1551     $queryParams = [
1552       1 => [$params['keyColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES],
1553       2 => [$params['labelColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES],
1554       3 => [$pseudoconstant['table'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES],
1555     ];
1556     // Add orderColumn param
1557     if (!empty($params['orderColumn'])) {
1558       $queryParams[4] = [$params['orderColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES];
1559       $order = 'ORDER BY %4';
1560     }
1561     // Support no sorting if $params[orderColumn] is FALSE
1562     elseif (isset($params['orderColumn']) && $params['orderColumn'] === FALSE) {
1563       $order = '';
1564     }
1565     // Default to 'weight' if that column exists
1566     elseif (in_array('weight', $availableFields)) {
1567       $order = "ORDER BY weight";
1568     }
1569
1570     $output = [];
1571     $query = "$select $from";
1572     if ($wheres) {
1573       $query .= " WHERE " . implode(' AND ', $wheres);
1574     }
1575     $query .= ' ' . $order;
1576     $dao = CRM_Core_DAO::executeQuery($query, $queryParams);
1577     while ($dao->fetch()) {
1578       $output[$dao->id] = $dao->label;
1579     }
1580     // Localize results
1581     if (!empty($params['localize']) || $pseudoconstant['table'] === 'civicrm_country' || $pseudoconstant['table'] === 'civicrm_state_province') {
1582       $I18nParams = [];
1583       if ($localizeContext) {
1584         $I18nParams['context'] = $localizeContext;
1585       }
1586       $i18n = CRM_Core_I18n::singleton();
1587       $i18n->localizeArray($output, $I18nParams);
1588       // Maintain sort by label
1589       if ($order === 'ORDER BY %2') {
1590         $output = CRM_Utils_Array::asort($output);
1591       }
1592     }
1593
1594     return $output;
1595   }
1596
1597 }