CRM/Core/PseudoConstant.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.5                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   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  *
  30  * Stores all constants and pseudo constants for CRM application.
  31  *
  32  * examples of constants are "Contact Type" which will always be either
  33  * 'Individual', 'Household', 'Organization'.
  34  *
  35  * pseudo constants are entities from the database whose values rarely
  36  * change. examples are list of countries, states, location types,
  37  * relationship types.
  38  *
  39  * currently we're getting the data from the underlying database. this
  40  * will be reworked to use caching.
  41  *
  42  * Note: All pseudoconstants should be uninitialized or default to NULL.
  43  * This provides greater consistency/predictability after flushing.
  44  *
  45  * @package CRM
  46  * @copyright CiviCRM LLC (c) 2004-2014
  47  * $Id$
  48  *
  49  */
  50 class CRM_Core_PseudoConstant {
  51
  52   /**
  53    * static cache for pseudoconstant arrays
  54    * @var array
  55    * @static
  56    */
  57   private static $cache;
  58
  59   /**
  60    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
  61    *
  62    * activity type
  63    * @var array
  64    * @static
  65    */
  66   private static $activityType;
  67
  68   /**
  69    * states, provinces
  70    * @var array
  71    * @static
  72    */
  73   private static $stateProvince;
  74
  75   /**
  76    * counties
  77    * @var array
  78    * @static
  79    */
  80   private static $county;
  81
  82   /**
  83    * states/provinces abbreviations
  84    * @var array
  85    * @static
  86    */
  87   private static $stateProvinceAbbreviation;
  88
  89   /**
  90    * country
  91    * @var array
  92    * @static
  93    */
  94   private static $country;
  95
  96   /**
  97    * countryIsoCode
  98    * @var array
  99    * @static
 100    */
 101   private static $countryIsoCode;
 102
 103   /**
 104    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
 105    *
 106    * group
 107    * @var array
 108    * @static
 109    */
 110   private static $group;
 111
 112   /**
 113    * groupIterator
 114    * @var mixed
 115    * @static
 116    */
 117   private static $groupIterator;
 118
 119   /**
 120    * relationshipType
 121    * @var array
 122    * @static
 123    */
 124   private static $relationshipType;
 125
 126   /**
 127    * civicrm groups that are not smart groups
 128    * @var array
 129    * @static
 130    */
 131   private static $staticGroup;
 132
 133   /**
 134    * currency codes
 135    * @var array
 136    * @static
 137    */
 138   private static $currencyCode;
 139
 140   /**
 141    * payment processor
 142    * @var array
 143    * @static
 144    */
 145   private static $paymentProcessor;
 146
 147   /**
 148    * payment processor types
 149    * @var array
 150    * @static
 151    */
 152   private static $paymentProcessorType;
 153
 154   /**
 155    * World Region
 156    * @var array
 157    * @static
 158    */
 159   private static $worldRegions;
 160
 161   /**
 162    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
 163    *
 164    * activity status
 165    * @var array
 166    * @static
 167    */
 168   private static $activityStatus;
 169
 170   /**
 171    * Visibility
 172    * @var array
 173    * @static
 174    */
 175   private static $visibility;
 176
 177   /**
 178    * Greetings
 179    * @var array
 180    * @static
 181    */
 182   private static $greeting;
 183
 184   /**
 185    * Default Greetings
 186    * @var array
 187    * @static
 188    */
 189   private static $greetingDefaults;
 190
 191   /**
 192    * Extensions of type module
 193    * @var array
 194    * @static
 195    */
 196   private static $extensions;
 197
 198   /**
 199    * Financial Account Type
 200    * @var array
 201    * @static
 202    */
 203   private static $accountOptionValues;
 204
 205   /**
 206    * Low-level option getter, rarely accessed directly.
 207    * NOTE: Rather than calling this function directly use CRM_*_BAO_*::buildOptions()
 208    * @see http://wiki.civicrm.org/confluence/display/CRMDOC/Pseudoconstant+%28option+list%29+Reference
 209    *
 210    * @param String $daoName
 211    * @param String $fieldName
 212    * @param Array $params
 213    * - name       string  name of the option group
 214    * - flip       boolean results are return in id => label format if false
 215    *                            if true, the results are reversed
 216    * - grouping   boolean if true, return the value in 'grouping' column (currently unsupported for tables other than option_value)
 217    * - localize   boolean if true, localize the results before returning
 218    * - condition  string|array add condition(s) to the sql query - will be concatenated using 'AND'
 219    * - keyColumn  string the column to use for 'id'
 220    * - labelColumn string the column to use for 'label'
 221    * - orderColumn string the column to use for sorting, defaults to 'weight' column if one exists, else defaults to labelColumn
 222    * - onlyActive boolean return only the action option values
 223    * - fresh      boolean ignore cache entries and go back to DB
 224    * @param String $context: Context string
 225    *
 226    * @return Array|bool - array on success, FALSE on error.
 227    *
 228    * @static
 229    */
 230   public static function get($daoName, $fieldName, $params = array(), $context = NULL) {
 231     CRM_Core_DAO::buildOptionsContext($context);
 232     $flip = !empty($params['flip']);
 233     // Merge params with defaults
 234     $params += array(
 235       'grouping' => FALSE,
 236       'localize' => FALSE,
 237       'onlyActive' => ($context == 'validate' || $context == 'get') ? FALSE : TRUE,
 238       'fresh' => FALSE,
 239     );
 240
 241     // Custom fields are not in the schema
 242     if (strpos($fieldName, 'custom_') === 0 && is_numeric($fieldName[7])) {
 243       $customField = new CRM_Core_DAO_CustomField();
 244       $customField->id = (int) substr($fieldName, 7);
 245       $customField->find(TRUE);
 246       $options = FALSE;
 247
 248       if (!empty($customField->option_group_id)) {
 249         $options = CRM_Core_OptionGroup::valuesByID($customField->option_group_id,
 250           FALSE,
 251           $params['grouping'],
 252           $params['localize'],
 253           // Note: for custom fields the 'name' column is NULL
 254           CRM_Utils_Array::value('labelColumn', $params, 'label'),
 255           $params['onlyActive'],
 256           $params['fresh']
 257         );
 258       }
 259       else {
 260         if ($customField->data_type === 'StateProvince') {
 261           $options = self::stateProvince();
 262         }
 263         elseif ($customField->data_type === 'Country') {
 264           $options = $context == 'validate' ? self::countryIsoCode() : self::country();
 265         }
 266         elseif ($customField->data_type === 'Boolean') {
 267           $options = $context == 'validate' ? array(0, 1) : array(1 => ts('Yes'), 0 => ts('No'));
 268         }
 269       }
 270       CRM_Utils_Hook::customFieldOptions($customField->id, $options, FALSE);
 271       if ($options && $flip) {
 272         $options = array_flip($options);
 273       }
 274       $customField->free();
 275       return $options;
 276     }
 277
 278     // Core field: load schema
 279     $dao = new $daoName;
 280     $fieldSpec = $dao->getFieldSpec($fieldName);
 281     $dao->free();
 282     // If neither worked then this field doesn't exist. Return false.
 283     if (empty($fieldSpec)) {
 284       return FALSE;
 285     }
 286
 287     elseif (!empty($fieldSpec['pseudoconstant'])) {
 288       $pseudoconstant = $fieldSpec['pseudoconstant'];
 289
 290       // if callback is specified..
 291       if(!empty($pseudoconstant['callback'])) {
 292         list($className, $fnName) = explode('::', $pseudoconstant['callback']);
 293         if (method_exists($className, $fnName)) {
 294           return call_user_func(array($className, $fnName));
 295         }
 296       }
 297
 298       // Merge params with schema defaults
 299       $params += array(
 300         'condition' => CRM_Utils_Array::value('condition', $pseudoconstant, array()),
 301         'keyColumn' => CRM_Utils_Array::value('keyColumn', $pseudoconstant),
 302         'labelColumn' => CRM_Utils_Array::value('labelColumn', $pseudoconstant),
 303       );
 304
 305       // Fetch option group from option_value table
 306       if(!empty($pseudoconstant['optionGroupName'])) {
 307         if ($context == 'validate') {
 308           $params['labelColumn'] = 'name';
 309         }
 310         // Call our generic fn for retrieving from the option_value table
 311         return CRM_Core_OptionGroup::values(
 312           $pseudoconstant['optionGroupName'],
 313           $flip,
 314           $params['grouping'],
 315           $params['localize'],
 316           $params['condition'] ? ' AND ' . implode(' AND ', (array) $params['condition']) : NULL,
 317           $params['labelColumn'] ? $params['labelColumn'] : 'label',
 318           $params['onlyActive'],
 319           $params['fresh'],
 320           $params['keyColumn'] ? $params['keyColumn'] : 'value'
 321         );
 322       }
 323
 324       // Fetch options from other tables
 325       if (!empty($pseudoconstant['table'])) {
 326         // Normalize params so the serialized cache string will be consistent.
 327         CRM_Utils_Array::remove($params, 'flip', 'fresh');
 328         ksort($params);
 329         $cacheKey = $daoName . $fieldName . serialize($params);
 330
 331         // Retrieve cached options
 332         if (isset(self::$cache[$cacheKey]) && empty($params['fresh'])) {
 333           $output = self::$cache[$cacheKey];
 334         }
 335         else {
 336           $daoName = CRM_Core_DAO_AllCoreTables::getClassForTable($pseudoconstant['table']);
 337           if (!class_exists($daoName)) {
 338             return FALSE;
 339           }
 340           // Get list of fields for the option table
 341           $dao = new $daoName;
 342           $availableFields = array_keys($dao->fieldKeys());
 343           $dao->free();
 344
 345           $select = "SELECT %1 AS id, %2 AS label";
 346           $from = "FROM %3";
 347           $wheres = array();
 348           $order = "ORDER BY %2";
 349
 350           // Use machine name instead of label in validate context
 351           if ($context == 'validate') {
 352             if (!empty($pseudoconstant['nameColumn'])) {
 353               $params['labelColumn'] = $pseudoconstant['nameColumn'];
 354             }
 355             elseif (in_array('name', $availableFields)) {
 356               $params['labelColumn'] = 'name';
 357             }
 358           }
 359           // Condition param can be passed as an sql clause string or an array of clauses
 360           if (!empty($params['condition'])) {
 361             $wheres[] = implode(' AND ', (array) $params['condition']);
 362           }
 363           // onlyActive param will automatically filter on common flags
 364           if (!empty($params['onlyActive'])) {
 365             foreach (array('is_active' => 1, 'is_deleted' => 0, 'is_test' => 0) as $flag => $val) {
 366               if (in_array($flag, $availableFields)) {
 367                 $wheres[] = "$flag = $val";
 368               }
 369             }
 370           }
 371           // Filter domain specific options
 372           if (in_array('domain_id', $availableFields)) {
 373             $wheres[] = 'domain_id = ' . CRM_Core_Config::domainID();
 374           }
 375           $queryParams = array(
 376              1 => array($params['keyColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES),
 377              2 => array($params['labelColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES),
 378              3 => array($pseudoconstant['table'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES),
 379           );
 380           // Add orderColumn param
 381           if (!empty($params['orderColumn'])) {
 382             $queryParams[4] = array($params['orderColumn'], 'String', CRM_Core_DAO::QUERY_FORMAT_NO_QUOTES);
 383             $order = "ORDER BY %4";
 384           }
 385           // Support no sorting if $params[orderColumn] is FALSE
 386           elseif (isset($params['orderColumn']) && $params['orderColumn'] === FALSE) {
 387             $order = '';
 388           }
 389           // Default to 'weight' if that column exists
 390           elseif (in_array('weight', $availableFields)) {
 391             $order = "ORDER BY weight";
 392           }
 393
 394           $output = array();
 395           $query = "$select $from";
 396           if ($wheres) {
 397             $query .= " WHERE " . implode($wheres, ' AND ');
 398           }
 399           $query .= ' ' . $order;
 400           $dao = CRM_Core_DAO::executeQuery($query, $queryParams);
 401           while ($dao->fetch()) {
 402             $output[$dao->id] = $dao->label;
 403           }
 404           $dao->free();
 405           // Localize results
 406           if (!empty($params['localize']) || $pseudoconstant['table'] == 'civicrm_country' || $pseudoconstant['table'] == 'civicrm_state_province') {
 407             $I18nParams = array();
 408             if ($pseudoconstant['table'] == 'civicrm_country') {
 409               $I18nParams['context'] = 'country';
 410             }
 411             if ($pseudoconstant['table'] == 'civicrm_state_province') {
 412               $I18nParams['context'] = 'province';
 413             }
 414             $i18n = CRM_Core_I18n::singleton();
 415             $i18n->localizeArray($output, $I18nParams);
 416             // Maintain sort by label
 417             if ($order == "ORDER BY %2") {
 418               CRM_Utils_Array::asort($output);
 419             }
 420           }
 421           self::$cache[$cacheKey] = $output;
 422         }
 423         return $flip ? array_flip($output) : $output;
 424       }
 425     }
 426
 427     // Return "Yes" and "No" for boolean fields
 428     elseif (CRM_Utils_Array::value('type', $fieldSpec) === CRM_Utils_Type::T_BOOLEAN) {
 429       $output = $context == 'validate' ? array(0, 1) : array(1 => ts('Yes'), 0 => ts('No'));
 430       return $flip ? array_flip($output) : $output;
 431     }
 432     // If we're still here, it's an error. Return FALSE.
 433     return FALSE;
 434   }
 435
 436   /**
 437    * Fetch the translated label for a field given its key
 438    *
 439    * @param String $baoName
 440    * @param String $fieldName
 441    * @param String|Int $key
 442    *
 443    * TODO: Accept multivalued input?
 444    *
 445    * @return bool|null|string
 446    *   FALSE if the given field has no associated option list
 447    *   NULL if the given key has no corresponding option
 448    *   String if label is found
 449    */
 450   static function getLabel($baoName, $fieldName, $key) {
 451     $values = $baoName::buildOptions($fieldName, 'get');
 452     if ($values === FALSE) {
 453       return FALSE;
 454     }
 455     return CRM_Utils_Array::value($key, $values);
 456   }
 457
 458   /**
 459    * Fetch the machine name for a field given its key
 460    *
 461    * @param String $baoName
 462    * @param String $fieldName
 463    * @param String|Int $key
 464    *
 465    * @return bool|null|string
 466    *   FALSE if the given field has no associated option list
 467    *   NULL if the given key has no corresponding option
 468    *   String if label is found
 469    */
 470   static function getName($baoName, $fieldName, $key) {
 471     $values = $baoName::buildOptions($fieldName, 'validate');
 472     if ($values === FALSE) {
 473       return FALSE;
 474     }
 475     return CRM_Utils_Array::value($key, $values);
 476   }
 477
 478   /**
 479    * Fetch the key for a field option given its name
 480    *
 481    * @param String $baoName
 482    * @param String $fieldName
 483    * @param String|Int $value
 484    *
 485    * @return bool|null|string|number
 486    *   FALSE if the given field has no associated option list
 487    *   NULL if the given key has no corresponding option
 488    *   String|Number if key is found
 489    */
 490   static function getKey($baoName, $fieldName, $value) {
 491     $values = $baoName::buildOptions($fieldName, 'validate');
 492     if ($values === FALSE) {
 493       return FALSE;
 494     }
 495     return CRM_Utils_Array::key($value, $values);
 496   }
 497
 498   /**
 499    * Lookup the admin page at which a field's option list can be edited
 500    * @param $fieldSpec
 501    * @return string|null
 502    */
 503   static function getOptionEditUrl($fieldSpec) {
 504     // If it's an option group, that's easy
 505     if (!empty($fieldSpec['pseudoconstant']['optionGroupName'])) {
 506       return 'civicrm/admin/options/' . $fieldSpec['pseudoconstant']['optionGroupName'];
 507     }
 508     // For everything else...
 509     elseif (!empty($fieldSpec['pseudoconstant']['table'])) {
 510       $daoName = CRM_Core_DAO_AllCoreTables::getClassForTable($fieldSpec['pseudoconstant']['table']);
 511       if (!$daoName) {
 512         return NULL;
 513       }
 514       // We don't have good mapping so have to do a bit of guesswork from the menu
 515       list(, $parent, , $child) = explode('_', $daoName);
 516       $sql = "SELECT path FROM civicrm_menu
 517         WHERE page_callback LIKE '%CRM_Admin_Page_$child%' OR page_callback LIKE '%CRM_{$parent}_Page_$child%'
 518         ORDER BY page_callback
 519         LIMIT 1";
 520       return CRM_Core_Dao::singleValueQuery($sql);
 521     }
 522     return NULL;
 523   }
 524
 525   /**
 526    * DEPRECATED generic populate method
 527    * All pseudoconstant functions that use this method are also deprecated.
 528    *
 529    * The static array $var is populated from the db
 530    * using the <b>$name DAO</b>.
 531    *
 532    * Note: any database errors will be trapped by the DAO.
 533    *
 534    * @param array $var the associative array we will fill
 535    * @param string $name the name of the DAO
 536    * @param boolean $all get all objects. default is to get only active ones.
 537    * @param string $retrieve the field that we are interested in (normally name, differs in some objects)
 538    * @param string $filter the field that we want to filter the result set with
 539    * @param string $condition the condition that gets passed to the final query as the WHERE clause
 540    *
 541    * @param null $orderby
 542    * @param string $key
 543    * @param null $force
 544    *
 545    * @return void
 546    * @access public
 547    * @static
 548    */
 549   public static function populate(
 550     &$var,
 551     $name,
 552     $all = FALSE,
 553     $retrieve = 'name',
 554     $filter = 'is_active',
 555     $condition = NULL,
 556     $orderby = NULL,
 557     $key = 'id',
 558     $force = NULL
 559   ) {
 560     $cacheKey = "CRM_PC_{$name}_{$all}_{$key}_{$retrieve}_{$filter}_{$condition}_{$orderby}";
 561     $cache    = CRM_Utils_Cache::singleton();
 562     $var      = $cache->get($cacheKey);
 563     if ($var && empty($force)) {
 564       return $var;
 565     }
 566
 567     $object = new $name ( );
 568
 569     $object->selectAdd();
 570     $object->selectAdd("$key, $retrieve");
 571     if ($condition) {
 572       $object->whereAdd($condition);
 573     }
 574
 575     if (!$orderby) {
 576       $object->orderBy($retrieve);
 577     }
 578     else {
 579       $object->orderBy($orderby);
 580     }
 581
 582     if (!$all) {
 583       $object->$filter = 1;
 584     }
 585
 586     $object->find();
 587     $var = array();
 588     while ($object->fetch()) {
 589       $var[$object->$key] = $object->$retrieve;
 590     }
 591
 592     $cache->set($cacheKey, $var);
 593   }
 594
 595   /**
 596    * Flush given pseudoconstant so it can be reread from db
 597    * nex time it's requested.
 598    *
 599    * @access public
 600    * @static
 601    *
 602    * @param boolean $name pseudoconstant to be flushed
 603    *
 604    */
 605   public static function flush($name = 'cache') {
 606     if (isset(self::$$name)) {
 607       self::$$name = NULL;
 608     }
 609     if ($name == 'cache') {
 610       CRM_Core_OptionGroup::flushAll();
 611     }
 612   }
 613
 614   /**
 615    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
 616    *
 617    * Get all Activty types.
 618    *
 619    * The static array activityType is returned
 620    *
 621    * @param boolean $all - get All Activity  types - default is to get only active ones.
 622    *
 623    * @access public
 624    * @static
 625    *
 626    * @return array - array reference of all activity types.
 627    */
 628   public static function &activityType() {
 629     $args = func_get_args();
 630     $all = CRM_Utils_Array::value(0, $args, TRUE);
 631     $includeCaseActivities = CRM_Utils_Array::value(1, $args, FALSE);
 632     $reset = CRM_Utils_Array::value(2, $args, FALSE);
 633     $returnColumn = CRM_Utils_Array::value(3, $args, 'label');
 634     $includeCampaignActivities = CRM_Utils_Array::value(4, $args, FALSE);
 635     $onlyComponentActivities = CRM_Utils_Array::value(5, $args, FALSE);
 636     $index = (int) $all . '_' . $returnColumn . '_' . (int) $includeCaseActivities;
 637     $index .= '_' . (int) $includeCampaignActivities;
 638     $index .= '_' . (int) $onlyComponentActivities;
 639
 640     if (NULL === self::$activityType) {
 641       self::$activityType = array();
 642     }
 643
 644     if (!isset(self::$activityType[$index]) || $reset) {
 645       $condition = NULL;
 646       if (!$all) {
 647         $condition = 'AND filter = 0';
 648       }
 649       $componentClause = " v.component_id IS NULL";
 650       if ($onlyComponentActivities) {
 651         $componentClause = " v.component_id IS NOT NULL";
 652       }
 653
 654       $componentIds = array();
 655       $compInfo = CRM_Core_Component::getEnabledComponents();
 656
 657       // build filter for listing activity types only if their
 658       // respective components are enabled
 659       foreach ($compInfo as $compName => $compObj) {
 660         if ($compName == 'CiviCase') {
 661           if ($includeCaseActivities) {
 662             $componentIds[] = $compObj->componentID;
 663           }
 664         }
 665         elseif ($compName == 'CiviCampaign') {
 666           if ($includeCampaignActivities) {
 667             $componentIds[] = $compObj->componentID;
 668           }
 669         }
 670         else {
 671           $componentIds[] = $compObj->componentID;
 672         }
 673       }
 674
 675       if (count($componentIds)) {
 676         $componentIds = implode(',', $componentIds);
 677         $componentClause = " ($componentClause OR v.component_id IN ($componentIds))";
 678         if ($onlyComponentActivities) {
 679           $componentClause = " ( v.component_id IN ($componentIds ) )";
 680         }
 681       }
 682       $condition = $condition . ' AND ' . $componentClause;
 683
 684       self::$activityType[$index] = CRM_Core_OptionGroup::values('activity_type', FALSE, FALSE, FALSE, $condition, $returnColumn);
 685     }
 686     return self::$activityType[$index];
 687   }
 688
 689   /**
 690    * Get all the State/Province from database.
 691    *
 692    * The static array stateProvince is returned, and if it's
 693    * called the first time, the <b>State Province DAO</b> is used
 694    * to get all the States.
 695    *
 696    * Note: any database errors will be trapped by the DAO.
 697    *
 698    * @access public
 699    * @static
 700    *
 701    * @param int $id -  Optional id to return
 702    *
 703    * @return array - array reference of all State/Provinces.
 704    *
 705    */
 706   public static function &stateProvince($id = FALSE, $limit = TRUE) {
 707     if (($id && !CRM_Utils_Array::value($id, self::$stateProvince)) || !self::$stateProvince || !$id) {
 708       $whereClause = FALSE;
 709       $config = CRM_Core_Config::singleton();
 710       if ($limit) {
 711         $countryIsoCodes = self::countryIsoCode();
 712         $limitCodes      = $config->provinceLimit();
 713         $limitIds        = array();
 714         foreach ($limitCodes as $code) {
 715           $limitIds = array_merge($limitIds, array_keys($countryIsoCodes, $code));
 716         }
 717         if (!empty($limitIds)) {
 718           $whereClause = 'country_id IN (' . implode(', ', $limitIds) . ')';
 719         }
 720         else {
 721           $whereClause = FALSE;
 722         }
 723       }
 724       self::populate(self::$stateProvince, 'CRM_Core_DAO_StateProvince', TRUE, 'name', 'is_active', $whereClause);
 725
 726       // localise the province names if in an non-en_US locale
 727       global $tsLocale;
 728       if ($tsLocale != '' and $tsLocale != 'en_US') {
 729         $i18n = CRM_Core_I18n::singleton();
 730         $i18n->localizeArray(self::$stateProvince, array(
 731             'context' => 'province',
 732           ));
 733         self::$stateProvince = CRM_Utils_Array::asort(self::$stateProvince);
 734       }
 735     }
 736     if ($id) {
 737       if (array_key_exists($id, self::$stateProvince)) {
 738         return self::$stateProvince[$id];
 739       }
 740       else {
 741         $result = NULL;
 742         return $result;
 743       }
 744     }
 745     return self::$stateProvince;
 746   }
 747
 748   /**
 749    * Get all the State/Province abbreviations from the database.
 750    *
 751    * Same as above, except gets the abbreviations instead of the names.
 752    *
 753    * @access public
 754    * @static
 755    *
 756    * @param int $id  -     Optional id to return
 757    *
 758    * @return array - array reference of all State/Province abbreviations.
 759    */
 760   public static function &stateProvinceAbbreviation($id = FALSE, $limit = TRUE) {
 761     if ($id > 1) {
 762       $query = "
 763 SELECT abbreviation
 764 FROM   civicrm_state_province
 765 WHERE  id = %1";
 766       $params = array(
 767         1 => array(
 768           $id,
 769           'Integer',
 770         ),
 771       );
 772       return CRM_Core_DAO::singleValueQuery($query, $params);
 773     }
 774
 775     if (!self::$stateProvinceAbbreviation || !$id) {
 776
 777       $whereClause = FALSE;
 778
 779       if ($limit) {
 780         $config          = CRM_Core_Config::singleton();
 781         $countryIsoCodes = self::countryIsoCode();
 782         $limitCodes      = $config->provinceLimit();
 783         $limitIds        = array();
 784         foreach ($limitCodes as $code) {
 785           $tmpArray = array_keys($countryIsoCodes, $code);
 786
 787           if (!empty($tmpArray)) {
 788             $limitIds[] = array_shift($tmpArray);
 789           }
 790         }
 791         if (!empty($limitIds)) {
 792           $whereClause = 'country_id IN (' . implode(', ', $limitIds) . ')';
 793         }
 794       }
 795       self::populate(self::$stateProvinceAbbreviation, 'CRM_Core_DAO_StateProvince', TRUE, 'abbreviation', 'is_active', $whereClause);
 796     }
 797
 798     if ($id) {
 799       if (array_key_exists($id, self::$stateProvinceAbbreviation)) {
 800         return self::$stateProvinceAbbreviation[$id];
 801       }
 802       else {
 803         $result = NULL;
 804         return $result;
 805       }
 806     }
 807     return self::$stateProvinceAbbreviation;
 808   }
 809
 810   /**
 811    * Get all the countries from database.
 812    *
 813    * The static array country is returned, and if it's
 814    * called the first time, the <b>Country DAO</b> is used
 815    * to get all the countries.
 816    *
 817    * Note: any database errors will be trapped by the DAO.
 818    *
 819    * @access public
 820    * @static
 821    *
 822    * @param int $id - Optional id to return
 823    *
 824    * @return array - array reference of all countries.
 825    *
 826    */
 827   public static function country($id = FALSE, $applyLimit = TRUE) {
 828     if (($id && !CRM_Utils_Array::value($id, self::$country)) || !self::$country || !$id) {
 829
 830       $config = CRM_Core_Config::singleton();
 831       $limitCodes = array();
 832
 833       if ($applyLimit) {
 834         // limit the country list to the countries specified in CIVICRM_COUNTRY_LIMIT
 835         // (ensuring it's a subset of the legal values)
 836         // K/P: We need to fix this, i dont think it works with new setting files
 837         $limitCodes = $config->countryLimit();
 838         if (!is_array($limitCodes)) {
 839           $limitCodes = array(
 840             $config->countryLimit => 1,
 841           );
 842         }
 843
 844         $limitCodes = array_intersect(self::countryIsoCode(), $limitCodes);
 845       }
 846
 847       if (count($limitCodes)) {
 848         $whereClause = "iso_code IN ('" . implode("', '", $limitCodes) . "')";
 849       }
 850       else {
 851         $whereClause = NULL;
 852       }
 853
 854       self::populate(self::$country, 'CRM_Core_DAO_Country', TRUE, 'name', 'is_active', $whereClause);
 855
 856       // if default country is set, percolate it to the top
 857       if ($config->defaultContactCountry()) {
 858         $countryIsoCodes = self::countryIsoCode();
 859         $defaultID = array_search($config->defaultContactCountry(), $countryIsoCodes);
 860         if ($defaultID !== FALSE) {
 861           $default[$defaultID] = CRM_Utils_Array::value($defaultID, self::$country);
 862           self::$country = $default + self::$country;
 863         }
 864       }
 865
 866       // localise the country names if in an non-en_US locale
 867       global $tsLocale;
 868       if ($tsLocale != '' and $tsLocale != 'en_US') {
 869         $i18n = CRM_Core_I18n::singleton();
 870         $i18n->localizeArray(self::$country, array(
 871             'context' => 'country',
 872           ));
 873         self::$country = CRM_Utils_Array::asort(self::$country);
 874       }
 875     }
 876     if ($id) {
 877       if (array_key_exists($id, self::$country)) {
 878         return self::$country[$id];
 879       }
 880       else {
 881         return CRM_Core_DAO::$_nullObject;
 882       }
 883     }
 884     return self::$country;
 885   }
 886
 887   /**
 888    * Get all the country ISO Code abbreviations from the database.
 889    *
 890    * The static array countryIsoCode is returned, and if it's
 891    * called the first time, the <b>Country DAO</b> is used
 892    * to get all the countries' ISO codes.
 893    *
 894    * Note: any database errors will be trapped by the DAO.
 895    *
 896    * @access public
 897    * @static
 898    *
 899    * @return array - array reference of all country ISO codes.
 900    *
 901    */
 902   public static function &countryIsoCode($id = FALSE) {
 903     if (!self::$countryIsoCode) {
 904       self::populate(self::$countryIsoCode, 'CRM_Core_DAO_Country', TRUE, 'iso_code');
 905     }
 906     if ($id) {
 907       if (array_key_exists($id, self::$countryIsoCode)) {
 908         return self::$countryIsoCode[$id];
 909       }
 910       else {
 911         return CRM_Core_DAO::$_nullObject;
 912       }
 913     }
 914     return self::$countryIsoCode;
 915   }
 916
 917   /**
 918    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
 919    *
 920    * Get all groups from database
 921    *
 922    * The static array group is returned, and if it's
 923    * called the first time, the <b>Group DAO</b> is used
 924    * to get all the groups.
 925    *
 926    * Note: any database errors will be trapped by the DAO.
 927    *
 928    * @param string $groupType     type of group(Access/Mailing)
 929    * @param boolen $excludeHidden exclude hidden groups.
 930    *
 931    * @access public
 932    * @static
 933    *
 934    * @return array - array reference of all groups.
 935    *
 936    */
 937   public static function &allGroup($groupType = NULL, $excludeHidden = TRUE) {
 938     $condition = CRM_Contact_BAO_Group::groupTypeCondition($groupType, $excludeHidden);
 939
 940     if (!self::$group) {
 941       self::$group = array();
 942     }
 943
 944     $groupKey = $groupType ? $groupType : 'null';
 945
 946     if (!isset(self::$group[$groupKey])) {
 947       self::$group[$groupKey] = NULL;
 948       self::populate(self::$group[$groupKey], 'CRM_Contact_DAO_Group', FALSE, 'title', 'is_active', $condition);
 949     }
 950     return self::$group[$groupKey];
 951   }
 952
 953   /**
 954    * Create or get groups iterator (iterates over nested groups in a
 955    * logical fashion)
 956    *
 957    * The GroupNesting instance is returned; it's created if this is being
 958    * called for the first time
 959    *
 960    *
 961    * @access public
 962    * @static
 963    *
 964    * @return mixed - instance of CRM_Contact_BAO_GroupNesting
 965    *
 966    */
 967   public static function &groupIterator($styledLabels = FALSE) {
 968     if (!self::$groupIterator) {
 969       /*
 970         When used as an object, GroupNesting implements Iterator
 971         and iterates nested groups in a logical manner for us
 972       */
 973       self::$groupIterator = new CRM_Contact_BAO_GroupNesting($styledLabels);
 974     }
 975     return self::$groupIterator;
 976   }
 977
 978   /**
 979    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
 980    *
 981    * Get all permissioned groups from database
 982    *
 983    * The static array group is returned, and if it's
 984    * called the first time, the <b>Group DAO</b> is used
 985    * to get all the groups.
 986    *
 987    * Note: any database errors will be trapped by the DAO.
 988    *
 989    * @param string $groupType     type of group(Access/Mailing)
 990    * @param boolen $excludeHidden exclude hidden groups.
 991
 992    * @access public
 993    * @static
 994    *
 995    * @return array - array reference of all groups.
 996    *
 997    */
 998   public static function group($groupType = NULL, $excludeHidden = TRUE) {
 999     return CRM_Core_Permission::group($groupType, $excludeHidden);
1000   }
1001
1002   /**
1003    * Get all permissioned groups from database
1004    *
1005    * The static array group is returned, and if it's
1006    * called the first time, the <b>Group DAO</b> is used
1007    * to get all the groups.
1008    *
1009    * Note: any database errors will be trapped by the DAO.
1010    *
1011    * @access public
1012    * @static
1013    *
1014    * @return array - array reference of all groups.
1015    *
1016    */
1017   public static function &staticGroup($onlyPublic = FALSE, $groupType = NULL, $excludeHidden = TRUE) {
1018     if (!self::$staticGroup) {
1019       $condition = 'saved_search_id = 0 OR saved_search_id IS NULL';
1020       if ($onlyPublic) {
1021         $condition .= " AND visibility != 'User and User Admin Only'";
1022       }
1023
1024       if ($groupType) {
1025         $condition .= ' AND ' . CRM_Contact_BAO_Group::groupTypeCondition($groupType);
1026       }
1027
1028       if ($excludeHidden) {
1029         $condition .= ' AND is_hidden != 1 ';
1030       }
1031
1032       self::populate(self::$staticGroup, 'CRM_Contact_DAO_Group', FALSE, 'title', 'is_active', $condition, 'title');
1033     }
1034
1035     return self::$staticGroup;
1036   }
1037
1038   /**
1039    * Get all Relationship Types  from database.
1040    *
1041    * The static array group is returned, and if it's
1042    * called the first time, the <b>RelationshipType DAO</b> is used
1043    * to get all the relationship types.
1044    *
1045    * Note: any database errors will be trapped by the DAO.
1046    *
1047    * @param string $valueColumnName db column name/label.
1048    * @param boolean $reset          reset relationship types if true
1049    *
1050    * @access public
1051    * @static
1052    *
1053    * @return array - array reference of all relationship types.
1054    */
1055   public static function &relationshipType($valueColumnName = 'label', $reset = FALSE) {
1056     if (!CRM_Utils_Array::value($valueColumnName, self::$relationshipType) || $reset) {
1057       self::$relationshipType[$valueColumnName] = array();
1058
1059       //now we have name/label columns CRM-3336
1060       $column_a_b = "{$valueColumnName}_a_b";
1061       $column_b_a = "{$valueColumnName}_b_a";
1062
1063       $relationshipTypeDAO = new CRM_Contact_DAO_RelationshipType();
1064       $relationshipTypeDAO->selectAdd();
1065       $relationshipTypeDAO->selectAdd("id, {$column_a_b}, {$column_b_a}, contact_type_a, contact_type_b, contact_sub_type_a, contact_sub_type_b");
1066       $relationshipTypeDAO->is_active = 1;
1067       $relationshipTypeDAO->find();
1068       while ($relationshipTypeDAO->fetch()) {
1069
1070         self::$relationshipType[$valueColumnName][$relationshipTypeDAO->id] = array(
1071           'id' => $relationshipTypeDAO->id,
1072           $column_a_b => $relationshipTypeDAO->$column_a_b,
1073           $column_b_a => $relationshipTypeDAO->$column_b_a,
1074           'contact_type_a' => "$relationshipTypeDAO->contact_type_a",
1075           'contact_type_b' => "$relationshipTypeDAO->contact_type_b",
1076           'contact_sub_type_a' => "$relationshipTypeDAO->contact_sub_type_a",
1077           'contact_sub_type_b' => "$relationshipTypeDAO->contact_sub_type_b",
1078         );
1079       }
1080     }
1081
1082     return self::$relationshipType[$valueColumnName];
1083   }
1084
1085   /**
1086    * get all the ISO 4217 currency codes
1087    *
1088    * so far, we use this for validation only, so there's no point of putting this into the database
1089    *
1090    * @access public
1091    *
1092    * @return array - array reference of all currency codes
1093    * @static
1094    */
1095   public static function &currencyCode() {
1096     if (!self::$currencyCode) {
1097       self::$currencyCode = array(
1098         'AFN',
1099         'ALL',
1100         'DZD',
1101         'USD',
1102         'EUR',
1103         'AOA',
1104         'XCD',
1105         'XCD',
1106         'ARS',
1107         'AMD',
1108         'AWG',
1109         'AUD',
1110         'EUR',
1111         'AZM',
1112         'BSD',
1113         'BHD',
1114         'BDT',
1115         'BBD',
1116         'BYR',
1117         'EUR',
1118         'BZD',
1119         'XOF',
1120         'BMD',
1121         'INR',
1122         'BTN',
1123         'BOB',
1124         'BOV',
1125         'BAM',
1126         'BWP',
1127         'NOK',
1128         'BRL',
1129         'USD',
1130         'BND',
1131         'BGN',
1132         'XOF',
1133         'BIF',
1134         'KHR',
1135         'XAF',
1136         'CAD',
1137         'CVE',
1138         'KYD',
1139         'XAF',
1140         'XAF',
1141         'CLP',
1142         'CLF',
1143         'CNY',
1144         'AUD',
1145         'AUD',
1146         'COP',
1147         'COU',
1148         'KMF',
1149         'XAF',
1150         'CDF',
1151         'NZD',
1152         'CRC',
1153         'XOF',
1154         'HRK',
1155         'CUP',
1156         'CYP',
1157         'CZK',
1158         'DKK',
1159         'DJF',
1160         'XCD',
1161         'DOP',
1162         'USD',
1163         'EGP',
1164         'SVC',
1165         'USD',
1166         'XAF',
1167         'ERN',
1168         'EEK',
1169         'ETB',
1170         'FKP',
1171         'DKK',
1172         'FJD',
1173         'EUR',
1174         'EUR',
1175         'EUR',
1176         'XPF',
1177         'EUR',
1178         'XAF',
1179         'GMD',
1180         'GEL',
1181         'EUR',
1182         'GHC',
1183         'GIP',
1184         'EUR',
1185         'DKK',
1186         'XCD',
1187         'EUR',
1188         'USD',
1189         'GTQ',
1190         'GNF',
1191         'GWP',
1192         'XOF',
1193         'GYD',
1194         'HTG',
1195         'USD',
1196         'AUD',
1197         'EUR',
1198         'HNL',
1199         'HKD',
1200         'HUF',
1201         'ISK',
1202         'INR',
1203         'IDR',
1204         'XDR',
1205         'IRR',
1206         'IQD',
1207         'EUR',
1208         'ILS',
1209         'EUR',
1210         'JMD',
1211         'JPY',
1212         'JOD',
1213         'KZT',
1214         'KES',
1215         'AUD',
1216         'KPW',
1217         'KRW',
1218         'KWD',
1219         'KGS',
1220         'LAK',
1221         'LVL',
1222         'LBP',
1223         'ZAR',
1224         'LSL',
1225         'LRD',
1226         'LYD',
1227         'CHF',
1228         'LTL',
1229         'EUR',
1230         'MOP',
1231         'MKD',
1232         'MGA',
1233         'MWK',
1234         'MYR',
1235         'MVR',
1236         'XOF',
1237         'MTL',
1238         'USD',
1239         'EUR',
1240         'MRO',
1241         'MUR',
1242         'EUR',
1243         'MXN',
1244         'MXV',
1245         'USD',
1246         'MDL',
1247         'EUR',
1248         'MNT',
1249         'XCD',
1250         'MAD',
1251         'MZM',
1252         'MMK',
1253         'ZAR',
1254         'NAD',
1255         'AUD',
1256         'NPR',
1257         'EUR',
1258         'ANG',
1259         'XPF',
1260         'NZD',
1261         'NIO',
1262         'XOF',
1263         'NGN',
1264         'NZD',
1265         'AUD',
1266         'USD',
1267         'NOK',
1268         'OMR',
1269         'PKR',
1270         'USD',
1271         'PAB',
1272         'USD',
1273         'PGK',
1274         'PYG',
1275         'PEN',
1276         'PHP',
1277         'NZD',
1278         'PLN',
1279         'EUR',
1280         'USD',
1281         'QAR',
1282         'EUR',
1283         'ROL',
1284         'RON',
1285         'RUB',
1286         'RWF',
1287         'SHP',
1288         'XCD',
1289         'XCD',
1290         'EUR',
1291         'XCD',
1292         'WST',
1293         'EUR',
1294         'STD',
1295         'SAR',
1296         'XOF',
1297         'CSD',
1298         'EUR',
1299         'SCR',
1300         'SLL',
1301         'SGD',
1302         'SKK',
1303         'SIT',
1304         'SBD',
1305         'SOS',
1306         'ZAR',
1307         'EUR',
1308         'LKR',
1309         'SDD',
1310         'SRD',
1311         'NOK',
1312         'SZL',
1313         'SEK',
1314         'CHF',
1315         'CHW',
1316         'CHE',
1317         'SYP',
1318         'TWD',
1319         'TJS',
1320         'TZS',
1321         'THB',
1322         'USD',
1323         'XOF',
1324         'NZD',
1325         'TOP',
1326         'TTD',
1327         'TND',
1328         'TRY',
1329         'TRL',
1330         'TMM',
1331         'USD',
1332         'AUD',
1333         'UGX',
1334         'UAH',
1335         'AED',
1336         'GBP',
1337         'USD',
1338         'USS',
1339         'USN',
1340         'USD',
1341         'UYU',
1342         'UZS',
1343         'VUV',
1344         'VEB',
1345         'VND',
1346         'USD',
1347         'USD',
1348         'XPF',
1349         'MAD',
1350         'YER',
1351         'ZMK',
1352         'ZWD',
1353         'XAU',
1354         'XBA',
1355         'XBB',
1356         'XBC',
1357         'XBD',
1358         'XPD',
1359         'XPT',
1360         'XAG',
1361         'XFU',
1362         'XFO',
1363         'XTS',
1364         'XXX',
1365       );
1366     }
1367     return self::$currencyCode;
1368   }
1369
1370   /**
1371    * Get all the County from database.
1372    *
1373    * The static array county is returned, and if it's
1374    * called the first time, the <b>County DAO</b> is used
1375    * to get all the Counties.
1376    *
1377    * Note: any database errors will be trapped by the DAO.
1378    *
1379    * @access public
1380    * @static
1381    *
1382    * @param int $id -  Optional id to return
1383    *
1384    * @return array - array reference of all Counties
1385    *
1386    */
1387   public static function &county($id = FALSE) {
1388     if (!self::$county) {
1389
1390       $config = CRM_Core_Config::singleton();
1391       // order by id so users who populate civicrm_county can have more control over sort by the order they load the counties
1392       self::populate(self::$county, 'CRM_Core_DAO_County', TRUE, 'name', NULL, NULL, 'id');
1393     }
1394     if ($id) {
1395       if (array_key_exists($id, self::$county)) {
1396         return self::$county[$id];
1397       }
1398       else {
1399         return CRM_Core_DAO::$_nullObject;
1400       }
1401     }
1402     return self::$county;
1403   }
1404
1405   /**
1406    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
1407    * Get all active payment processors
1408    *
1409    * The static array paymentProcessor is returned
1410    *
1411    * @access public
1412    * @static
1413    *
1414    * @param boolean $all  - get payment processors     - default is to get only active ones.
1415    * @param boolean $test - get test payment processors
1416    *
1417    * @return array - array of all payment processors
1418    *
1419    */
1420   public static function &paymentProcessor($all = FALSE, $test = FALSE, $additionalCond = NULL) {
1421     $condition = "is_test = ";
1422     $condition .= ($test) ? '1' : '0';
1423
1424     if ($additionalCond) {
1425       $condition .= " AND ( $additionalCond ) ";
1426     }
1427
1428     // CRM-7178. Make sure we only include payment processors valid in ths
1429     // domain
1430     $condition .= " AND domain_id = " . CRM_Core_Config::domainID();
1431
1432     $cacheKey = $condition . '_' . (int) $all;
1433     if (!isset(self::$paymentProcessor[$cacheKey])) {
1434       self::populate(self::$paymentProcessor[$cacheKey], 'CRM_Financial_DAO_PaymentProcessor', $all, 'name', 'is_active', $condition, 'is_default desc, name');
1435     }
1436
1437     return self::$paymentProcessor[$cacheKey];
1438   }
1439
1440   /**
1441    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
1442    *
1443    * The static array paymentProcessorType is returned
1444    *
1445    * @access public
1446    * @static
1447    *
1448    * @param boolean $all  - get payment processors     - default is to get only active ones.
1449    *
1450    * @return array - array of all payment processor types
1451    *
1452    */
1453   public static function &paymentProcessorType($all = FALSE, $id = NULL, $return = 'title') {
1454     $cacheKey = $id . '_' .$return;
1455     if (empty(self::$paymentProcessorType[$cacheKey])) {
1456       self::populate(self::$paymentProcessorType[$cacheKey], 'CRM_Financial_DAO_PaymentProcessorType', $all, $return, 'is_active', NULL, "is_default, $return", 'id');
1457     }
1458     if ($id && CRM_Utils_Array::value($id, self::$paymentProcessorType[$cacheKey])) {
1459       return self::$paymentProcessorType[$cacheKey][$id];
1460     }
1461     return self::$paymentProcessorType[$cacheKey];
1462   }
1463
1464   /**
1465    * Get all the World Regions from Database
1466    *
1467    * @access public
1468    *
1469    * @return array - array reference of all World Regions
1470    * @static
1471    */
1472   public static function &worldRegion($id = FALSE) {
1473     if (!self::$worldRegions) {
1474       self::populate(self::$worldRegions, 'CRM_Core_DAO_Worldregion', TRUE, 'name', NULL, NULL, 'id');
1475     }
1476
1477     if ($id) {
1478       if (array_key_exists($id, self::$worldRegions)) {
1479         return self::$worldRegions[$id];
1480       }
1481       else {
1482         return CRM_Core_DAO::$_nullObject;
1483       }
1484     }
1485
1486     return self::$worldRegions;
1487   }
1488
1489   /**
1490    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
1491    *
1492    * Get all Activity Statuses.
1493    *
1494    * The static array activityStatus is returned
1495    *
1496    * @access public
1497    * @static
1498    *
1499    * @return array - array reference of all activity statuses
1500    */
1501   public static function &activityStatus($column = 'label') {
1502     if (NULL === self::$activityStatus) {
1503       self::$activityStatus = array();
1504     }
1505     if (!array_key_exists($column, self::$activityStatus)) {
1506       self::$activityStatus[$column] = array();
1507
1508       self::$activityStatus[$column] = CRM_Core_OptionGroup::values('activity_status', FALSE, FALSE, FALSE, NULL, $column);
1509     }
1510
1511     return self::$activityStatus[$column];
1512   }
1513
1514   /**
1515    * DEPRECATED. Please use the buildOptions() method in the appropriate BAO object.
1516    *
1517    * Get all Visibility levels.
1518    *
1519    * The static array visibility is returned
1520    *
1521    * @access public
1522    * @static
1523    *
1524    * @return array - array reference of all Visibility levels.
1525    *
1526    */
1527   public static function &visibility($column = 'label') {
1528     if (!isset(self::$visibility)) {
1529       self::$visibility = array( );
1530     }
1531
1532     if (!isset(self::$visibility[$column])) {
1533       self::$visibility[$column] = CRM_Core_OptionGroup::values('visibility', FALSE, FALSE, FALSE, NULL, $column);
1534   }
1535
1536     return self::$visibility[$column];
1537   }
1538
1539   public static function &stateProvinceForCountry($countryID, $field = 'name') {
1540     static $_cache = NULL;
1541
1542     $cacheKey = "{$countryID}_{$field}";
1543     if (!$_cache) {
1544       $_cache = array();
1545     }
1546
1547     if (!empty($_cache[$cacheKey])) {
1548       return $_cache[$cacheKey];
1549     }
1550
1551     $query = "
1552 SELECT civicrm_state_province.{$field} name, civicrm_state_province.id id
1553   FROM civicrm_state_province
1554 WHERE country_id = %1
1555 ORDER BY name";
1556     $params = array(
1557       1 => array(
1558         $countryID,
1559         'Integer',
1560       ),
1561     );
1562
1563     $dao = CRM_Core_DAO::executeQuery($query, $params);
1564
1565     $result = array();
1566     while ($dao->fetch()) {
1567       $result[$dao->id] = $dao->name;
1568     }
1569
1570     // localise the stateProvince names if in an non-en_US locale
1571     $config = CRM_Core_Config::singleton();
1572     global $tsLocale;
1573     if ($tsLocale != '' and $tsLocale != 'en_US') {
1574       $i18n = CRM_Core_I18n::singleton();
1575       $i18n->localizeArray($result, array(
1576         'context' => 'province',
1577       ));
1578       $result = CRM_Utils_Array::asort($result);
1579     }
1580
1581     $_cache[$cacheKey] = $result;
1582
1583     CRM_Utils_Hook::buildStateProvinceForCountry($countryID, $result);
1584
1585     return $result;
1586   }
1587
1588   public static function &countyForState($stateID) {
1589     if (is_array($stateID)) {
1590       $states = implode(", ", $stateID);
1591       $query = "
1592     SELECT civicrm_county.name name, civicrm_county.id id, civicrm_state_province.abbreviation abbreviation
1593       FROM civicrm_county
1594       LEFT JOIN civicrm_state_province ON civicrm_county.state_province_id = civicrm_state_province.id
1595     WHERE civicrm_county.state_province_id in ( $states )
1596     ORDER BY civicrm_state_province.abbreviation, civicrm_county.name";
1597
1598       $dao = CRM_Core_DAO::executeQuery($query);
1599
1600       $result = array();
1601       while ($dao->fetch()) {
1602         $result[$dao->id] = $dao->abbreviation . ': ' . $dao->name;
1603       }
1604     }
1605     else {
1606
1607       static $_cache = NULL;
1608
1609       $cacheKey = "{$stateID}_name";
1610       if (!$_cache) {
1611         $_cache = array();
1612       }
1613
1614       if (!empty($_cache[$cacheKey])) {
1615         return $_cache[$cacheKey];
1616       }
1617
1618       $query = "
1619     SELECT civicrm_county.name name, civicrm_county.id id
1620       FROM civicrm_county
1621     WHERE state_province_id = %1
1622     ORDER BY name";
1623       $params = array(
1624         1 => array(
1625           $stateID,
1626           'Integer',
1627         ),
1628       );
1629
1630       $dao = CRM_Core_DAO::executeQuery($query, $params);
1631
1632       $result = array();
1633       while ($dao->fetch()) {
1634         $result[$dao->id] = $dao->name;
1635       }
1636     }
1637
1638     return $result;
1639   }
1640
1641   /**
1642    * Given a state ID return the country ID, this allows
1643    * us to populate forms and values for downstream code
1644    *
1645    * @param $stateID int
1646    *
1647    * @return int the country id that the state belongs to
1648    * @static
1649    * @public
1650    */
1651   static function countryIDForStateID($stateID) {
1652     if (empty($stateID)) {
1653       return CRM_Core_DAO::$_nullObject;
1654     }
1655
1656     $query = "
1657 SELECT country_id
1658 FROM   civicrm_state_province
1659 WHERE  id = %1
1660 ";
1661     $params = array(1 => array($stateID, 'Integer'));
1662
1663     return CRM_Core_DAO::singleValueQuery($query, $params);
1664   }
1665
1666   /**
1667    * Get all types of Greetings.
1668    *
1669    * The static array of greeting is returned
1670    *
1671    * @access public
1672    * @static
1673    *
1674    * @param $filter - get All Email Greetings - default is to get only active ones.
1675    *
1676    * @return array - array reference of all greetings.
1677    *
1678    */
1679   public static function greeting($filter, $columnName = 'label') {
1680     $index = $filter['greeting_type'] . '_' . $columnName;
1681
1682     // also add contactType to the array
1683     $contactType = CRM_Utils_Array::value('contact_type', $filter);
1684     if ($contactType) {
1685       $index .= '_' . $contactType;
1686     }
1687
1688     if (NULL === self::$greeting) {
1689       self::$greeting = array();
1690     }
1691
1692     if (!CRM_Utils_Array::value($index, self::$greeting)) {
1693       $filterCondition = NULL;
1694       if ($contactType) {
1695         $filterVal = 'v.filter =';
1696         switch ($contactType) {
1697           case 'Individual':
1698             $filterVal .= "1";
1699             break;
1700
1701           case 'Household':
1702             $filterVal .= "2";
1703             break;
1704
1705           case 'Organization':
1706             $filterVal .= "3";
1707             break;
1708         }
1709         $filterCondition .= "AND (v.filter = 0 OR {$filterVal}) ";
1710       }
1711
1712       self::$greeting[$index] = CRM_Core_OptionGroup::values($filter['greeting_type'], NULL, NULL, NULL, $filterCondition, $columnName);
1713     }
1714
1715     return self::$greeting[$index];
1716   }
1717
1718   /**
1719    * Construct array of default greeting values for contact type
1720    *
1721    * @access public
1722    * @static
1723    *
1724    * @return array - array reference of default greetings.
1725    *
1726    */
1727   public static function &greetingDefaults() {
1728     if (!self::$greetingDefaults) {
1729       $defaultGreetings = array();
1730       $contactTypes = self::get('CRM_Contact_DAO_Contact', 'contact_type', array('keyColumn' => 'id', 'labelColumn' => 'name'));
1731
1732       foreach ($contactTypes as $filter => $contactType) {
1733         $filterCondition = " AND (v.filter = 0 OR v.filter = $filter) AND v.is_default = 1 ";
1734
1735         foreach (CRM_Contact_BAO_Contact::$_greetingTypes as $greeting) {
1736           $tokenVal = CRM_Core_OptionGroup::values($greeting, NULL, NULL, NULL, $filterCondition, 'label');
1737           $defaultGreetings[$contactType][$greeting] = $tokenVal;
1738         }
1739       }
1740
1741       self::$greetingDefaults = $defaultGreetings;
1742     }
1743
1744     return self::$greetingDefaults;
1745   }
1746
1747   /**
1748    * Get all extensions
1749    *
1750    * The static array extensions
1751    *
1752    * FIXME: This is called by civix but not by any core code. We
1753    * should provide an API call which civix can use instead.
1754    *
1755    * @access public
1756    * @static
1757    *
1758    * @return array - array($fullyQualifiedName => $label) list of extensions
1759    */
1760   public static function &getExtensions() {
1761     if (!self::$extensions) {
1762       self::$extensions = array();
1763       $sql = '
1764         SELECT full_name, label
1765         FROM civicrm_extension
1766         WHERE is_active = 1
1767       ';
1768       $dao = CRM_Core_DAO::executeQuery($sql);
1769       while ($dao->fetch()) {
1770         self::$extensions[$dao->full_name] = $dao->label;
1771       }
1772     }
1773
1774     return self::$extensions;
1775   }
1776
1777   /**
1778    * Get all options values
1779    *
1780    * The static array option values is returned
1781    *
1782    * @access public
1783    * @static
1784    *
1785    * @param boolean $optionGroupName - get All  Option Group values- default is to get only active ones.
1786    *
1787    * @return array - array reference of all Option Group Name
1788    *
1789    */
1790   public static function accountOptionValues($optionGroupName, $id = null, $condition = null) {
1791     $cacheKey = $optionGroupName . '_' . $condition;
1792     if (empty(self::$accountOptionValues[$cacheKey])) {
1793       self::$accountOptionValues[$cacheKey] = CRM_Core_OptionGroup::values($optionGroupName, false, false, false, $condition);
1794     }
1795     if ($id) {
1796       return CRM_Utils_Array::value($id, self::$accountOptionValues[$cacheKey]);
1797     }
1798
1799     return self::$accountOptionValues[$cacheKey];
1800   }
1801
1802   /**
1803    * Fetch the list of active extensions of type 'module'
1804    *
1805    * @param $fresh bool whether to forcibly reload extensions list from canonical store
1806    * @access public
1807    * @static
1808    *
1809    * @return array - array(array('prefix' => $, 'file' => $))
1810    */
1811   public static function getModuleExtensions($fresh = FALSE) {
1812     return CRM_Extension_System::singleton()->getMapper()->getActiveModuleFiles($fresh);
1813   }
1814 }
1815