CRM/Core/BAO/CustomField.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  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2014
  32  * $Id$
  33  *
  34  */
  35
  36 /**
  37  * Business objects for managing custom data fields.
  38  *
  39  */
  40 class CRM_Core_BAO_CustomField extends CRM_Core_DAO_CustomField {
  41
  42   /**
  43    * Array for valid combinations of data_type & descriptions
  44    *
  45    * @var array
  46    * @static
  47    */
  48   public static $_dataType = NULL;
  49
  50   /**
  51    * Array for valid combinations of data_type & html_type
  52    *
  53    * @var array
  54    * @static
  55    */
  56   public static $_dataToHtml = NULL;
  57
  58   /**
  59    * Array to hold (formatted) fields for import
  60    *
  61    * @var array
  62    * @static
  63    */
  64   public static $_importFields = NULL;
  65
  66   /**
  67    * Build and retrieve the list of data types and descriptions
  68    *
  69    * @param NULL
  70    *
  71    * @return array        Data type => Description
  72    * @access public
  73    * @static
  74    */
  75   static function &dataType() {
  76     if (!(self::$_dataType)) {
  77       self::$_dataType = array(
  78         'String' => ts('Alphanumeric'),
  79         'Int' => ts('Integer'),
  80         'Float' => ts('Number'),
  81         'Money' => ts('Money'),
  82         'Memo' => ts('Note'),
  83         'Date' => ts('Date'),
  84         'Boolean' => ts('Yes or No'),
  85         'StateProvince' => ts('State/Province'),
  86         'Country' => ts('Country'),
  87         'File' => ts('File'),
  88         'Link' => ts('Link'),
  89         'ContactReference' => ts('Contact Reference'),
  90       );
  91     }
  92     return self::$_dataType;
  93   }
  94
  95   /**
  96    * @return array
  97    */
  98   static function dataToHtml() {
  99     if (!self::$_dataToHtml) {
 100       self::$_dataToHtml = array(
 101         array(
 102           'Text' => 'Text', 'Select' => 'Select',
 103           'Radio' => 'Radio', 'CheckBox' => 'CheckBox',
 104           'Multi-Select' => 'Multi-Select',
 105           'AdvMulti-Select' => 'AdvMulti-Select',
 106           'Autocomplete-Select' => 'Autocomplete-Select',
 107         ),
 108         array('Text' => 'Text', 'Select' => 'Select', 'Radio' => 'Radio'),
 109         array('Text' => 'Text', 'Select' => 'Select', 'Radio' => 'Radio'),
 110         array('Text' => 'Text', 'Select' => 'Select', 'Radio' => 'Radio'),
 111         array('TextArea' => 'TextArea', 'RichTextEditor' => 'RichTextEditor'),
 112         array('Date' => 'Select Date'),
 113         array('Radio' => 'Radio'),
 114         array('StateProvince' => 'Select State/Province', 'Multi-Select' => 'Multi-Select State/Province'),
 115         array('Country' => 'Select Country', 'Multi-Select' => 'Multi-Select Country'),
 116         array('File' => 'File'),
 117         array('Link' => 'Link'),
 118         array('ContactReference' => 'Autocomplete-Select'),
 119       );
 120     }
 121     return self::$_dataToHtml;
 122   }
 123
 124   /**
 125    * takes an associative array and creates a custom field object
 126    *
 127    * This function is invoked from within the web form layer and also from the api layer
 128    *
 129    * @param array $params (reference) an assoc array of name/value pairs
 130    *
 131    * @return CRM_Core_DAO_CustomField object
 132    * @access public
 133    * @static
 134    */
 135   static function create(&$params) {
 136     $origParams = array_merge(array(), $params);
 137
 138     if (!isset($params['id'])) {
 139       if (!isset($params['column_name'])) {
 140         // if add mode & column_name not present, calculate it.
 141         $params['column_name'] = strtolower(CRM_Utils_String::munge($params['label'], '_', 32));
 142       }
 143       if (!isset($params['name'])) {
 144         $params['name'] = CRM_Utils_String::munge($params['label'], '_', 64);
 145       }
 146     }
 147     else {
 148       $params['column_name'] = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
 149         $params['id'],
 150         'column_name'
 151       );
 152     }
 153     $columnName = $params['column_name'];
 154
 155     $indexExist = FALSE;
 156     //as during create if field is_searchable we had created index.
 157     if (!empty($params['id'])) {
 158       $indexExist = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField', $params['id'], 'is_searchable');
 159     }
 160
 161     switch (CRM_Utils_Array::value('html_type', $params)){
 162       case 'Select Date':
 163         if(empty($params['date_format'])){
 164           $config = CRM_Core_Config::singleton();
 165           $params['date_format'] = $config->dateInputFormat;
 166         }
 167         break;
 168       case 'CheckBox':
 169       case 'AdvMulti-Select':
 170       case 'Multi-Select':
 171         if (isset($params['default_checkbox_option'])) {
 172           $tempArray = array_keys($params['default_checkbox_option']);
 173           $defaultArray = array();
 174           foreach ($tempArray as $k => $v) {
 175             if ($params['option_value'][$v]) {
 176               $defaultArray[] = $params['option_value'][$v];
 177             }
 178           }
 179
 180           if (!empty($defaultArray)) {
 181             // also add the seperator before and after the value per new conventio (CRM-1604)
 182             $params['default_value'] = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR, $defaultArray) . CRM_Core_DAO::VALUE_SEPARATOR;
 183           }
 184         }
 185         else {
 186           if (!empty($params['default_option']) && isset($params['option_value'][$params['default_option']])
 187           ) {
 188             $params['default_value'] = $params['option_value'][$params['default_option']];
 189           }
 190         }
 191        break;
 192     }
 193
 194     $transaction = new CRM_Core_Transaction();
 195     // create any option group & values if required
 196     if ($params['html_type'] != 'Text' &&
 197       in_array($params['data_type'], array(
 198         'String', 'Int', 'Float', 'Money'))
 199     ) {
 200
 201       $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
 202         $params['custom_group_id'],
 203         'table_name'
 204       );
 205
 206
 207       if ($params['option_type'] == 1) {
 208         // first create an option group for this custom group
 209         $optionGroup = new CRM_Core_DAO_OptionGroup();
 210         $optionGroup->name = "{$columnName}_" . date('YmdHis');
 211         $optionGroup->title = $params['label'];
 212         $optionGroup->is_active = 1;
 213         $optionGroup->save();
 214         $params['option_group_id'] = $optionGroup->id;
 215           if(!empty($params['option_value']) && is_array($params['option_value'])){
 216           foreach ($params['option_value'] as $k => $v) {
 217             if (strlen(trim($v))) {
 218               $optionValue = new CRM_Core_DAO_OptionValue();
 219               $optionValue->option_group_id = $optionGroup->id;
 220               $optionValue->label = $params['option_label'][$k];
 221               $optionValue->name = CRM_Utils_String::titleToVar($params['option_label'][$k]);
 222               switch ($params['data_type']) {
 223                 case 'Money':
 224                   $optionValue->value = CRM_Utils_Rule::cleanMoney($v);
 225                   break;
 226
 227                 case 'Int':
 228                   $optionValue->value = intval($v);
 229                   break;
 230
 231                 case 'Float':
 232                   $optionValue->value = floatval($v);
 233                   break;
 234
 235                 default:
 236                   $optionValue->value = trim($v);
 237               }
 238
 239               $optionValue->weight = $params['option_weight'][$k];
 240               $optionValue->is_active = CRM_Utils_Array::value($k, $params['option_status'], FALSE);
 241               $optionValue->save();
 242             }
 243           }
 244         }
 245       }
 246     }
 247
 248     // check for orphan option groups
 249     if (!empty($params['option_group_id'])) {
 250       if (!empty($params['id'])) {
 251         self::fixOptionGroups($params['id'], $params['option_group_id']);
 252       }
 253
 254       // if we dont have a default value
 255       // retrive it from one of the other custom fields which use this option group
 256       if (empty($params['default_value'])) {
 257         //don't insert only value separator as default value, CRM-4579
 258         $defaultValue = self::getOptionGroupDefault($params['option_group_id'],
 259           $params['html_type']
 260         );
 261
 262         if (!CRM_Utils_System::isNull(explode(CRM_Core_DAO::VALUE_SEPARATOR,
 263               $defaultValue
 264             ))) {
 265           $params['default_value'] = $defaultValue;
 266         }
 267       }
 268     }
 269
 270     // since we need to save option group id :)
 271     if (!isset($params['attributes']) && strtolower($params['html_type']) == 'textarea') {
 272       $params['attributes'] = 'rows=4, cols=60';
 273     }
 274
 275     $customField = new CRM_Core_DAO_CustomField();
 276     $customField->copyValues($params);
 277     $customField->is_required = CRM_Utils_Array::value('is_required', $params, FALSE);
 278     $customField->is_searchable = CRM_Utils_Array::value('is_searchable', $params, FALSE);
 279     $customField->in_selector = CRM_Utils_Array::value('in_selector', $params, FALSE);
 280     $customField->is_search_range = CRM_Utils_Array::value('is_search_range', $params, FALSE);
 281     $customField->is_active = CRM_Utils_Array::value('is_active', $params, FALSE);
 282     $customField->is_view = CRM_Utils_Array::value('is_view', $params, FALSE);
 283     $customField->save();
 284
 285     // make sure all values are present in the object for further processing
 286     $customField->find(TRUE);
 287
 288     $triggerRebuild = CRM_Utils_Array::value('triggerRebuild', $params, TRUE);
 289     //create/drop the index when we toggle the is_searchable flag
 290     if (!empty($params['id'])) {
 291       self::createField($customField, 'modify', $indexExist, $triggerRebuild);
 292     }
 293     else {
 294       if (!isset($origParams['column_name'])) {
 295         $columnName .= "_{$customField->id}";
 296         $params['column_name'] = $columnName;
 297       }
 298       $customField->column_name = $columnName;
 299       $customField->save();
 300       // make sure all values are present in the object
 301       $customField->find(TRUE);
 302
 303       $indexExist = FALSE;
 304       self::createField($customField, 'add', $indexExist, $triggerRebuild);
 305     }
 306
 307     // complete transaction
 308     $transaction->commit();
 309
 310     CRM_Utils_System::flushCache();
 311
 312     return $customField;
 313   }
 314
 315   /**
 316    * Takes a bunch of params that are needed to match certain criteria and
 317    * retrieves the relevant objects. Typically the valid params are only
 318    * contact_id. We'll tweak this function to be more full featured over a period
 319    * of time. This is the inverse function of create. It also stores all the retrieved
 320    * values in the default array
 321    *
 322    * @param array $params   (reference ) an assoc array of name/value pairs
 323    * @param array $defaults (reference ) an assoc array to hold the flattened values
 324    *
 325    * @return object CRM_Core_DAO_CustomField object
 326    * @access public
 327    * @static
 328    */
 329   static function retrieve(&$params, &$defaults) {
 330     return CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_CustomField', $params, $defaults);
 331   }
 332
 333   /**
 334    * update the is_active flag in the db
 335    *
 336    * @param int      $id         Id of the database record
 337    * @param boolean  $is_active  Value we want to set the is_active field
 338    *
 339    * @return   Object            DAO object on sucess, null otherwise
 340    *
 341    * @access public
 342    * @static
 343    */
 344   static function setIsActive($id, $is_active) {
 345
 346     CRM_Utils_System::flushCache();
 347
 348     //enable-disable CustomField
 349     CRM_Core_BAO_UFField::setUFField($id, $is_active);
 350     return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_CustomField', $id, 'is_active', $is_active);
 351   }
 352
 353   /**
 354    * Get the field title.
 355    *
 356    * @param int $id id of field.
 357    *
 358    * @return string name
 359    *
 360    * @access public
 361    * @static
 362    *
 363    */
 364   public static function getTitle($id) {
 365     return CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField', $id, 'label');
 366   }
 367
 368   /**
 369    * Store and return an array of all active custom fields.
 370    *
 371    * @param string      $customDataType      type of Custom Data; empty is a synonym for "all contact data types"
 372    * @param boolean     $showAll             If true returns all fields (includes disabled fields)
 373    * @param boolean     $inline              If true returns all inline fields (includes disabled fields)
 374    * @param int         $customDataSubType   Custom Data sub type value
 375    * @param int         $customDataSubName   Custom Data sub name value
 376    * @param boolean     $onlyParent          return only top level custom data, for eg, only Participant and ignore subname and subtype
 377    * @param boolean     $onlySubType         return only custom data for subtype
 378    * @param boolean     $checkPermission     if false, do not include permissioning clause
 379    *
 380    * @return array      $fields - an array of active custom fields.
 381    *
 382    * @access public
 383    * @static
 384    */
 385   public static function &getFields($customDataType = 'Individual',
 386                                     $showAll = FALSE,
 387                                     $inline = FALSE,
 388                                     $customDataSubType = NULL,
 389                                     $customDataSubName = NULL,
 390                                     $onlyParent = FALSE,
 391                                     $onlySubType = FALSE,
 392                                     $checkPermission = TRUE
 393   ) {
 394     if (empty($customDataType)) {
 395       $customDataType = array('Contact', 'Individual', 'Organization', 'Household');
 396     }
 397     if ($customDataType && !is_array($customDataType)) {
 398
 399       if (in_array($customDataType, CRM_Contact_BAO_ContactType::subTypes())) {
 400         // This is the case when getFieldsForImport() requires fields
 401         // limited strictly to a subtype.
 402         $customDataSubType = $customDataType;
 403         $customDataType = CRM_Contact_BAO_ContactType::getBasicType($customDataType);
 404         $onlySubType = TRUE;
 405       }
 406
 407       if (in_array($customDataType, array_keys(CRM_Core_SelectValues::customGroupExtends()))) {
 408         // this makes the method flexible to support retrieving fields
 409         // for multiple extends value.
 410         $customDataType = array($customDataType);
 411       }
 412     }
 413
 414     $customDataSubType = CRM_Utils_Array::explodePadded($customDataSubType);
 415
 416     if (is_array($customDataType)) {
 417       $cacheKey = implode('_', $customDataType);
 418     }
 419     else {
 420       $cacheKey = $customDataType;
 421     }
 422
 423     $cacheKey .= !empty($customDataSubType) ? ('_' . implode('_', $customDataSubType)) : '_0';
 424     $cacheKey .= $customDataSubName ? "{$customDataSubName}_" : '_0';
 425     $cacheKey .= $showAll ? '_1' : '_0';
 426     $cacheKey .= $inline ? '_1_' : '_0_';
 427     $cacheKey .= $onlyParent ? '_1_' : '_0_';
 428     $cacheKey .= $onlySubType ? '_1_' : '_0_';
 429     $cacheKey .= $checkPermission ? '_1_' : '_0_';
 430
 431     $cgTable = CRM_Core_DAO_CustomGroup::getTableName();
 432
 433     // also get the permission stuff here
 434     if ($checkPermission) {
 435       $permissionClause = CRM_Core_Permission::customGroupClause(CRM_Core_Permission::VIEW,
 436         "{$cgTable}."
 437       );
 438     }
 439     else {
 440       $permissionClause = '(1)';
 441     }
 442
 443     // lets md5 permission clause and take first 8 characters
 444     $cacheKey .= substr(md5($permissionClause), 0, 8);
 445
 446     if (strlen($cacheKey) > 40) {
 447       $cacheKey = md5($cacheKey);
 448     }
 449
 450     if (!self::$_importFields ||
 451       CRM_Utils_Array::value($cacheKey, self::$_importFields) === NULL
 452     ) {
 453       if (!self::$_importFields) {
 454         self::$_importFields = array();
 455       }
 456
 457       // check if we can retrieve from database cache
 458       $fields = CRM_Core_BAO_Cache::getItem('contact fields', "custom importableFields $cacheKey");
 459
 460       if ($fields === NULL) {
 461         $cfTable = self::getTableName();
 462
 463         $extends = '';
 464         if (is_array($customDataType)) {
 465           $value = NULL;
 466           foreach ($customDataType as $dataType) {
 467             if (in_array($dataType, array_keys(CRM_Core_SelectValues::customGroupExtends()))) {
 468               if (in_array($dataType, array('Individual', 'Household', 'Organization'))) {
 469                 $val = "'" . CRM_Utils_Type::escape($dataType, 'String') . "', 'Contact' ";
 470               }
 471               else {
 472                 $val = "'" . CRM_Utils_Type::escape($dataType, 'String') . "'";
 473               }
 474               $value = $value ? $value . ", {$val}" : $val;
 475             }
 476           }
 477           if ($value) {
 478             $extends = "AND   $cgTable.extends IN ( $value ) ";
 479           }
 480         }
 481
 482         if (!empty($customDataType) && empty($extends)) {
 483           // $customDataType specified a filter, but there is no corresponding SQL ($extends)
 484           self::$_importFields[$cacheKey] = array();
 485           return self::$_importFields[$cacheKey];
 486         }
 487
 488         if ($onlyParent) {
 489           $extends .= " AND $cgTable.extends_entity_column_value IS NULL AND $cgTable.extends_entity_column_id IS NULL ";
 490         }
 491
 492         $query = "SELECT $cfTable.id, $cfTable.label,
 493                             $cgTable.title,
 494                             $cfTable.data_type,
 495                             $cfTable.html_type,
 496                             $cfTable.default_value,
 497                             $cfTable.options_per_line, $cfTable.text_length,
 498                             $cfTable.custom_group_id,
 499                             $cfTable.is_required,
 500                             $cgTable.extends, $cfTable.is_search_range,
 501                             $cgTable.extends_entity_column_value,
 502                             $cgTable.extends_entity_column_id,
 503                             $cfTable.is_view,
 504                             $cfTable.option_group_id,
 505                             $cfTable.date_format,
 506                             $cfTable.time_format,
 507                             $cgTable.is_multiple
 508                      FROM $cfTable
 509                      INNER JOIN $cgTable
 510                      ON $cfTable.custom_group_id = $cgTable.id
 511                      WHERE ( 1 ) ";
 512
 513         if (!$showAll) {
 514           $query .= " AND $cfTable.is_active = 1 AND $cgTable.is_active = 1 ";
 515         }
 516
 517         if ($inline) {
 518           $query .= " AND $cgTable.style = 'Inline' ";
 519         }
 520
 521         //get the custom fields for specific type in
 522         //combination with fields those support any type.
 523         if (!empty($customDataSubType)) {
 524           $subtypeClause = array();
 525           foreach ($customDataSubType as $subtype) {
 526             $subtype = CRM_Core_DAO::VALUE_SEPARATOR . $subtype . CRM_Core_DAO::VALUE_SEPARATOR;
 527             $subtypeClause[] = "$cgTable.extends_entity_column_value LIKE '%{$subtype}%'";
 528           }
 529           if (!$onlySubType) {
 530             $subtypeClause[] = "$cgTable.extends_entity_column_value IS NULL";
 531           }
 532           $query .= " AND ( " . implode(' OR ', $subtypeClause) . " )";
 533         }
 534
 535         if ($customDataSubName) {
 536           $query .= " AND ( $cgTable.extends_entity_column_id = $customDataSubName ) ";
 537         }
 538
 539         // also get the permission stuff here
 540         if ($checkPermission) {
 541           $permissionClause = CRM_Core_Permission::customGroupClause(CRM_Core_Permission::VIEW,
 542             "{$cgTable}.", TRUE
 543           );
 544         }
 545         else {
 546           $permissionClause = '(1)';
 547         }
 548
 549         $query .= " $extends AND $permissionClause
 550                         ORDER BY $cgTable.weight, $cgTable.title,
 551                                  $cfTable.weight, $cfTable.label";
 552
 553         $dao = CRM_Core_DAO::executeQuery($query);
 554
 555         $fields = array();
 556         while (($dao->fetch()) != NULL) {
 557           $fields[$dao->id]['label'] = $dao->label;
 558           $fields[$dao->id]['groupTitle'] = $dao->title;
 559           $fields[$dao->id]['data_type'] = $dao->data_type;
 560           $fields[$dao->id]['html_type'] = $dao->html_type;
 561           $fields[$dao->id]['default_value'] = $dao->default_value;
 562           $fields[$dao->id]['text_length'] = $dao->text_length;
 563           $fields[$dao->id]['options_per_line'] = $dao->options_per_line;
 564           $fields[$dao->id]['custom_group_id'] = $dao->custom_group_id;
 565           $fields[$dao->id]['extends'] = $dao->extends;
 566           $fields[$dao->id]['is_search_range'] = $dao->is_search_range;
 567           $fields[$dao->id]['extends_entity_column_value'] = $dao->extends_entity_column_value;
 568           $fields[$dao->id]['extends_entity_column_id'] = $dao->extends_entity_column_id;
 569           $fields[$dao->id]['is_view'] = $dao->is_view;
 570           $fields[$dao->id]['is_multiple'] = $dao->is_multiple;
 571           $fields[$dao->id]['option_group_id'] = $dao->option_group_id;
 572           $fields[$dao->id]['date_format'] = $dao->date_format;
 573           $fields[$dao->id]['time_format'] = $dao->time_format;
 574           $fields[$dao->id]['is_required'] = $dao->is_required;
 575         }
 576
 577         CRM_Core_BAO_Cache::setItem($fields,
 578           'contact fields',
 579           "custom importableFields $cacheKey"
 580         );
 581       }
 582       self::$_importFields[$cacheKey] = $fields;
 583     }
 584
 585     return self::$_importFields[$cacheKey];
 586   }
 587
 588   /**
 589    * Return the field ids and names (with groups) for import purpose.
 590    *
 591    * @param int|string $contactType Contact type
 592    * @param boolean $showAll If true returns all fields (includes disabled fields)
 593    * @param boolean $onlyParent return fields ONLY related to basic types
 594    * @param boolean $search when called from search and multiple records need to be returned
 595    * @param boolean $checkPermission if false, do not include permissioning clause
 596    *
 597    * @param bool $withMultiple
 598    *
 599    * @return array   $fields -
 600    *
 601    * @access public
 602    * @static
 603    */
 604   public static function &getFieldsForImport($contactType = 'Individual',
 605     $showAll         = FALSE,
 606     $onlyParent      = FALSE,
 607     $search          = FALSE,
 608     $checkPermission = TRUE,
 609     $withMultiple    = FALSE
 610   ) {
 611     // Note: there are situations when we want getFieldsForImport() return fields related
 612     // ONLY to basic contact types, but NOT subtypes. And thats where $onlyParent is helpful
 613     $fields = &self::getFields($contactType,
 614       $showAll,
 615       FALSE,
 616       NULL,
 617       NULL,
 618       $onlyParent,
 619       FALSE,
 620       $checkPermission
 621     );
 622
 623     $importableFields = array();
 624     foreach ($fields as $id => $values) {
 625       // for now we should not allow multiple fields in profile / export etc, hence unsetting
 626       if (!$search &&
 627         (!empty($values['is_multiple']) && !$withMultiple)
 628       ) {
 629         continue;
 630       }
 631
 632       /* generate the key for the fields array */
 633
 634       $key = "custom_$id";
 635
 636       $regexp = preg_replace('/[.,;:!?]/', '', CRM_Utils_Array::value(0, $values));
 637       $importableFields[$key] = array(
 638         'name' => $key,
 639         'title' => CRM_Utils_Array::value('label', $values),
 640         'headerPattern' => '/' . preg_quote($regexp, '/') . '/',
 641         'import' => 1,
 642         'custom_field_id' => $id,
 643         'options_per_line' => CRM_Utils_Array::value('options_per_line', $values),
 644         'text_length' => CRM_Utils_Array::value('text_length', $values, 255),
 645         'data_type' => CRM_Utils_Array::value('data_type', $values),
 646         'html_type' => CRM_Utils_Array::value('html_type', $values),
 647         'is_search_range' => CRM_Utils_Array::value('is_search_range', $values),
 648       );
 649
 650       // CRM-6681, pass date and time format when html_type = Select Date
 651       if (CRM_Utils_Array::value('html_type', $values) == 'Select Date') {
 652         $importableFields[$key]['date_format'] = CRM_Utils_Array::value('date_format', $values);
 653         $importableFields[$key]['time_format'] = CRM_Utils_Array::value('time_format', $values);
 654       }
 655     }
 656
 657     return $importableFields;
 658   }
 659
 660   /**
 661    * Get the field id from an import key
 662    *
 663    * @param string $key The key to parse
 664    *
 665    * @param bool $all
 666    * @return int|null         The id (if exists)
 667    * @access public
 668    * @static
 669    */
 670   public static function getKeyID($key, $all = FALSE) {
 671     $match = array();
 672     if (preg_match('/^custom_(\d+)_?(-?\d+)?$/', $key, $match)) {
 673       if (!$all) {
 674         return $match[1];
 675       }
 676       else {
 677         return array(
 678           $match[1],
 679           CRM_Utils_Array::value(2, $match),
 680         );
 681       }
 682     }
 683     return $all ? array(NULL, NULL) : NULL;
 684   }
 685
 686   /**
 687    * Use the cache to get all values of a specific custom field
 688    *
 689    * @param int   $fieldID  the custom field ID
 690    *
 691    * @return CRM_Core_DAO_CustomField $field  the field object
 692    * @static
 693    * public
 694    */
 695   static function getFieldObject($fieldID) {
 696     $field = new CRM_Core_DAO_CustomField();
 697
 698     // check if we can get the field values from the system cache
 699     $cacheKey    = "CRM_Core_DAO_CustomField_{$fieldID}";
 700     $cache       = CRM_Utils_Cache::singleton();
 701     $fieldValues = $cache->get($cacheKey);
 702     if (empty($fieldValues)) {
 703       $field->id = $fieldID;
 704       if (!$field->find(TRUE)) {
 705         CRM_Core_Error::fatal();
 706       }
 707
 708       $fieldValues = array();
 709       CRM_Core_DAO::storeValues($field, $fieldValues);
 710
 711       $cache->set($cacheKey, $fieldValues);
 712     }
 713     else {
 714       $field->copyValues($fieldValues);
 715     }
 716
 717     return $field;
 718   }
 719
 720   /**
 721    * This function for building custom fields
 722    *
 723    * @param CRM_Core_Form $qf form object (reference)
 724    * @param string $elementName name of the custom field
 725    * @param $fieldId
 726    * @param boolean $inactiveNeeded -deprecated
 727    * @param bool $useRequired
 728    * @param boolean $search true if used for search else false
 729    * @param string $label label for custom field
 730    *
 731    * @internal param bool $userRequired true if required else false
 732    * @access public
 733    * @static
 734    */
 735   public static function addQuickFormElement(&$qf,
 736     $elementName,
 737     $fieldId,
 738     $inactiveNeeded = FALSE,
 739     $useRequired    = TRUE,
 740     $search         = FALSE,
 741     $label          = NULL
 742   ) {
 743     $field = self::getFieldObject($fieldId);
 744     $widget = $field->html_type;
 745
 746     // Custom field HTML should indicate group+field name
 747     $groupName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $field->custom_group_id);
 748     $dataCrmCustomVal = $groupName.':'.$field->name;
 749     $dataCrmCustomAttr = 'data-crm-custom="'.$dataCrmCustomVal.'"';
 750     $field->attributes .= $dataCrmCustomAttr;
 751
 752     // Fixed for Issue CRM-2183
 753     if ($widget == 'TextArea' && $search) {
 754       $widget = 'Text';
 755     }
 756
 757     $placeholder = $search ? ts('- any -') : ($useRequired ? ts('- select -') : ts('- none -'));
 758
 759     // FIXME: Why are select state/country separate widget types?
 760     $isSelect = (in_array($widget, array('Select', 'Multi-Select', 'Select State/Province', 'Multi-Select State/Province', 'Select Country', 'Multi-Select Country', 'AdvMulti-Select', 'CheckBox', 'Radio')));
 761
 762     if ($isSelect) {
 763       $options = CRM_Utils_Array::value('values', civicrm_api3('contact', 'getoptions', array('field' => "custom_$fieldId", 'context' => $search ? 'search' : 'create'), array()));
 764
 765       // Consolidate widget types to simplify the below switch statement
 766       if ($search || ($widget !== 'AdvMulti-Select' && strpos($widget, 'Select') !== FALSE)) {
 767         $widget = 'Select';
 768       }
 769       $selectAttributes = array(
 770         'data-crm-custom' => $dataCrmCustomVal,
 771         'class' => 'crm-select2',
 772       );
 773       // Search field is always multi-select
 774       if ($search || strpos($field->html_type, 'Multi') !== FALSE) {
 775         $selectAttributes['class'] .= ' huge';
 776         $selectAttributes['multiple'] = 'multiple';
 777         $selectAttributes['placeholder'] = $placeholder;
 778       }
 779       // Add data for popup link. Normally this is handled by CRM_Core_Form->addSelect
 780       if ($field->option_group_id && !$search && $widget == 'Select' && CRM_Core_Permission::check('administer CiviCRM')) {
 781         $selectAttributes += array(
 782           'data-api-entity' => 'contact', // FIXME: This works because the getoptions api isn't picky about custom fields, but it's WRONG
 783           'data-api-field' => 'custom_' . $field->id,
 784           'data-option-edit-path' => 'civicrm/admin/options/' . CRM_Core_DAO::getFieldValue('CRM_Core_DAO_OptionGroup', $field->option_group_id),
 785         );
 786       }
 787     }
 788
 789     if (!isset($label)) {
 790       $label = $field->label;
 791     }
 792
 793     /**
 794      * at some point in time we might want to split the below into small functions
 795      **/
 796
 797     switch ($widget) {
 798       case 'Text':
 799       case 'Link':
 800         if ($field->is_search_range && $search) {
 801           $qf->add('text', $elementName . '_from', $label . ' ' . ts('From'), $field->attributes);
 802           $qf->add('text', $elementName . '_to', ts('To'), $field->attributes);
 803         }
 804         else {
 805           $element = &$qf->add('text', $elementName, $label,
 806             $field->attributes,
 807             $useRequired && !$search
 808           );
 809         }
 810         break;
 811
 812       case 'TextArea':
 813         $attributes = $dataCrmCustomAttr;
 814         if ($field->note_rows) {
 815           $attributes .= 'rows=' . $field->note_rows;
 816         }
 817         else {
 818           $attributes .= 'rows=4';
 819         }
 820         if ($field->note_columns) {
 821           $attributes .= ' cols=' . $field->note_columns;
 822         }
 823         else {
 824           $attributes .= ' cols=60';
 825         }
 826         if ($field->text_length) {
 827           $attributes .= ' maxlength=' . $field->text_length;
 828         }
 829         $element = &$qf->add('textarea',
 830           $elementName,
 831           $label,
 832           $attributes,
 833           $useRequired && !$search
 834         );
 835         break;
 836
 837       case 'Select Date':
 838         if ($field->is_search_range && $search) {
 839           $qf->addDate($elementName . '_from', $label . ' - ' . ts('From'), FALSE,
 840             array(
 841               'format' => $field->date_format,
 842               'timeFormat' => $field->time_format,
 843               'startOffset' => $field->start_date_years,
 844               'endOffset' => $field->end_date_years,
 845               'data-crm-custom' => $dataCrmCustomVal,
 846             )
 847           );
 848
 849           $qf->addDate($elementName . '_to', ts('To'), FALSE,
 850             array(
 851               'format' => $field->date_format,
 852               'timeFormat' => $field->time_format,
 853               'startOffset' => $field->start_date_years,
 854               'endOffset' => $field->end_date_years,
 855               'data-crm-custom' => $dataCrmCustomVal,
 856             )
 857           );
 858         }
 859         else {
 860           $required = $useRequired && !$search;
 861
 862           $qf->addDate($elementName, $label, $required, array(
 863             'format' => $field->date_format,
 864               'timeFormat' => $field->time_format,
 865               'startOffset' => $field->start_date_years,
 866               'endOffset' => $field->end_date_years,
 867               'data-crm-custom' => $dataCrmCustomVal,
 868             ));
 869         }
 870         break;
 871
 872       case 'Radio':
 873         $choice = array();
 874         foreach ($options as $v => $l) {
 875           $choice[] = $qf->createElement('radio', NULL, '', $l, (string)$v, $field->attributes);
 876         }
 877         $group = $qf->addGroup($choice, $elementName, $label);
 878         if ($useRequired && !$search) {
 879           $qf->addRule($elementName, ts('%1 is a required field.', array(1 => $label)), 'required');
 880         }
 881         else {
 882           $group->setAttribute('allowClear', TRUE);
 883         }
 884         break;
 885
 886       // For all select elements
 887       case 'Select':
 888         if (empty($selectAttributes['multiple'])) {
 889           $options = array('' => $placeholder) + $options;
 890         }
 891         $qf->add('select', $elementName, $label, $options, $useRequired && !$search, $selectAttributes);
 892
 893         // Add and/or option for fields that store multiple values
 894         if ($search && self::isSerialized($field)) {
 895
 896           $operators = array(
 897             $qf->createElement('radio', NULL, '', ts('Any'), 'or', array('title' => ts('Results may contain any of the selected options'))),
 898             $qf->createElement('radio', NULL, '', ts('All'), 'and', array('title' => ts('Results must have all of the selected options'))),
 899           );
 900           $qf->addGroup($operators, $elementName . '_operator');
 901           $qf->setDefaults(array($elementName . '_operator' => 'or'));
 902         }
 903         break;
 904
 905       case 'AdvMulti-Select':
 906         $include =& $qf->addElement(
 907           'advmultiselect',
 908           $elementName,
 909           $label, $options,
 910           array(
 911             'size' => 5,
 912             'style' => '',
 913             'class' => 'advmultiselect',
 914             'data-crm-custom' => $dataCrmCustomVal,
 915           )
 916         );
 917
 918         $include->setButtonAttributes('add', array('value' => ts('Add >>')));
 919         $include->setButtonAttributes('remove', array('value' => ts('<< Remove')));
 920
 921         if ($useRequired && !$search) {
 922           $qf->addRule($elementName, ts('%1 is a required field.', array(1 => $label)), 'required');
 923         }
 924         break;
 925
 926       case 'CheckBox':
 927         $check = array();
 928         foreach ($options as $v => $l) {
 929           $check[] = &$qf->addElement('advcheckbox', $v, NULL, $l, array('data-crm-custom' => $dataCrmCustomVal));
 930         }
 931         $qf->addGroup($check, $elementName, $label);
 932         if ($useRequired && !$search) {
 933           $qf->addRule($elementName, ts('%1 is a required field.', array(1 => $label)), 'required');
 934         }
 935         break;
 936
 937       case 'File':
 938         // we should not build upload file in search mode
 939         if ($search) {
 940           return;
 941         }
 942         $qf->add(
 943           strtolower($field->html_type),
 944           $elementName,
 945           $label,
 946           $field->attributes,
 947           $useRequired && !$search
 948         );
 949         $qf->addUploadElement($elementName);
 950         break;
 951
 952       case 'RichTextEditor':
 953         $attributes = array('rows' => $field->note_rows, 'cols' => $field->note_columns, 'data-crm-custom' => $dataCrmCustomVal);
 954         if ($field->text_length) {
 955           $attributes['maxlength'] = $field->text_length;
 956         }
 957         $qf->addWysiwyg($elementName, $label, $attributes, $search);
 958         break;
 959
 960       case 'Autocomplete-Select':
 961         static $customUrls = array();
 962         // Fixme: why is this a string in the first place??
 963         $attributes = array();
 964         if ($field->attributes) {
 965           foreach(explode(' ', $field->attributes) as $at) {
 966             if (strpos($at, '=')) {
 967               list($k, $v) = explode('=', $at);
 968               $attributes[$k] = trim($v, ' "');
 969             }
 970           }
 971         }
 972         if ($field->data_type == 'ContactReference') {
 973           $attributes['class'] = (isset($attributes['class']) ? $attributes['class'] . ' ' : '') . 'crm-form-contact-reference huge';
 974           $attributes['data-api-entity'] = 'contact';
 975           $qf->add('text', $elementName, $label, $attributes,
 976             $useRequired && !$search
 977           );
 978
 979           $urlParams = "context=customfield&id={$field->id}";
 980
 981           $customUrls[$elementName] = CRM_Utils_System::url('civicrm/ajax/contactref',
 982             $urlParams,
 983             FALSE, NULL, FALSE
 984           );
 985
 986         }
 987         else {
 988           // FIXME: This won't work with customFieldOptions hook
 989           $attributes += array(
 990             'entity' => 'option_value',
 991             'placeholder' => $placeholder,
 992             'multiple' => $search,
 993             'api' => array(
 994               'params' => array('option_group_id' => $field->option_group_id),
 995             ),
 996           );
 997           $qf->addEntityRef($elementName, $label, $attributes, $useRequired && !$search);
 998         }
 999
1000         $qf->assign('customUrls', $customUrls);
1001         break;
1002     }
1003
1004     switch ($field->data_type) {
1005       case 'Int':
1006         // integers will have numeric rule applied to them.
1007         if ($field->is_search_range && $search) {
1008           $qf->addRule($elementName . '_from', ts('%1 From must be an integer (whole number).', array(1 => $label)), 'integer');
1009           $qf->addRule($elementName . '_to', ts('%1 To must be an integer (whole number).', array(1 => $label)), 'integer');
1010         }
1011         elseif ($widget == 'Text') {
1012           $qf->addRule($elementName, ts('%1 must be an integer (whole number).', array(1 => $label)), 'integer');
1013         }
1014         break;
1015
1016       case 'Float':
1017         if ($field->is_search_range && $search) {
1018           $qf->addRule($elementName . '_from', ts('%1 From must be a number (with or without decimal point).', array(1 => $label)), 'numeric');
1019           $qf->addRule($elementName . '_to', ts('%1 To must be a number (with or without decimal point).', array(1 => $label)), 'numeric');
1020         }
1021         elseif ($widget == 'Text') {
1022           $qf->addRule($elementName, ts('%1 must be a number (with or without decimal point).', array(1 => $label)), 'numeric');
1023         }
1024         break;
1025
1026       case 'Money':
1027         if ($field->is_search_range && $search) {
1028           $qf->addRule($elementName . '_from', ts('%1 From must in proper money format. (decimal point/comma/space is allowed).', array(1 => $label)), 'money');
1029           $qf->addRule($elementName . '_to', ts('%1 To must in proper money format. (decimal point/comma/space is allowed).', array(1 => $label)), 'money');
1030         }
1031         elseif ($widget == 'Text') {
1032           $qf->addRule($elementName, ts('%1 must be in proper money format. (decimal point/comma/space is allowed).', array(1 => $label)), 'money');
1033         }
1034         break;
1035
1036       case 'Link':
1037         $element->setAttribute('onfocus', "if (!this.value) {this.value='http://';}");
1038         $element->setAttribute('onblur', "if (this.value == 'http://') {this.value='';}");
1039         $element->setAttribute('class', "url");
1040         $qf->addRule($elementName, ts('Enter a valid Website.'), 'wikiURL');
1041         break;
1042     }
1043     if ($field->is_view && !$search) {
1044       $qf->freeze($elementName);
1045     }
1046   }
1047
1048   /**
1049    * Delete the Custom Field.
1050    *
1051    * @param   object $field - the field object
1052    *
1053    * @return  boolean
1054    *
1055    * @access public
1056    * @static
1057    *
1058    */
1059   public static function deleteField($field) {
1060     CRM_Utils_System::flushCache();
1061
1062     // first delete the custom option group and values associated with this field
1063     if ($field->option_group_id) {
1064       //check if option group is related to any other field, if
1065       //not delete the option group and related option values
1066       self::checkOptionGroup($field->option_group_id);
1067     }
1068
1069     // next drop the column from the custom value table
1070     self::createField($field, 'delete');
1071
1072     $field->delete();
1073     CRM_Core_BAO_UFField::delUFField($field->id);
1074     CRM_Utils_Weight::correctDuplicateWeights('CRM_Core_DAO_CustomField');
1075
1076     return;
1077   }
1078
1079   /**
1080    * Given a custom field value, its id and the set of options
1081    * find the display value for this field
1082    *
1083    * @param mixed $value the custom field value
1084    * @param int $id the custom field id
1085    * @param int $options the assoc array of option name/value pairs
1086    *
1087    * @param null $contactID
1088    * @param null $fieldID
1089    *
1090    * @return  string   the display value
1091    *
1092    * @static
1093    * @access public
1094    */
1095   static function getDisplayValue($value, $id, &$options, $contactID = NULL, $fieldID = NULL) {
1096     $option     = &$options[$id];
1097     $attributes = &$option['attributes'];
1098     $html_type  = $attributes['html_type'];
1099     $data_type  = $attributes['data_type'];
1100     $format     = CRM_Utils_Array::value('format', $attributes);
1101
1102     return self::getDisplayValueCommon($value,
1103       $option,
1104       $html_type,
1105       $data_type,
1106       $format,
1107       $contactID,
1108       $fieldID
1109     );
1110   }
1111
1112   /**
1113    * @param $value
1114    * @param $option
1115    * @param $html_type
1116    * @param $data_type
1117    * @param null $format
1118    * @param null $contactID
1119    * @param null $fieldID
1120    *
1121    * @return array|mixed|null|string
1122    */
1123   static function getDisplayValueCommon($value,
1124     &$option,
1125     $html_type,
1126     $data_type,
1127     $format    = NULL,
1128     $contactID = NULL,
1129     $fieldID   = NULL
1130   ) {
1131     $display = $value;
1132
1133     if ($fieldID &&
1134       (($html_type == 'Radio' && $data_type != 'Boolean') ||
1135         ($html_type == 'Autocomplete-Select' && $data_type != 'ContactReference') ||
1136         $html_type == 'Select' ||
1137         $html_type == 'CheckBox' ||
1138         $html_type == 'AdvMulti-Select' ||
1139         $html_type == 'Multi-Select'
1140       )
1141     ) {
1142       CRM_Utils_Hook::customFieldOptions($fieldID, $option);
1143     }
1144
1145     switch ($html_type) {
1146       case 'Radio':
1147         if ($data_type == 'Boolean') {
1148           // Do not assume that if not yes means no.
1149           $display = '';
1150           if ($value) {
1151             $display = ts('Yes');
1152           }
1153           elseif ((string)$value === '0') {
1154             $display = ts('No');
1155           }
1156         }
1157         else {
1158           $display = CRM_Utils_Array::value($value, $option);
1159         }
1160         break;
1161
1162       case 'Autocomplete-Select':
1163         if ($data_type == 'ContactReference' &&
1164           $value
1165         ) {
1166           $display = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $value, 'display_name');
1167         }
1168         else {
1169           $display = CRM_Utils_Array::value($value, $option);
1170         }
1171         break;
1172
1173       case 'Select':
1174         $display = CRM_Utils_Array::value($value, $option);
1175         break;
1176
1177       case 'CheckBox':
1178       case 'AdvMulti-Select':
1179       case 'Multi-Select':
1180         if (is_array($value)) {
1181           $checkedData = $value;
1182         }
1183         else {
1184           $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR,
1185             substr($value, 1, -1)
1186           );
1187           if ($html_type == 'CheckBox') {
1188             $newData = array();
1189             foreach ($checkedData as $v) {
1190               $newData[$v] = 1;
1191             }
1192             $checkedData = $newData;
1193           }
1194         }
1195
1196         $v = array();
1197         $p = array();
1198         foreach ($checkedData as $key => $val) {
1199           if ($html_type == 'CheckBox') {
1200             if ($val) {
1201               $p[] = $key;
1202               $v[] = CRM_Utils_Array::value($key, $option);
1203             }
1204           }
1205           else {
1206             $p[] = $val;
1207             $v[] = CRM_Utils_Array::value($val, $option);
1208           }
1209         }
1210         if (!empty($v)) {
1211           $display = implode(', ', $v);
1212         }
1213         break;
1214
1215       case 'Select Date':
1216         if (is_array($value)) {
1217           foreach ($value as $key => $val) {
1218             $display[$key] = CRM_Utils_Date::customFormat($val);
1219           }
1220         }
1221         else {
1222           // remove time element display if time is not set
1223           if (empty($option['attributes']['time_format'])) {
1224             $value = substr($value, 0, 10);
1225           }
1226           $display = CRM_Utils_Date::customFormat($value);
1227         }
1228         break;
1229
1230       case 'Select State/Province':
1231         if (empty($value)) {
1232           $display = '';
1233         }
1234         else {
1235           $display = CRM_Core_PseudoConstant::stateProvince($value);
1236         }
1237         break;
1238
1239       case 'Multi-Select State/Province':
1240         if (is_array($value)) {
1241           $checkedData = $value;
1242         }
1243         else {
1244           $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR,
1245             substr($value, 1, -1)
1246           );
1247         }
1248
1249         $states = CRM_Core_PseudoConstant::stateProvince();
1250         $display = NULL;
1251         foreach ($checkedData as $stateID) {
1252           if ($display) {
1253             $display .= ', ';
1254           }
1255           $display .= $states[$stateID];
1256         }
1257         break;
1258
1259       case 'Select Country':
1260         if (empty($value)) {
1261           $display = '';
1262         }
1263         else {
1264           $display = CRM_Core_PseudoConstant::country($value);
1265         }
1266         break;
1267
1268       case 'Multi-Select Country':
1269         if (is_array($value)) {
1270           $checkedData = $value;
1271         }
1272         else {
1273           $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR,
1274             substr($value, 1, -1)
1275           );
1276         }
1277
1278         $countries = CRM_Core_PseudoConstant::country();
1279         $display = NULL;
1280         foreach ($checkedData as $countryID) {
1281           if ($display) {
1282             $display .= ', ';
1283           }
1284           $display .= $countries[$countryID];
1285         }
1286         break;
1287
1288       case 'File':
1289         if ($value) {
1290           $icons = CRM_Core_BAO_File::paperIconAttachment('*', $value);
1291           $display = $icons[$value];
1292         }
1293         break;
1294
1295       case 'TextArea':
1296         if (empty($value)) {
1297           $display = '';
1298         }
1299         else {
1300           $display = nl2br($value);
1301         }
1302         break;
1303
1304       case 'Link':
1305         if (empty($value)) {
1306           $display = '';
1307         }
1308         else {
1309           $display = $value;
1310         }
1311     }
1312     return $display ? $display : $value;
1313   }
1314
1315   /**
1316    * Function to set default values for custom data used in profile
1317    *
1318    * @params int    $customFieldId custom field id
1319    * @params string $elementName   custom field name
1320    * @params array  $defaults      associated array of fields
1321    * @params int    $contactId     contact id
1322    * @param $customFieldId
1323    * @param $elementName
1324    * @param $defaults
1325    * @param null $contactId
1326    * @param  int $mode profile mode
1327    * @param  mixed $value if passed - dont fetch value from db,
1328    *                               just format the given value
1329    *
1330    * @static
1331    * @access public
1332    */
1333   static function setProfileDefaults($customFieldId,
1334     $elementName,
1335     &$defaults,
1336     $contactId = NULL,
1337     $mode = NULL,
1338     $value = NULL
1339   ) {
1340     //get the type of custom field
1341     $customField = new CRM_Core_BAO_CustomField();
1342     $customField->id = $customFieldId;
1343     $customField->find(TRUE);
1344
1345     if (!$contactId) {
1346       if ($mode == CRM_Profile_Form::MODE_CREATE) {
1347         $value = $customField->default_value;
1348       }
1349     }
1350     else {
1351       if (!isset($value)) {
1352         $info   = self::getTableColumnGroup($customFieldId);
1353         $query  = "SELECT {$info[0]}.{$info[1]} as value FROM {$info[0]} WHERE {$info[0]}.entity_id = {$contactId}";
1354         $result = CRM_Core_DAO::executeQuery($query);
1355         if ($result->fetch()) {
1356           $value = $result->value;
1357         }
1358       }
1359
1360       if ($customField->data_type == 'Country') {
1361         if (!$value) {
1362           $config = CRM_Core_Config::singleton();
1363           if ($config->defaultContactCountry) {
1364             $value = $config->defaultContactCountry();
1365           }
1366         }
1367       }
1368     }
1369
1370     //set defaults if mode is registration
1371     if (!trim($value) &&
1372       ($value !== 0) &&
1373       (!in_array($mode, array(CRM_Profile_Form::MODE_EDIT, CRM_Profile_Form::MODE_SEARCH)))
1374     ) {
1375       $value = $customField->default_value;
1376     }
1377
1378     if ($customField->data_type == 'Money' && isset($value)) {
1379       $value = number_format($value, 2);
1380     }
1381     switch ($customField->html_type) {
1382       case 'CheckBox':
1383       case 'AdvMulti-Select':
1384       case 'Multi-Select':
1385         $customOption = CRM_Core_BAO_CustomOption::getCustomOption($customFieldId, FALSE);
1386         $defaults[$elementName] = array();
1387         $checkedValue = explode(CRM_Core_DAO::VALUE_SEPARATOR,
1388           substr($value, 1, -1)
1389         );
1390         foreach ($customOption as $val) {
1391           if (in_array($val['value'], $checkedValue)) {
1392             if ($customField->html_type == 'CheckBox') {
1393               $defaults[$elementName][$val['value']] = 1;
1394             }
1395             elseif ($customField->html_type == 'Multi-Select' ||
1396               $customField->html_type == 'AdvMulti-Select'
1397             ) {
1398               $defaults[$elementName][$val['value']] = $val['value'];
1399             }
1400           }
1401         }
1402         break;
1403
1404       case 'Select Date':
1405         if ($value) {
1406           list($defaults[$elementName], $defaults[$elementName . '_time']) = CRM_Utils_Date::setDateDefaults(
1407             $value,
1408             NULL,
1409             $customField->date_format,
1410             $customField->time_format
1411           );
1412         }
1413         break;
1414
1415       case 'Autocomplete-Select':
1416         if ($customField->data_type == 'ContactReference') {
1417           if (is_numeric($value)) {
1418             $defaults[$elementName . '_id'] = $value;
1419             $defaults[$elementName] = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $value, 'sort_name');
1420           }
1421         }
1422         else {
1423           $defaults[$elementName] = $value;
1424         }
1425         break;
1426
1427       default:
1428         $defaults[$elementName] = $value;
1429     }
1430   }
1431
1432   /**
1433    * @param $contactID
1434    * @param $cfID
1435    * @param null $fileID
1436    * @param bool $absolute
1437    *
1438    * @return array
1439    */
1440   /**
1441    * @param $contactID
1442    * @param $cfID
1443    * @param null $fileID
1444    * @param bool $absolute
1445    *
1446    * @return array
1447    */
1448   static function getFileURL($contactID, $cfID, $fileID = NULL, $absolute = FALSE, $multiRecordWhereClause = NULL) {
1449     if ($contactID) {
1450       if (!$fileID) {
1451         $params = array('id' => $cfID);
1452         $defaults = array();
1453         CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_CustomField', $params, $defaults);
1454         $columnName = $defaults['column_name'];
1455
1456         //table name of custom data
1457         $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
1458           $defaults['custom_group_id'],
1459           'table_name', 'id'
1460         );
1461
1462         //query to fetch id from civicrm_file
1463         if ($multiRecordWhereClause) {
1464           $query = "SELECT {$columnName} FROM {$tableName} where entity_id = {$contactID} AND {$multiRecordWhereClause}";
1465         }
1466         else {
1467           $query = "SELECT {$columnName} FROM {$tableName} where entity_id = {$contactID}";
1468         }
1469         $fileID = CRM_Core_DAO::singleValueQuery($query);
1470       }
1471
1472       $result = array();
1473       if ($fileID) {
1474         $fileType = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_File',
1475           $fileID,
1476           'mime_type',
1477           'id'
1478         );
1479         $result['file_id'] = $fileID;
1480
1481         if ($fileType == 'image/jpeg' ||
1482           $fileType == 'image/pjpeg' ||
1483           $fileType == 'image/gif' ||
1484           $fileType == 'image/x-png' ||
1485           $fileType == 'image/png'
1486         ) {
1487           $entityId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_EntityFile',
1488             $fileID,
1489             'entity_id',
1490             'id'
1491           );
1492           list($path) = CRM_Core_BAO_File::path($fileID, $entityId, NULL, NULL);
1493           list($imageWidth, $imageHeight) = getimagesize($path);
1494           list($imageThumbWidth, $imageThumbHeight) = CRM_Contact_BAO_Contact::getThumbSize($imageWidth, $imageHeight);
1495           $url = CRM_Utils_System::url('civicrm/file',
1496             "reset=1&id=$fileID&eid=$contactID",
1497             $absolute, NULL, TRUE, TRUE
1498           );
1499           $result['file_url'] = "
1500           <a href=\"$url\" class='crm-image-popup'>
1501           <img src=\"$url\" width=$imageThumbWidth height=$imageThumbHeight/>
1502           </a>";
1503           // for non image files
1504         }
1505         else {
1506           $uri = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_File',
1507             $fileID,
1508             'uri'
1509           );
1510           $url = CRM_Utils_System::url('civicrm/file',
1511             "reset=1&id=$fileID&eid=$contactID",
1512             $absolute, NULL, TRUE, TRUE
1513           );
1514           $result['file_url'] = "<a href=\"$url\">{$uri}</a>";
1515         }
1516       }
1517       return $result;
1518     }
1519   }
1520
1521   /**
1522    * Format custom fields before inserting
1523    *
1524    * @param int    $customFieldId       custom field id
1525    * @param array   $customFormatted     formatted array
1526    * @param mix     $value               value of custom field
1527    * @param string  $customFieldExtend   custom field extends
1528    * @param int     $customValueId       custom option value id
1529    * @param int     $entityId            entity id (contribution, membership...)
1530    * @param boolean $inline              consider inline custom groups only
1531    * @param boolean $checkPermission     if false, do not include permissioning clause
1532    * @param boolean $includeViewOnly     if true, fields marked 'View Only' are included. Required for APIv3.
1533    *
1534    * @return array $customFormatted formatted custom field array
1535    * @static
1536    */
1537   static function formatCustomField($customFieldId, &$customFormatted, $value,
1538     $customFieldExtend, $customValueId = NULL,
1539     $entityId = NULL,
1540     $inline = FALSE,
1541     $checkPermission = TRUE,
1542     $includeViewOnly = false
1543   ) {
1544     //get the custom fields for the entity
1545     //subtype and basic type
1546     $customDataSubType = NULL;
1547     if (is_array($customFieldExtend)) {
1548       $customFieldExtend = $customFieldExtend[0];
1549     }
1550
1551     if (in_array($customFieldExtend,
1552         CRM_Contact_BAO_ContactType::subTypes()
1553       )) {
1554       // This is the case when getFieldsForImport() requires fields
1555       // of subtype and its parent.CRM-5143
1556       $customDataSubType = $customFieldExtend;
1557       $customFieldExtend = CRM_Contact_BAO_ContactType::getBasicType($customDataSubType);
1558     }
1559
1560     $customFields = CRM_Core_BAO_CustomField::getFields($customFieldExtend,
1561       FALSE,
1562       $inline,
1563       $customDataSubType,
1564       NULL,
1565       FALSE,
1566       FALSE,
1567       $checkPermission
1568     );
1569
1570     if (!array_key_exists($customFieldId, $customFields)) {
1571       return;
1572     }
1573
1574     // return if field is a 'code' field
1575     if (!$includeViewOnly && !empty($customFields[$customFieldId]['is_view'])) {
1576       return;
1577     }
1578
1579     list($tableName, $columnName, $groupID) = self::getTableColumnGroup($customFieldId);
1580
1581     if (!$customValueId &&
1582       // we always create new entites for is_multiple unless specified
1583       !$customFields[$customFieldId]['is_multiple'] &&
1584       $entityId
1585     ) {
1586       $query = "
1587 SELECT id
1588   FROM $tableName
1589  WHERE entity_id={$entityId}";
1590
1591       $customValueId = CRM_Core_DAO::singleValueQuery($query);
1592     }
1593
1594     //fix checkbox, now check box always submits values
1595     if ($customFields[$customFieldId]['html_type'] == 'CheckBox') {
1596       if ($value) {
1597         // Note that only during merge this is not an array, and you can directly use value
1598         if (is_array($value)) {
1599           $selectedValues = array();
1600           foreach ($value as $selId => $val) {
1601             if ($val) {
1602               $selectedValues[] = $selId;
1603             }
1604           }
1605           if (!empty($selectedValues)) {
1606             $value = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
1607               $selectedValues
1608             ) . CRM_Core_DAO::VALUE_SEPARATOR;
1609           }
1610           else {
1611             $value = '';
1612           }
1613         }
1614       }
1615     }
1616
1617     if ($customFields[$customFieldId]['html_type'] == 'Multi-Select' ||
1618       $customFields[$customFieldId]['html_type'] == 'AdvMulti-Select'
1619     ) {
1620       if ($value) {
1621         // Note that only during merge this is not an array,
1622         // and you can directly use value, CRM-4385
1623         if (is_array($value)) {
1624           $value = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
1625             array_values($value)
1626           ) . CRM_Core_DAO::VALUE_SEPARATOR;
1627         }
1628       }
1629       else {
1630         $value = '';
1631       }
1632     }
1633
1634     if (($customFields[$customFieldId]['html_type'] == 'Multi-Select' ||
1635         $customFields[$customFieldId]['html_type'] == 'AdvMulti-Select' ||
1636         $customFields[$customFieldId]['html_type'] == 'CheckBox'
1637       ) &&
1638       $customFields[$customFieldId]['data_type'] == 'String' &&
1639       !empty($customFields[$customFieldId]['text_length']) &&
1640       !empty($value)
1641     ) {
1642       // lets make sure that value is less than the length, else we'll
1643       // be losing some data, CRM-7481
1644       if (strlen($value) >= $customFields[$customFieldId]['text_length']) {
1645         // need to do a few things here
1646
1647         // 1. lets find a new length
1648         $newLength = $customFields[$customFieldId]['text_length'];
1649         $minLength = strlen($value);
1650         while ($newLength < $minLength) {
1651           $newLength = $newLength * 2;
1652         }
1653
1654         // set the custom field meta data to have a length larger than value
1655         // alter the custom value table column to match this length
1656         CRM_Core_BAO_SchemaHandler::alterFieldLength($customFieldId, $tableName, $columnName, $newLength);
1657       }
1658     }
1659
1660     $date = NULL;
1661     if ($customFields[$customFieldId]['data_type'] == 'Date') {
1662       if (!CRM_Utils_System::isNull($value)) {
1663         $format = $customFields[$customFieldId]['date_format'];
1664         $date = CRM_Utils_Date::processDate($value, NULL, FALSE, 'YmdHis', $format);
1665       }
1666       $value = $date;
1667     }
1668
1669     if ($customFields[$customFieldId]['data_type'] == 'Float' ||
1670       $customFields[$customFieldId]['data_type'] == 'Money'
1671     ) {
1672       if (!$value) {
1673         $value = 0;
1674       }
1675
1676       if ($customFields[$customFieldId]['data_type'] == 'Money') {
1677         $value = CRM_Utils_Rule::cleanMoney($value);
1678       }
1679     }
1680
1681     if (($customFields[$customFieldId]['data_type'] == 'StateProvince' ||
1682         $customFields[$customFieldId]['data_type'] == 'Country'
1683       ) &&
1684       empty($value)
1685     ) {
1686       // CRM-3415
1687       $value = 0;
1688     }
1689
1690     $fileId = NULL;
1691
1692     if ($customFields[$customFieldId]['data_type'] == 'File') {
1693       if (empty($value)) {
1694         return;
1695       }
1696
1697       $config = CRM_Core_Config::singleton();
1698
1699       $fName = $value['name'];
1700       $mimeType = $value['type'];
1701
1702       $filename = pathinfo($fName, PATHINFO_BASENAME);
1703
1704       // rename this file to go into the secure directory
1705       if (!rename($fName, $config->customFileUploadDir . $filename)) {
1706         CRM_Core_Error::statusBounce(ts('Could not move custom file to custom upload directory'));
1707       }
1708
1709       if ($customValueId) {
1710         $query = "
1711 SELECT $columnName
1712   FROM $tableName
1713  WHERE id = %1";
1714         $params = array(1 => array($customValueId, 'Integer'));
1715         $fileId = CRM_Core_DAO::singleValueQuery($query, $params);
1716       }
1717
1718       $fileDAO = new CRM_Core_DAO_File();
1719
1720       if ($fileId) {
1721         $fileDAO->id = $fileId;
1722       }
1723
1724       $fileDAO->uri = $filename;
1725       $fileDAO->mime_type = $mimeType;
1726       $fileDAO->upload_date = date('Ymdhis');
1727       $fileDAO->save();
1728       $fileId = $fileDAO->id;
1729       $value = $filename;
1730     }
1731
1732     if (!is_array($customFormatted)) {
1733       $customFormatted = array();
1734     }
1735
1736     if (!array_key_exists($customFieldId, $customFormatted)) {
1737       $customFormatted[$customFieldId] = array();
1738     }
1739
1740     $index = -1;
1741     if ($customValueId) {
1742       $index = $customValueId;
1743     }
1744
1745     if (!array_key_exists($index, $customFormatted[$customFieldId])) {
1746       $customFormatted[$customFieldId][$index] = array();
1747     }
1748     $customFormatted[$customFieldId][$index] = array(
1749       'id' => $customValueId > 0 ? $customValueId : NULL,
1750       'value' => $value,
1751       'type' => $customFields[$customFieldId]['data_type'],
1752       'custom_field_id' => $customFieldId,
1753       'custom_group_id' => $groupID,
1754       'table_name' => $tableName,
1755       'column_name' => $columnName,
1756       'file_id' => $fileId,
1757       'is_multiple' => $customFields[$customFieldId]['is_multiple'],
1758     );
1759
1760     //we need to sort so that custom fields are created in the order of entry
1761     krsort($customFormatted[$customFieldId]);
1762     return $customFormatted;
1763   }
1764
1765   /**
1766    * @param $params
1767    *
1768    * @return array
1769    */
1770   static function &defaultCustomTableSchema(&$params) {
1771     // add the id and extends_id
1772     $table = array(
1773       'name' => $params['name'],
1774       'is_multiple' => $params['is_multiple'],
1775       'attributes' => "ENGINE=InnoDB DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci",
1776       'fields' => array(
1777         array(
1778           'name' => 'id',
1779           'type' => 'int unsigned',
1780           'primary' => TRUE,
1781           'required' => TRUE,
1782           'attributes' => 'AUTO_INCREMENT',
1783           'comment' => 'Default MySQL primary key',
1784         ),
1785         array(
1786           'name' => 'entity_id',
1787           'type' => 'int unsigned',
1788           'required' => TRUE,
1789           'comment' => 'Table that this extends',
1790           'fk_table_name' => $params['extends_name'],
1791           'fk_field_name' => 'id',
1792           'fk_attributes' => 'ON DELETE CASCADE',
1793         ),
1794       ),
1795     );
1796
1797     if (!$params['is_multiple']) {
1798       $table['indexes'] = array(
1799         array(
1800           'unique' => TRUE,
1801           'field_name_1' => 'entity_id',
1802         ),
1803       );
1804     }
1805     return $table;
1806   }
1807
1808   /**
1809    * @param $field
1810    * @param $operation
1811    * @param bool $indexExist
1812    * @param bool $triggerRebuild
1813    */
1814   static function createField($field, $operation, $indexExist = FALSE, $triggerRebuild = TRUE) {
1815     $tableName = CRM_Core_DAO::getFieldValue(
1816       'CRM_Core_DAO_CustomGroup',
1817       $field->custom_group_id,
1818       'table_name'
1819     );
1820
1821     $params = array(
1822       'table_name' => $tableName,
1823       'operation' => $operation,
1824       'name' => $field->column_name,
1825       'type' => CRM_Core_BAO_CustomValueTable::fieldToSQLType(
1826         $field->data_type,
1827         $field->text_length
1828       ),
1829       'required' => $field->is_required,
1830       'searchable' => $field->is_searchable,
1831     );
1832
1833     if ($operation == 'delete') {
1834       $fkName = "{$tableName}_{$field->column_name}";
1835       if (strlen($fkName) >= 48) {
1836         $fkName = substr($fkName, 0, 32) . '_' . substr(md5($fkName), 0, 16);
1837       }
1838       $params['fkName'] = $fkName;
1839     }
1840     if ($field->data_type == 'Country' && $field->html_type == 'Select Country') {
1841       $params['fk_table_name'] = 'civicrm_country';
1842       $params['fk_field_name'] = 'id';
1843       $params['fk_attributes'] = 'ON DELETE SET NULL';
1844     }
1845     elseif ($field->data_type == 'Country' && $field->html_type == 'Multi-Select Country') {
1846       $params['type'] = 'varchar(255)';
1847     }
1848     elseif ($field->data_type == 'StateProvince' && $field->html_type == 'Select State/Province') {
1849       $params['fk_table_name'] = 'civicrm_state_province';
1850       $params['fk_field_name'] = 'id';
1851       $params['fk_attributes'] = 'ON DELETE SET NULL';
1852     }
1853     elseif ($field->data_type == 'StateProvince' && $field->html_type == 'Multi-Select State/Province') {
1854       $params['type'] = 'varchar(255)';
1855     }
1856     elseif ($field->data_type == 'File') {
1857       $params['fk_table_name'] = 'civicrm_file';
1858       $params['fk_field_name'] = 'id';
1859       $params['fk_attributes'] = 'ON DELETE SET NULL';
1860     }
1861     elseif ($field->data_type == 'ContactReference') {
1862       $params['fk_table_name'] = 'civicrm_contact';
1863       $params['fk_field_name'] = 'id';
1864       $params['fk_attributes'] = 'ON DELETE SET NULL';
1865     }
1866     if ($field->default_value) {
1867       $params['default'] = "'{$field->default_value}'";
1868     }
1869
1870     CRM_Core_BAO_SchemaHandler::alterFieldSQL($params, $indexExist, $triggerRebuild);
1871   }
1872
1873   /**
1874    * Determine whether it would be safe to move a field
1875    *
1876    * @param int $fieldID FK to civicrm_custom_field
1877    * @param int $newGroupID FK to civicrm_custom_group
1878    *
1879    * @return array(
1880      string) or TRUE
1881    */
1882   static function _moveFieldValidate($fieldID, $newGroupID) {
1883     $errors = array();
1884
1885     $field = new CRM_Core_DAO_CustomField();
1886     $field->id = $fieldID;
1887     if (!$field->find(TRUE)) {
1888       $errors['fieldID'] = 'Invalid ID for custom field';
1889       return $errors;
1890     }
1891
1892     $oldGroup = new CRM_Core_DAO_CustomGroup();
1893     $oldGroup->id = $field->custom_group_id;
1894     if (!$oldGroup->find(TRUE)) {
1895       $errors['fieldID'] = 'Invalid ID for old custom group';
1896       return $errors;
1897     }
1898
1899     $newGroup = new CRM_Core_DAO_CustomGroup();
1900     $newGroup->id = $newGroupID;
1901     if (!$newGroup->find(TRUE)) {
1902       $errors['newGroupID'] = 'Invalid ID for new custom group';
1903       return $errors;
1904     }
1905
1906     $query = "
1907 SELECT     b.id
1908 FROM       civicrm_custom_field a
1909 INNER JOIN civicrm_custom_field b
1910 WHERE      a.id = %1
1911 AND        a.label = b.label
1912 AND        b.custom_group_id = %2
1913 ";
1914     $params = array(
1915       1 => array($field->id, 'Integer'),
1916       2 => array($newGroup->id, 'Integer'),
1917     );
1918     $count = CRM_Core_DAO::singleValueQuery($query, $params);
1919     if ($count > 0) {
1920       $errors['newGroupID'] = ts('A field of the same label exists in the destination group');
1921     }
1922
1923     $tableName = $oldGroup->table_name;
1924     $columnName = $field->column_name;
1925
1926     $query = "
1927 SELECT count(*)
1928 FROM   $tableName
1929 WHERE  $columnName is not null
1930 ";
1931     $count = CRM_Core_DAO::singleValueQuery($query,
1932       CRM_Core_DAO::$_nullArray
1933     );
1934     if ($count > 0) {
1935       $query = "
1936 SELECT extends
1937 FROM   civicrm_custom_group
1938 WHERE  id IN ( %1, %2 )
1939 ";
1940       $params = array(1 => array($oldGroup->id, 'Integer'),
1941         2 => array($newGroup->id, 'Integer'),
1942       );
1943
1944       $dao = CRM_Core_DAO::executeQuery($query, $params);
1945       $extends = array();
1946       while ($dao->fetch()) {
1947         $extends[] = $dao->extends;
1948       }
1949       if ($extends[0] != $extends[1]) {
1950         $errors['newGroupID'] = ts('The destination group extends a different entity type.');
1951       }
1952     }
1953
1954     return empty($errors) ? TRUE : $errors;
1955   }
1956
1957   /**
1958    * Move a custom data field from one group (table) to another
1959    *
1960    * @param int $fieldID FK to civicrm_custom_field
1961    * @param int $newGroupID FK to civicrm_custom_group
1962    *
1963    * @return void
1964    */
1965   static function moveField($fieldID, $newGroupID) {
1966     $validation = self::_moveFieldValidate($fieldID, $newGroupID);
1967     if (TRUE !== $validation) {
1968       CRM_Core_Error::fatal(implode(' ', $validation));
1969     }
1970     $field = new CRM_Core_DAO_CustomField();
1971     $field->id = $fieldID;
1972     $field->find(TRUE);
1973
1974     $newGroup = new CRM_Core_DAO_CustomGroup();
1975     $newGroup->id = $newGroupID;
1976     $newGroup->find(TRUE);
1977
1978     $oldGroup = new CRM_Core_DAO_CustomGroup();
1979     $oldGroup->id = $field->custom_group_id;
1980     $oldGroup->find(TRUE);
1981
1982     $add = clone$field;
1983     $add->custom_group_id = $newGroup->id;
1984     self::createField($add, 'add');
1985
1986     $sql = "INSERT INTO {$newGroup->table_name} (entity_id, {$field->column_name})
1987             SELECT entity_id, {$field->column_name} FROM {$oldGroup->table_name}
1988             ON DUPLICATE KEY UPDATE {$field->column_name} = {$oldGroup->table_name}.{$field->column_name}
1989             ";
1990     CRM_Core_DAO::executeQuery($sql);
1991
1992     $del = clone$field;
1993     $del->custom_group_id = $oldGroup->id;
1994     self::createField($del, 'delete');
1995
1996     $add->save();
1997
1998     CRM_Utils_System::flushCache();
1999   }
2000
2001   /**
2002    * Get the database table name and column name for a custom field
2003    *
2004    * @param int     $fieldID - the fieldID of the custom field
2005    * @param boolean $force   - force the sql to be run again (primarily used for tests)
2006    *
2007    * @return array           - fatal is fieldID does not exists, else array of tableName, columnName
2008    * @static
2009    * @public
2010    */
2011   static function getTableColumnGroup($fieldID, $force = FALSE) {
2012     $cacheKey    = "CRM_Core_DAO_CustomField_CustomGroup_TableColumn_{$fieldID}";
2013     $cache       = CRM_Utils_Cache::singleton();
2014     $fieldValues = $cache->get($cacheKey);
2015     if (empty($fieldValues) || $force) {
2016       $query = "
2017 SELECT cg.table_name, cf.column_name, cg.id
2018 FROM   civicrm_custom_group cg,
2019        civicrm_custom_field cf
2020 WHERE  cf.custom_group_id = cg.id
2021 AND    cf.id = %1";
2022       $params = array(1 => array($fieldID, 'Integer'));
2023       $dao = CRM_Core_DAO::executeQuery($query, $params);
2024
2025       if (!$dao->fetch()) {
2026         CRM_Core_Error::fatal();
2027       }
2028       $dao->free();
2029       $fieldValues = array($dao->table_name, $dao->column_name, $dao->id);
2030       $cache->set($cacheKey, $fieldValues);
2031     }
2032     return $fieldValues;
2033   }
2034
2035   /**
2036    * Function to get custom option groups
2037    *
2038    * @params array $includeFieldIds ids of custom fields for which
2039    * option groups must be included.
2040    *
2041    * Currently this is required in the cases where option groups are to be included
2042    * for inactive fields : CRM-5369
2043    *
2044    * @access public
2045    *
2046    * @param null $includeFieldIds
2047    *
2048    * @return mixed $customOptionGroup@static
2049    */
2050   public static function &customOptionGroup($includeFieldIds = NULL) {
2051     static $customOptionGroup = NULL;
2052
2053     $cacheKey = (empty($includeFieldIds)) ? 'onlyActive' : 'force';
2054     if ($cacheKey == 'force') {
2055       $customOptionGroup[$cacheKey] = NULL;
2056     }
2057
2058     if (empty($customOptionGroup[$cacheKey])) {
2059       $whereClause = '( g.is_active = 1 AND f.is_active = 1 )';
2060
2061       //support for single as well as array format.
2062       if (!empty($includeFieldIds)) {
2063         if (is_array($includeFieldIds)) {
2064           $includeFieldIds = implode(',', $includeFieldIds);
2065         }
2066         $whereClause .= "OR f.id IN ( $includeFieldIds )";
2067       }
2068
2069       $query = "
2070     SELECT  g.id, g.title
2071       FROM  civicrm_option_group g
2072 INNER JOIN  civicrm_custom_field f ON ( g.id = f.option_group_id )
2073      WHERE  {$whereClause}";
2074
2075       $dao = CRM_Core_DAO::executeQuery($query);
2076       while ($dao->fetch()) {
2077         $customOptionGroup[$cacheKey][$dao->id] = $dao->title;
2078       }
2079     }
2080
2081     return $customOptionGroup[$cacheKey];
2082   }
2083
2084   /**
2085    * Function to fix orphan groups
2086    *
2087    * @params int $customFieldId custom field id
2088    * @params int $optionGroupId option group id
2089    *
2090    * @access public
2091    *
2092    * @param $customFieldId
2093    * @param $optionGroupId
2094    *
2095    * @return void
2096    * @static
2097    */
2098   static function fixOptionGroups($customFieldId, $optionGroupId) {
2099     // check if option group belongs to any custom Field else delete
2100     // get the current option group
2101     $currentOptionGroupId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
2102       $customFieldId,
2103       'option_group_id'
2104     );
2105     // get the updated option group
2106     // if both are same return
2107     if ($currentOptionGroupId == $optionGroupId) {
2108       return;
2109     }
2110
2111     // check if option group is related to any other field
2112     self::checkOptionGroup($currentOptionGroupId);
2113   }
2114
2115   /**
2116    * Function to check if option group is related to more than one
2117    * custom field
2118    *
2119    * @params int $optionGroupId option group id
2120    *
2121    * @param $optionGroupId
2122    *
2123    * @return void
2124   @static
2125    */
2126   static function checkOptionGroup($optionGroupId) {
2127     $query = "
2128 SELECT count(*)
2129 FROM   civicrm_custom_field
2130 WHERE  option_group_id = {$optionGroupId}";
2131
2132     $count = CRM_Core_DAO::singleValueQuery($query);
2133
2134     if ($count < 2) {
2135       //delete the option group
2136       CRM_Core_BAO_OptionGroup::del($optionGroupId);
2137     }
2138   }
2139
2140   /**
2141    * @param $optionGroupId
2142    * @param $htmlType
2143    *
2144    * @return null|string
2145    */
2146   static function getOptionGroupDefault($optionGroupId, $htmlType) {
2147     $query = "
2148 SELECT   default_value, html_type
2149 FROM     civicrm_custom_field
2150 WHERE    option_group_id = {$optionGroupId}
2151 AND      default_value IS NOT NULL
2152 ORDER BY html_type";
2153
2154     $dao             = CRM_Core_DAO::executeQuery($query);
2155     $defaultValue    = NULL;
2156     $defaultHTMLType = NULL;
2157     while ($dao->fetch()) {
2158       if ($dao->html_type == $htmlType) {
2159         return $dao->default_value;
2160       }
2161       if ($defaultValue == NULL) {
2162         $defaultValue = $dao->default_value;
2163         $defaultHTMLType = $dao->html_type;
2164       }
2165     }
2166
2167     // some conversions are needed if either the old or new has a html type which has potential
2168     // multiple default values.
2169     if (($htmlType == 'CheckBox' || $htmlType == 'Multi-Select') &&
2170       ($defaultHTMLType != 'CheckBox' && $defaultHTMLType != 'Multi-Select')
2171     ) {
2172       $defaultValue = CRM_Core_DAO::VALUE_SEPARATOR . $defaultValue . CRM_Core_DAO::VALUE_SEPARATOR;
2173     }
2174     elseif (($defaultHTMLType == 'CheckBox' || $defaultHTMLType == 'Multi-Select') &&
2175       ($htmlType != 'CheckBox' && $htmlType != 'Multi-Select')
2176     ) {
2177       $defaultValue = substr($defaultValue, 1, -1);
2178       $values = explode(CRM_Core_DAO::VALUE_SEPARATOR,
2179         substr($defaultValue, 1, -1)
2180       );
2181       $defaultValue = $values[0];
2182     }
2183
2184     return $defaultValue;
2185   }
2186
2187   /**
2188    * @param $params
2189    * @param $customFields
2190    * @param $entityID
2191    * @param $customFieldExtends
2192    * @param bool $inline
2193    *
2194    * @return array
2195    */
2196   static function postProcess(&$params,
2197     &$customFields,
2198     $entityID,
2199     $customFieldExtends,
2200     $inline = FALSE
2201   ) {
2202     $customData = array();
2203
2204     foreach ($params as $key => $value) {
2205       if ($customFieldInfo = CRM_Core_BAO_CustomField::getKeyID($key, TRUE)) {
2206
2207         // for autocomplete transfer hidden value instead of label
2208         if ($params[$key] && isset($params[$key . '_id'])) {
2209           $value = $params[$key . '_id'];
2210         }
2211
2212         // we need to append time with date
2213         if ($params[$key] && isset($params[$key . '_time'])) {
2214           $value .= ' ' . $params[$key . '_time'];
2215         }
2216
2217         CRM_Core_BAO_CustomField::formatCustomField($customFieldInfo[0],
2218           $customData,
2219           $value,
2220           $customFieldExtends,
2221           $customFieldInfo[1],
2222           $entityID,
2223           $inline
2224         );
2225       }
2226     }
2227     return $customData;
2228   }
2229
2230   /**
2231    * @param $field
2232    * @param $options
2233    *
2234    * @throws Exception
2235    */
2236   static function buildOption($field, &$options) {
2237     // Fixme - adding anything but options to the $options array is a bad idea
2238     // What if an option had the key 'attributes'?
2239     $options['attributes'] = array(
2240       'label' => $field['label'],
2241       'data_type' => $field['data_type'],
2242       'html_type' => $field['html_type'],
2243     );
2244
2245     $optionGroupID = NULL;
2246     if (($field['html_type'] == 'CheckBox' ||
2247         $field['html_type'] == 'Radio' ||
2248         $field['html_type'] == 'Select' ||
2249         $field['html_type'] == 'AdvMulti-Select' ||
2250         $field['html_type'] == 'Multi-Select' ||
2251         ($field['html_type'] == 'Autocomplete-Select' && $field['data_type'] != 'ContactReference')
2252       )) {
2253       if ($field['option_group_id']) {
2254         $optionGroupID = $field['option_group_id'];
2255       }
2256       elseif ($field['data_type'] != 'Boolean') {
2257         CRM_Core_Error::fatal();
2258       }
2259     }
2260
2261     // build the cache for custom values with options (label => value)
2262     if ($optionGroupID != NULL) {
2263       $query = "
2264 SELECT label, value
2265   FROM civicrm_option_value
2266  WHERE option_group_id = $optionGroupID
2267 ";
2268
2269       $dao = CRM_Core_DAO::executeQuery($query);
2270       while ($dao->fetch()) {
2271         if ($field['data_type'] == 'Int' || $field['data_type'] == 'Float') {
2272           $num = round($dao->value, 2);
2273           $options["$num"] = $dao->label;
2274         }
2275         else {
2276           $options[$dao->value] = $dao->label;
2277         }
2278       }
2279
2280       CRM_Utils_Hook::customFieldOptions($field['id'], $options);
2281     }
2282   }
2283
2284   /**
2285    * @param $fieldLabel
2286    * @param null $groupTitle
2287    *
2288    * @return null
2289    */
2290   static function getCustomFieldID($fieldLabel, $groupTitle = NULL) {
2291     $params = array(1 => array($fieldLabel, 'String'));
2292     if ($groupTitle) {
2293       $params[2] = array($groupTitle, 'String');
2294       $sql = "
2295 SELECT     f.id
2296 FROM       civicrm_custom_field f
2297 INNER JOIN civicrm_custom_group g ON f.custom_group_id = g.id
2298 WHERE      ( f.label = %1 OR f.name  = %1 )
2299 AND        ( g.title = %2 OR g.name = %2 )
2300 ";
2301     }
2302     else {
2303       $sql = "
2304 SELECT     f.id
2305 FROM       civicrm_custom_field f
2306 WHERE      ( f.label = %1 OR f.name = %1 )
2307 ";
2308     }
2309
2310     $dao = CRM_Core_DAO::executeQuery($sql, $params);
2311     if ($dao->fetch() &&
2312       $dao->N == 1
2313     ) {
2314       return $dao->id;
2315     }
2316     else {
2317       return NULL;
2318     }
2319   }
2320
2321   /**
2322    * Given ID of a custom field, return its name as well as the name of the custom group it belongs to.
2323    *
2324    */
2325   static function getNameFromID($ids) {
2326     if (is_array($ids)) {
2327       $ids = implode(',', $ids);
2328     }
2329     $sql = "
2330 SELECT     f.id, f.name AS field_name, f.label AS field_label, g.name AS group_name, g.title AS group_title
2331 FROM       civicrm_custom_field f
2332 INNER JOIN civicrm_custom_group g ON f.custom_group_id = g.id
2333 WHERE      f.id IN ($ids)";
2334
2335
2336     $dao = CRM_Core_DAO::executeQuery($sql);
2337     $result = array();
2338     while ($dao->fetch()) {
2339       $result[$dao->id] = array(
2340         'field_name' => $dao->field_name,
2341         'field_label' => $dao->field_label,
2342         'group_name' => $dao->group_name,
2343         'group_title' => $dao->group_title,
2344       );
2345     }
2346     return $result;
2347   }
2348
2349   /**
2350    * Validate custom data.
2351    *
2352    * @param array $params custom data submitted.
2353    * ie array( 'custom_1' => 'validate me' );
2354    *
2355    * @return array $errors validation errors.
2356    * @static
2357    */
2358   static function validateCustomData($params) {
2359     $errors = array();
2360     if (!is_array($params) || empty($params)) {
2361       return $errors;
2362     }
2363
2364
2365     //pick up profile fields.
2366     $profileFields = array();
2367     $ufGroupId = CRM_Utils_Array::value('ufGroupId', $params);
2368     if ($ufGroupId) {
2369       $profileFields = CRM_Core_BAO_UFGroup::getFields($ufGroupId,
2370         FALSE,
2371         CRM_Core_Action::VIEW
2372       );
2373     }
2374
2375     //lets start w/ params.
2376     foreach ($params as $key => $value) {
2377       $customFieldID = self::getKeyID($key);
2378       if (!$customFieldID) {
2379         continue;
2380       }
2381
2382       //load the structural info for given field.
2383       $field = new CRM_Core_DAO_CustomField();
2384       $field->id = $customFieldID;
2385       if (!$field->find(TRUE)) {
2386         continue;
2387       }
2388       $dataType = $field->data_type;
2389
2390       $profileField = CRM_Utils_Array::value($key, $profileFields, array());
2391       $fieldTitle   = CRM_Utils_Array::value('title', $profileField);
2392       $isRequired   = CRM_Utils_Array::value('is_required', $profileField);
2393       if (!$fieldTitle) {
2394         $fieldTitle = $field->label;
2395       }
2396
2397       //no need to validate.
2398       if (CRM_Utils_System::isNull($value) && !$isRequired) {
2399         continue;
2400       }
2401
2402       //lets validate first for required field.
2403       if ($isRequired && CRM_Utils_System::isNull($value)) {
2404         $errors[$key] = ts('%1 is a required field.', array(1 => $fieldTitle));
2405         continue;
2406       }
2407
2408       //now time to take care of custom field form rules.
2409       $ruleName = $errorMsg = NULL;
2410       switch ($dataType) {
2411         case 'Int':
2412           $ruleName = 'integer';
2413           $errorMsg = ts('%1 must be an integer (whole number).',
2414             array(1 => $fieldTitle)
2415           );
2416           break;
2417
2418         case 'Money':
2419           $ruleName = 'money';
2420           $errorMsg = ts('%1 must in proper money format. (decimal point/comma/space is allowed).',
2421             array(1 => $fieldTitle)
2422           );
2423           break;
2424
2425         case 'Float':
2426           $ruleName = 'numeric';
2427           $errorMsg = ts('%1 must be a number (with or without decimal point).',
2428             array(1 => $fieldTitle)
2429           );
2430           break;
2431
2432         case 'Link':
2433           $ruleName = 'wikiURL';
2434           $errorMsg = ts('%1 must be valid Website.',
2435             array(1 => $fieldTitle)
2436           );
2437           break;
2438       }
2439
2440       if ($ruleName && !CRM_Utils_System::isNull($value)) {
2441         $valid = FALSE;
2442         $funName = "CRM_Utils_Rule::{$ruleName}";
2443         if (is_callable($funName)) {
2444           $valid = call_user_func($funName, $value);
2445         }
2446         if (!$valid) {
2447           $errors[$key] = $errorMsg;
2448         }
2449       }
2450     }
2451
2452     return $errors;
2453   }
2454
2455   /**
2456    * @param $customId
2457    *
2458    * @return bool
2459    */
2460   static function isMultiRecordField($customId) {
2461     $isMultipleWithGid = FALSE;
2462     if (!is_numeric($customId)) {
2463       $customId = self::getKeyID($customId);
2464     }
2465     if (is_numeric($customId)) {
2466       $sql = "SELECT cg.id cgId
2467  FROM civicrm_custom_group cg
2468  INNER JOIN civicrm_custom_field cf
2469  ON cg.id = cf.custom_group_id
2470 WHERE cf.id = %1 AND cg.is_multiple = 1";
2471       $params[1] = array($customId, 'Integer');
2472       $dao = CRM_Core_DAO::executeQuery($sql, $params);
2473       if ($dao->fetch()) {
2474         if ($dao->cgId) {
2475           $isMultipleWithGid = $dao->cgId;
2476         }
2477       }
2478     }
2479
2480     return $isMultipleWithGid;
2481   }
2482
2483   /**
2484    * Does this field store a serialized string?
2485    * @param CRM_Core_DAO_CustomField|array $field
2486    * @return bool
2487    */
2488   static function isSerialized($field) {
2489     // Fields retrieved via api are an array, or from the dao are an object. We'll accept either.
2490     $field = (array) $field;
2491     // FIXME: Currently the only way to know if data is serialized is by looking at the html_type. It would be cleaner to decouple this.
2492     return ($field['html_type'] == 'CheckBox' || strpos($field['html_type'], 'Multi') !== FALSE);
2493   }
2494 }
2495