CRM/Core/BAO/CustomGroup.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 /**
  13  *
  14  * @package CRM
  15  * @copyright CiviCRM LLC https://civicrm.org/licensing
  16  */
  17
  18 /**
  19  * Business object for managing custom data groups.
  20  */
  21 class CRM_Core_BAO_CustomGroup extends CRM_Core_DAO_CustomGroup {
  22
  23   /**
  24    * Class constructor.
  25    */
  26   public function __construct() {
  27     parent::__construct();
  28   }
  29
  30   /**
  31    * Takes an associative array and creates a custom group object.
  32    *
  33    * This function is invoked from within the web form layer and also from the api layer
  34    *
  35    * @param array $params
  36    *   (reference) an assoc array of name/value pairs.
  37    *
  38    * @return CRM_Core_DAO_CustomGroup
  39    * @throws \Exception
  40    */
  41   public static function create(&$params) {
  42     // create custom group dao, populate fields and then save.
  43     $group = new CRM_Core_DAO_CustomGroup();
  44     if (isset($params['title'])) {
  45       $group->title = $params['title'];
  46     }
  47
  48     $extends = CRM_Utils_Array::value('extends', $params, []);
  49     $extendsEntity = $extends[0] ?? NULL;
  50
  51     $participantEntities = [
  52       'ParticipantRole',
  53       'ParticipantEventName',
  54       'ParticipantEventType',
  55     ];
  56
  57     if (in_array($extendsEntity, $participantEntities)) {
  58       $group->extends = 'Participant';
  59     }
  60     else {
  61       $group->extends = $extendsEntity;
  62     }
  63
  64     $group->extends_entity_column_id = 'null';
  65     if (in_array($extendsEntity, $participantEntities)
  66     ) {
  67       $group->extends_entity_column_id = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_OptionValue', $extendsEntity, 'value', 'name');
  68     }
  69
  70     // this is format when form get submit.
  71     $extendsChildType = $extends[1] ?? NULL;
  72     // lets allow user to pass direct child type value, CRM-6893
  73     if (!empty($params['extends_entity_column_value'])) {
  74       $extendsChildType = $params['extends_entity_column_value'];
  75     }
  76     if (!CRM_Utils_System::isNull($extendsChildType)) {
  77       $extendsChildType = implode(CRM_Core_DAO::VALUE_SEPARATOR, $extendsChildType);
  78       if (CRM_Utils_Array::value(0, $extends) == 'Relationship') {
  79         $extendsChildType = str_replace(['_a_b', '_b_a'], [
  80           '',
  81           '',
  82         ], $extendsChildType);
  83       }
  84       if (substr($extendsChildType, 0, 1) != CRM_Core_DAO::VALUE_SEPARATOR) {
  85         $extendsChildType = CRM_Core_DAO::VALUE_SEPARATOR . $extendsChildType .
  86           CRM_Core_DAO::VALUE_SEPARATOR;
  87       }
  88     }
  89     else {
  90       $extendsChildType = 'null';
  91     }
  92     $group->extends_entity_column_value = $extendsChildType;
  93
  94     if (isset($params['id'])) {
  95       $oldWeight = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $params['id'], 'weight', 'id');
  96     }
  97     else {
  98       $oldWeight = 0;
  99     }
 100     $group->weight = CRM_Utils_Weight::updateOtherWeights('CRM_Core_DAO_CustomGroup', $oldWeight, CRM_Utils_Array::value('weight', $params, FALSE));
 101     $fields = [
 102       'style',
 103       'collapse_display',
 104       'collapse_adv_display',
 105       'help_pre',
 106       'help_post',
 107       'is_active',
 108       'is_multiple',
 109       'icon',
 110     ];
 111     $current_db_version = CRM_Core_BAO_Domain::version();
 112     $is_public_version = version_compare($current_db_version, '4.7.19', '>=');
 113     if ($is_public_version) {
 114       $fields[] = 'is_public';
 115     }
 116     foreach ($fields as $field) {
 117       if (isset($params[$field])) {
 118         $group->$field = $params[$field];
 119       }
 120     }
 121     $group->max_multiple = isset($params['is_multiple']) ? (isset($params['max_multiple']) &&
 122       $params['max_multiple'] >= '0'
 123     ) ? $params['max_multiple'] : 'null' : 'null';
 124
 125     $tableName = $tableNameNeedingIndexUpdate = NULL;
 126     if (isset($params['id'])) {
 127       $group->id = $params['id'];
 128
 129       if (isset($params['is_multiple'])) {
 130         // check whether custom group was changed from single-valued to multiple-valued
 131         $isMultiple = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
 132           $params['id'],
 133           'is_multiple'
 134         );
 135
 136         // dev/core#227 Fix issue where is_multiple in params maybe an empty string if checkbox is not rendered on the form.
 137         $paramsIsMultiple = empty($params['is_multiple']) ? 0 : 1;
 138         if ($paramsIsMultiple != $isMultiple) {
 139           $tableNameNeedingIndexUpdate = CRM_Core_DAO::getFieldValue(
 140             'CRM_Core_DAO_CustomGroup',
 141             $params['id'],
 142             'table_name'
 143           );
 144         }
 145       }
 146     }
 147     else {
 148       $group->created_id = $params['created_id'] ?? NULL;
 149       $group->created_date = $params['created_date'] ?? NULL;
 150
 151       // we do this only once, so name never changes
 152       if (isset($params['name'])) {
 153         $group->name = CRM_Utils_String::munge($params['name'], '_', 64);
 154       }
 155       else {
 156         $group->name = CRM_Utils_String::munge($group->title, '_', 64);
 157       }
 158
 159       if (isset($params['table_name'])) {
 160         $tableName = $params['table_name'];
 161
 162         if (CRM_Core_DAO_AllCoreTables::isCoreTable($tableName)) {
 163           // Bad idea.  Prevent group creation because it might lead to a broken configuration.
 164           throw new CRM_Core_Exception(ts('Cannot create custom table because %1 is already a core table.', ['1' => $tableName]));
 165         }
 166       }
 167     }
 168
 169     if (array_key_exists('is_reserved', $params)) {
 170       $group->is_reserved = $params['is_reserved'] ? 1 : 0;
 171     }
 172     $op = isset($params['id']) ? 'edit' : 'create';
 173     CRM_Utils_Hook::pre($op, 'CustomGroup', CRM_Utils_Array::value('id', $params), $params);
 174
 175     // enclose the below in a transaction
 176     $transaction = new CRM_Core_Transaction();
 177
 178     $group->save();
 179     if (!isset($params['id'])) {
 180       if (!isset($params['table_name'])) {
 181         $munged_title = strtolower(CRM_Utils_String::munge($group->title, '_', 13));
 182         $tableName = "civicrm_value_{$munged_title}_{$group->id}";
 183       }
 184       $group->table_name = $tableName;
 185       CRM_Core_DAO::setFieldValue('CRM_Core_DAO_CustomGroup',
 186         $group->id,
 187         'table_name',
 188         $tableName
 189       );
 190
 191       // now create the table associated with this group
 192       self::createTable($group);
 193     }
 194     elseif ($tableNameNeedingIndexUpdate) {
 195       CRM_Core_BAO_SchemaHandler::changeUniqueToIndex($tableNameNeedingIndexUpdate, CRM_Utils_Array::value('is_multiple', $params));
 196     }
 197
 198     if (CRM_Utils_Array::value('overrideFKConstraint', $params) == 1) {
 199       $table = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
 200         $params['id'],
 201         'table_name'
 202       );
 203       CRM_Core_BAO_SchemaHandler::changeFKConstraint($table, self::mapTableName($extendsEntity));
 204     }
 205     $transaction->commit();
 206
 207     // reset the cache
 208     CRM_Utils_System::flushCache();
 209
 210     if ($tableName) {
 211       CRM_Utils_Hook::post('create', 'CustomGroup', $group->id, $group);
 212     }
 213     else {
 214       CRM_Utils_Hook::post('edit', 'CustomGroup', $group->id, $group);
 215     }
 216
 217     return $group;
 218   }
 219
 220   /**
 221    * Fetch object based on array of properties.
 222    *
 223    * @param array $params
 224    *   (reference ) an assoc array of name/value pairs.
 225    * @param array $defaults
 226    *   (reference ) an assoc array to hold the flattened values.
 227    *
 228    * @return CRM_Core_DAO_CustomGroup
 229    */
 230   public static function retrieve(&$params, &$defaults) {
 231     return CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_CustomGroup', $params, $defaults);
 232   }
 233
 234   /**
 235    * Update the is_active flag in the db.
 236    *
 237    * @param int $id
 238    *   Id of the database record.
 239    * @param bool $is_active
 240    *   Value we want to set the is_active field.
 241    *
 242    * @return bool
 243    *   true if we found and updated the object, else false
 244    */
 245   public static function setIsActive($id, $is_active) {
 246     // reset the cache
 247     Civi::cache('fields')->flush();
 248     // reset ACL and system caches.
 249     CRM_Core_BAO_Cache::resetCaches();
 250
 251     if (!$is_active) {
 252       CRM_Core_BAO_UFField::setUFFieldStatus($id, $is_active);
 253     }
 254
 255     return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_CustomGroup', $id, 'is_active', $is_active);
 256   }
 257
 258   /**
 259    * Determine if given entity (sub)type has any custom groups
 260    *
 261    * @param string $extends
 262    *   E.g. "Individual", "Activity".
 263    * @param int $columnId
 264    *   E.g. custom-group matching mechanism (usu NULL for matching on sub type-id); see extends_entity_column_id.
 265    * @param string $columnValue
 266    *   E.g. "Student" or "3" or "3\05"; see extends_entity_column_value.
 267    *
 268    * @return bool
 269    */
 270   public static function hasCustomGroup($extends, $columnId, $columnValue) {
 271     $dao = new CRM_Core_DAO_CustomGroup();
 272     $dao->extends = $extends;
 273     $dao->extends_entity_column_id = $columnId;
 274     $escapedValue = CRM_Core_DAO::VALUE_SEPARATOR . CRM_Core_DAO::escapeString($columnValue) . CRM_Core_DAO::VALUE_SEPARATOR;
 275     $dao->whereAdd("extends_entity_column_value LIKE \"%$escapedValue%\"");
 276     //$dao->extends_entity_column_value = $columnValue;
 277     return (bool) $dao->find();
 278   }
 279
 280   /**
 281    * Determine if there are any CustomGroups for the given $activityTypeId.
 282    * If none found, create one.
 283    *
 284    * @param int $activityTypeId
 285    *
 286    * @return bool
 287    *   TRUE if a group is found or created; FALSE on error
 288    */
 289   public static function autoCreateByActivityType($activityTypeId) {
 290     if (self::hasCustomGroup('Activity', NULL, $activityTypeId)) {
 291       return TRUE;
 292     }
 293     // everything
 294     $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, TRUE, FALSE, 'label', TRUE, FALSE);
 295     $params = [
 296       'version' => 3,
 297       'extends' => 'Activity',
 298       'extends_entity_column_id' => NULL,
 299       'extends_entity_column_value' => CRM_Utils_Array::implodePadded([$activityTypeId]),
 300       'title' => ts('%1 Questions', [1 => $activityTypes[$activityTypeId]]),
 301       'style' => 'Inline',
 302       'is_active' => 1,
 303     ];
 304     $result = civicrm_api('CustomGroup', 'create', $params);
 305     return !$result['is_error'];
 306   }
 307
 308   /**
 309    * Get custom groups/fields data for type of entity in a tree structure representing group->field hierarchy
 310    * This may also include entity specific data values.
 311    *
 312    * An array containing all custom groups and their custom fields is returned.
 313    *
 314    * @param string $entityType
 315    *   Of the contact whose contact type is needed.
 316    * @param array $toReturn
 317    *   What data should be returned. ['custom_group' => ['id', 'name', etc.], 'custom_field' => ['id', 'label', etc.]]
 318    * @param int $entityID
 319    * @param int $groupID
 320    * @param array $subTypes
 321    * @param string $subName
 322    * @param bool $fromCache
 323    * @param bool $onlySubType
 324    *   Only return specified subtype or return specified subtype + unrestricted fields.
 325    * @param bool $returnAll
 326    *   Do not restrict by subtype at all. (The parameter feels a bit cludgey but is only used from the
 327    *   api - through which it is properly tested - so can be refactored with some comfort.)
 328    *
 329    * @param bool $checkPermission
 330    * @param string|int $singleRecord
 331    *   holds 'new' or id if view/edit/copy form for a single record is being loaded.
 332    * @param bool $showPublicOnly
 333    *
 334    * @return array
 335    *   Custom field 'tree'.
 336    *
 337    *   The returned array is keyed by group id and has the custom group table fields
 338    *   and a subkey 'fields' holding the specific custom fields.
 339    *   If entityId is passed in the fields keys have a subkey 'customValue' which holds custom data
 340    *   if set for the given entity. This is structured as an array of values with each one having the keys 'id', 'data'
 341    *
 342    * @todo - review this  - It also returns an array called 'info' with tables, select, from, where keys
 343    *   The reason for the info array in unclear and it could be determined from parsing the group tree after creation
 344    *   With caching the performance impact would be small & the function would be cleaner
 345    *
 346    * @throws \CRM_Core_Exception
 347    */
 348   public static function getTree(
 349     $entityType,
 350     $toReturn = [],
 351     $entityID = NULL,
 352     $groupID = NULL,
 353     $subTypes = [],
 354     $subName = NULL,
 355     $fromCache = TRUE,
 356     $onlySubType = NULL,
 357     $returnAll = FALSE,
 358     $checkPermission = TRUE,
 359     $singleRecord = NULL,
 360     $showPublicOnly = FALSE
 361   ) {
 362     if ($entityID) {
 363       $entityID = CRM_Utils_Type::escape($entityID, 'Integer');
 364     }
 365     if (!is_array($subTypes)) {
 366       if (empty($subTypes)) {
 367         $subTypes = [];
 368       }
 369       else {
 370         if (stristr($subTypes, ',')) {
 371           $subTypes = explode(',', $subTypes);
 372         }
 373         else {
 374           $subTypes = explode(CRM_Core_DAO::VALUE_SEPARATOR, trim($subTypes, CRM_Core_DAO::VALUE_SEPARATOR));
 375         }
 376       }
 377     }
 378
 379     // create a new tree
 380
 381     // legacy hardcoded list of data to return
 382     $tableData = [
 383       'custom_field' => [
 384         'id',
 385         'name',
 386         'label',
 387         'column_name',
 388         'data_type',
 389         'html_type',
 390         'default_value',
 391         'attributes',
 392         'is_required',
 393         'is_view',
 394         'help_pre',
 395         'help_post',
 396         'options_per_line',
 397         'start_date_years',
 398         'end_date_years',
 399         'date_format',
 400         'time_format',
 401         'option_group_id',
 402         'in_selector',
 403       ],
 404       'custom_group' => [
 405         'id',
 406         'name',
 407         'table_name',
 408         'title',
 409         'help_pre',
 410         'help_post',
 411         'collapse_display',
 412         'style',
 413         'is_multiple',
 414         'extends',
 415         'extends_entity_column_id',
 416         'extends_entity_column_value',
 417         'max_multiple',
 418       ],
 419     ];
 420     $current_db_version = CRM_Core_BAO_Domain::version();
 421     $is_public_version = version_compare($current_db_version, '4.7.19', '>=');
 422     $serialize_version = version_compare($current_db_version, '5.27.alpha1', '>=');
 423     if ($is_public_version) {
 424       $tableData['custom_group'][] = 'is_public';
 425     }
 426     if ($serialize_version) {
 427       $tableData['custom_field'][] = 'serialize';
 428     }
 429     if (!$toReturn || !is_array($toReturn)) {
 430       $toReturn = $tableData;
 431     }
 432     else {
 433       // Supply defaults and remove unknown array keys
 434       $toReturn = array_intersect_key(array_filter($toReturn) + $tableData, $tableData);
 435       // Merge in required fields that we must have
 436       $toReturn['custom_field'] = array_unique(array_merge($toReturn['custom_field'], ['id', 'column_name', 'data_type']));
 437       $toReturn['custom_group'] = array_unique(array_merge($toReturn['custom_group'], ['id', 'is_multiple', 'table_name', 'name']));
 438       // Validate return fields
 439       $toReturn['custom_field'] = array_intersect($toReturn['custom_field'], array_keys(CRM_Core_DAO_CustomField::fieldKeys()));
 440       $toReturn['custom_group'] = array_intersect($toReturn['custom_group'], array_keys(CRM_Core_DAO_CustomGroup::fieldKeys()));
 441     }
 442
 443     // create select
 444     $select = [];
 445     foreach ($toReturn as $tableName => $tableColumn) {
 446       foreach ($tableColumn as $columnName) {
 447         $select[] = "civicrm_{$tableName}.{$columnName} as civicrm_{$tableName}_{$columnName}";
 448       }
 449     }
 450     $strSelect = "SELECT " . implode(', ', $select);
 451
 452     // from, where, order by
 453     $strFrom = "
 454 FROM     civicrm_custom_group
 455 LEFT JOIN civicrm_custom_field ON (civicrm_custom_field.custom_group_id = civicrm_custom_group.id)
 456 ";
 457
 458     // if entity is either individual, organization or household pls get custom groups for 'contact' too.
 459     if ($entityType == "Individual" || $entityType == 'Organization' ||
 460       $entityType == 'Household'
 461     ) {
 462       $in = "'$entityType', 'Contact'";
 463     }
 464     elseif (strpos($entityType, "'") !== FALSE) {
 465       // this allows the calling function to send in multiple entity types
 466       $in = $entityType;
 467     }
 468     else {
 469       // quote it
 470       $in = "'$entityType'";
 471     }
 472
 473     $params = [];
 474     $sqlParamKey = 1;
 475     $subType = '';
 476     if (!empty($subTypes)) {
 477       foreach ($subTypes as $key => $subType) {
 478         $subTypeClauses[] = self::whereListHas("civicrm_custom_group.extends_entity_column_value", self::validateSubTypeByEntity($entityType, $subType));
 479       }
 480       $subTypeClause = '(' . implode(' OR ', $subTypeClauses) . ')';
 481       if (!$onlySubType) {
 482         $subTypeClause = '(' . $subTypeClause . '  OR civicrm_custom_group.extends_entity_column_value IS NULL )';
 483       }
 484
 485       $strWhere = "
 486 WHERE civicrm_custom_group.is_active = 1
 487   AND civicrm_custom_field.is_active = 1
 488   AND civicrm_custom_group.extends IN ($in)
 489   AND $subTypeClause
 490 ";
 491       if ($subName) {
 492         $strWhere .= " AND civicrm_custom_group.extends_entity_column_id = %{$sqlParamKey}";
 493         $params[$sqlParamKey] = [$subName, 'String'];
 494         $sqlParamKey = $sqlParamKey + 1;
 495       }
 496     }
 497     else {
 498       $strWhere = "
 499 WHERE civicrm_custom_group.is_active = 1
 500   AND civicrm_custom_field.is_active = 1
 501   AND civicrm_custom_group.extends IN ($in)
 502 ";
 503       if (!$returnAll) {
 504         $strWhere .= "AND civicrm_custom_group.extends_entity_column_value IS NULL";
 505       }
 506     }
 507
 508     if ($groupID > 0) {
 509       // since we want a specific group id we add it to the where clause
 510       $strWhere .= " AND civicrm_custom_group.id = %{$sqlParamKey}";
 511       $params[$sqlParamKey] = [$groupID, 'Integer'];
 512     }
 513     elseif (!$groupID) {
 514       // since groupID is false we need to show all Inline groups
 515       $strWhere .= " AND civicrm_custom_group.style = 'Inline'";
 516     }
 517     if ($checkPermission) {
 518       // ensure that the user has access to these custom groups
 519       $strWhere .= " AND " .
 520         CRM_Core_Permission::customGroupClause(CRM_Core_Permission::VIEW,
 521           'civicrm_custom_group.'
 522         );
 523     }
 524
 525     if ($showPublicOnly && $is_public_version) {
 526       $strWhere .= "AND civicrm_custom_group.is_public = 1";
 527     }
 528
 529     $orderBy = "
 530 ORDER BY civicrm_custom_group.weight,
 531          civicrm_custom_group.title,
 532          civicrm_custom_field.weight,
 533          civicrm_custom_field.label
 534 ";
 535
 536     // final query string
 537     $queryString = "$strSelect $strFrom $strWhere $orderBy";
 538
 539     // lets see if we can retrieve the groupTree from cache
 540     $cacheString = $queryString;
 541     if ($groupID > 0) {
 542       $cacheString .= "_{$groupID}";
 543     }
 544     else {
 545       $cacheString .= "_Inline";
 546     }
 547
 548     $cacheKey = "CRM_Core_DAO_CustomGroup_Query " . md5($cacheString);
 549     $multipleFieldGroupCacheKey = "CRM_Core_DAO_CustomGroup_QueryMultipleFields " . md5($cacheString);
 550     $cache = CRM_Utils_Cache::singleton();
 551     if ($fromCache) {
 552       $groupTree = $cache->get($cacheKey);
 553       $multipleFieldGroups = $cache->get($multipleFieldGroupCacheKey);
 554     }
 555
 556     if (empty($groupTree)) {
 557       list($multipleFieldGroups, $groupTree) = self::buildGroupTree($entityType, $toReturn, $subTypes, $queryString, $params, $subType);
 558
 559       $cache->set($cacheKey, $groupTree);
 560       $cache->set($multipleFieldGroupCacheKey, $multipleFieldGroups);
 561     }
 562     // entitySelectClauses is an array of select clauses for custom value tables which are not multiple
 563     // and have data for the given entities. $entityMultipleSelectClauses is the same for ones with multiple
 564     $entitySingleSelectClauses = $entityMultipleSelectClauses = $groupTree['info']['select'] = [];
 565     $singleFieldTables = [];
 566     // now that we have all the groups and fields, lets get the values
 567     // since we need to know the table and field names
 568     // add info to groupTree
 569
 570     if (isset($groupTree['info']) && !empty($groupTree['info']) &&
 571       !empty($groupTree['info']['tables']) && $singleRecord != 'new'
 572     ) {
 573       $select = $from = $where = [];
 574       $groupTree['info']['where'] = NULL;
 575
 576       foreach ($groupTree['info']['tables'] as $table => $fields) {
 577         $groupTree['info']['from'][] = $table;
 578         $select = [
 579           "{$table}.id as {$table}_id",
 580           "{$table}.entity_id as {$table}_entity_id",
 581         ];
 582         foreach ($fields as $column => $dontCare) {
 583           $select[] = "{$table}.{$column} as {$table}_{$column}";
 584         }
 585         $groupTree['info']['select'] = array_merge($groupTree['info']['select'], $select);
 586         if ($entityID) {
 587           $groupTree['info']['where'][] = "{$table}.entity_id = $entityID";
 588           if (in_array($table, $multipleFieldGroups) &&
 589             self::customGroupDataExistsForEntity($entityID, $table)
 590           ) {
 591             $entityMultipleSelectClauses[$table] = $select;
 592           }
 593           else {
 594             $singleFieldTables[] = $table;
 595             $entitySingleSelectClauses = array_merge($entitySingleSelectClauses, $select);
 596           }
 597
 598         }
 599       }
 600       if ($entityID && !empty($singleFieldTables)) {
 601         self::buildEntityTreeSingleFields($groupTree, $entityID, $entitySingleSelectClauses, $singleFieldTables);
 602       }
 603       $multipleFieldTablesWithEntityData = array_keys($entityMultipleSelectClauses);
 604       if (!empty($multipleFieldTablesWithEntityData)) {
 605         self::buildEntityTreeMultipleFields($groupTree, $entityID, $entityMultipleSelectClauses, $multipleFieldTablesWithEntityData, $singleRecord);
 606       }
 607
 608     }
 609     return $groupTree;
 610   }
 611
 612   /**
 613    * Clean and validate the filter before it is used in a db query.
 614    *
 615    * @param string $entityType
 616    * @param string $subType
 617    *
 618    * @return string
 619    * @throws \CRM_Core_Exception
 620    */
 621   protected static function validateSubTypeByEntity($entityType, $subType) {
 622     $subType = trim($subType, CRM_Core_DAO::VALUE_SEPARATOR);
 623     if (is_numeric($subType)) {
 624       return $subType;
 625     }
 626
 627     $contactTypes = CRM_Contact_BAO_ContactType::basicTypeInfo(TRUE);
 628     $contactTypes = array_merge($contactTypes, ['Event' => 1]);
 629
 630     if ($entityType != 'Contact' && !array_key_exists($entityType, $contactTypes)) {
 631       throw new CRM_Core_Exception('Invalid Entity Filter');
 632     }
 633     $subTypes = CRM_Contact_BAO_ContactType::subTypeInfo($entityType, TRUE);
 634     $subTypes = array_merge($subTypes, CRM_Event_PseudoConstant::eventType());
 635     if (!array_key_exists($subType, $subTypes)) {
 636       throw new CRM_Core_Exception('Invalid Filter');
 637     }
 638     return $subType;
 639   }
 640
 641   /**
 642    * Suppose you have a SQL column, $column, which includes a delimited list, and you want
 643    * a WHERE condition for rows that include $value. Use whereListHas().
 644    *
 645    * @param string $column
 646    * @param string $value
 647    * @param string $delimiter
 648    * @return string
 649    *   SQL condition.
 650    */
 651   private static function whereListHas($column, $value, $delimiter = CRM_Core_DAO::VALUE_SEPARATOR) {
 652     // ?
 653     $bareValue = trim($value, $delimiter);
 654     $escapedValue = CRM_Utils_Type::escape("%{$delimiter}{$bareValue}{$delimiter}%", 'String', FALSE);
 655     return "($column LIKE \"$escapedValue\")";
 656   }
 657
 658   /**
 659    * Check whether the custom group has any data for the given entity.
 660    *
 661    * @param int $entityID
 662    *   Id of entity for whom we are checking data for.
 663    * @param string $table
 664    *   Table that we are checking.
 665    *
 666    * @param bool $getCount
 667    *
 668    * @return bool
 669    *   does this entity have data in this custom table
 670    */
 671   public static function customGroupDataExistsForEntity($entityID, $table, $getCount = FALSE) {
 672     $query = "
 673       SELECT count(id)
 674       FROM   $table
 675       WHERE  entity_id = $entityID
 676     ";
 677     $recordExists = CRM_Core_DAO::singleValueQuery($query);
 678     if ($getCount) {
 679       return $recordExists;
 680     }
 681     return (bool) $recordExists;
 682   }
 683
 684   /**
 685    * Build the group tree for Custom fields which are not 'is_multiple'
 686    *
 687    * The combination of all these fields in one query with a 'using' join was not working for
 688    * multiple fields. These now have a new behaviour (one at a time) but the single fields still use this
 689    * mechanism as it seemed to be acceptable in this context
 690    *
 691    * @param array $groupTree
 692    *   (reference) group tree array which is being built.
 693    * @param int $entityID
 694    *   Id of entity for whom the tree is being build up.
 695    * @param array $entitySingleSelectClauses
 696    *   Array of select clauses relevant to the entity.
 697    * @param array $singleFieldTablesWithEntityData
 698    *   Array of tables in which this entity has data.
 699    */
 700   public static function buildEntityTreeSingleFields(&$groupTree, $entityID, $entitySingleSelectClauses, $singleFieldTablesWithEntityData) {
 701     $select = implode(', ', $entitySingleSelectClauses);
 702     $fromSQL = " (SELECT $entityID as entity_id ) as first ";
 703     foreach ($singleFieldTablesWithEntityData as $table) {
 704       $fromSQL .= "\nLEFT JOIN $table USING (entity_id)";
 705     }
 706
 707     $query = "
 708       SELECT $select
 709       FROM $fromSQL
 710       WHERE first.entity_id = $entityID
 711     ";
 712     self::buildTreeEntityDataFromQuery($groupTree, $query, $singleFieldTablesWithEntityData);
 713   }
 714
 715   /**
 716    * Build the group tree for Custom fields which are  'is_multiple'
 717    *
 718    * This is done one table at a time to avoid Cross-Joins resulting in too many rows being returned
 719    *
 720    * @param array $groupTree
 721    *   (reference) group tree array which is being built.
 722    * @param int $entityID
 723    *   Id of entity for whom the tree is being build up.
 724    * @param array $entityMultipleSelectClauses
 725    *   Array of select clauses relevant to the entity.
 726    * @param array $multipleFieldTablesWithEntityData
 727    *   Array of tables in which this entity has data.
 728    * @param string|int $singleRecord
 729    *   holds 'new' or id if view/edit/copy form for a single record is being loaded.
 730    */
 731   public static function buildEntityTreeMultipleFields(&$groupTree, $entityID, $entityMultipleSelectClauses, $multipleFieldTablesWithEntityData, $singleRecord = NULL) {
 732     foreach ($entityMultipleSelectClauses as $table => $selectClauses) {
 733       $select = implode(',', $selectClauses);
 734       $query = "
 735         SELECT $select
 736         FROM $table
 737         WHERE entity_id = $entityID
 738       ";
 739       if ($singleRecord) {
 740         $offset = $singleRecord - 1;
 741         $query .= " LIMIT {$offset}, 1";
 742       }
 743       self::buildTreeEntityDataFromQuery($groupTree, $query, [$table], $singleRecord);
 744     }
 745   }
 746
 747   /**
 748    * Build the tree entity data - starting from a query retrieving the custom fields build the group
 749    * tree data for the relevant entity (entity is included in the query).
 750    *
 751    * This function represents shared code between the buildEntityTreeMultipleFields & the buildEntityTreeSingleFields function
 752    *
 753    * @param array $groupTree
 754    *   (reference) group tree array which is being built.
 755    * @param string $query
 756    * @param array $includedTables
 757    *   Tables to include - required because the function (for historical reasons).
 758    *   iterates through the group tree
 759    * @param string|int $singleRecord
 760    *   holds 'new' OR id if view/edit/copy form for a single record is being loaded.
 761    */
 762   public static function buildTreeEntityDataFromQuery(&$groupTree, $query, $includedTables, $singleRecord = NULL) {
 763     $dao = CRM_Core_DAO::executeQuery($query);
 764     while ($dao->fetch()) {
 765       foreach ($groupTree as $groupID => $group) {
 766         if ($groupID === 'info') {
 767           continue;
 768         }
 769         $table = $groupTree[$groupID]['table_name'];
 770         //working from the groupTree instead of the table list means we have to iterate & exclude.
 771         // this could possibly be re-written as other parts of the function have been refactored
 772         // for now we just check if the given table is to be included in this function
 773         if (!in_array($table, $includedTables)) {
 774           continue;
 775         }
 776         foreach ($group['fields'] as $fieldID => $dontCare) {
 777           self::buildCustomFieldData($dao, $groupTree, $table, $groupID, $fieldID, $singleRecord);
 778         }
 779       }
 780     }
 781   }
 782
 783   /**
 784    * Build the entity-specific custom data into the group tree on a per-field basis
 785    *
 786    * @param object $dao
 787    *   Object representing the custom field to be populated into the groupTree.
 788    * @param array $groupTree
 789    *   (reference) the group tree being build.
 790    * @param string $table
 791    *   Table name.
 792    * @param int $groupID
 793    *   Custom group ID.
 794    * @param int $fieldID
 795    *   Custom field ID.
 796    * @param string|int $singleRecord
 797    *   holds 'new' or id if loading view/edit/copy for a single record.
 798    */
 799   public static function buildCustomFieldData($dao, &$groupTree, $table, $groupID, $fieldID, $singleRecord = NULL) {
 800     $column = $groupTree[$groupID]['fields'][$fieldID]['column_name'];
 801     $idName = "{$table}_id";
 802     $fieldName = "{$table}_{$column}";
 803     $dataType = $groupTree[$groupID]['fields'][$fieldID]['data_type'];
 804     if ($dataType == 'File') {
 805       if (isset($dao->$fieldName)) {
 806         $config = CRM_Core_Config::singleton();
 807         $fileDAO = new CRM_Core_DAO_File();
 808         $fileDAO->id = $dao->$fieldName;
 809
 810         if ($fileDAO->find(TRUE)) {
 811           $entityIDName = "{$table}_entity_id";
 812           $fileHash = CRM_Core_BAO_File::generateFileHash($dao->$entityIDName, $fileDAO->id);
 813           $customValue['id'] = $dao->$idName;
 814           $customValue['data'] = $fileDAO->uri;
 815           $customValue['fid'] = $fileDAO->id;
 816           $customValue['fileURL'] = CRM_Utils_System::url('civicrm/file', "reset=1&id={$fileDAO->id}&eid={$dao->$entityIDName}&fcs=$fileHash");
 817           $customValue['displayURL'] = NULL;
 818           $deleteExtra = ts('Are you sure you want to delete attached file.');
 819           $deleteURL = [
 820             CRM_Core_Action::DELETE => [
 821               'name' => ts('Delete Attached File'),
 822               'url' => 'civicrm/file',
 823               'qs' => 'reset=1&id=%%id%%&eid=%%eid%%&fid=%%fid%%&action=delete&fcs=%%fcs%%',
 824               'extra' => 'onclick = "if (confirm( \'' . $deleteExtra
 825               . '\' ) ) this.href+=\'&amp;confirmed=1\'; else return false;"',
 826             ],
 827           ];
 828           $customValue['deleteURL'] = CRM_Core_Action::formLink($deleteURL,
 829             CRM_Core_Action::DELETE,
 830             [
 831               'id' => $fileDAO->id,
 832               'eid' => $dao->$entityIDName,
 833               'fid' => $fieldID,
 834               'fcs' => $fileHash,
 835             ],
 836             ts('more'),
 837             FALSE,
 838             'file.manage.delete',
 839             'File',
 840             $fileDAO->id
 841           );
 842           $customValue['deleteURLArgs'] = CRM_Core_BAO_File::deleteURLArgs($table, $dao->$entityIDName, $fileDAO->id);
 843           $customValue['fileName'] = CRM_Utils_File::cleanFileName(basename($fileDAO->uri));
 844           if ($fileDAO->mime_type == "image/jpeg" ||
 845             $fileDAO->mime_type == "image/pjpeg" ||
 846             $fileDAO->mime_type == "image/gif" ||
 847             $fileDAO->mime_type == "image/x-png" ||
 848             $fileDAO->mime_type == "image/png"
 849           ) {
 850             $customValue['displayURL'] = $customValue['fileURL'];
 851             $entityId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_EntityFile',
 852               $fileDAO->id,
 853               'entity_id',
 854               'file_id'
 855             );
 856             $customValue['imageURL'] = str_replace('persist/contribute', 'custom', $config->imageUploadURL) .
 857               $fileDAO->uri;
 858             list($path) = CRM_Core_BAO_File::path($fileDAO->id, $entityId);
 859             if ($path && file_exists($path)) {
 860               list($imageWidth, $imageHeight) = getimagesize($path);
 861               list($imageThumbWidth, $imageThumbHeight) = CRM_Contact_BAO_Contact::getThumbSize($imageWidth, $imageHeight);
 862               $customValue['imageThumbWidth'] = $imageThumbWidth;
 863               $customValue['imageThumbHeight'] = $imageThumbHeight;
 864             }
 865           }
 866         }
 867       }
 868       else {
 869         $customValue = [
 870           'id' => $dao->$idName,
 871           'data' => '',
 872         ];
 873       }
 874     }
 875     else {
 876       $customValue = [
 877         'id' => $dao->$idName,
 878         'data' => $dao->$fieldName,
 879       ];
 880     }
 881
 882     if (!array_key_exists('customValue', $groupTree[$groupID]['fields'][$fieldID])) {
 883       $groupTree[$groupID]['fields'][$fieldID]['customValue'] = [];
 884     }
 885     if (empty($groupTree[$groupID]['fields'][$fieldID]['customValue']) && !empty($singleRecord)) {
 886       $groupTree[$groupID]['fields'][$fieldID]['customValue'] = [$singleRecord => $customValue];
 887     }
 888     elseif (empty($groupTree[$groupID]['fields'][$fieldID]['customValue'])) {
 889       $groupTree[$groupID]['fields'][$fieldID]['customValue'] = [1 => $customValue];
 890     }
 891     else {
 892       $groupTree[$groupID]['fields'][$fieldID]['customValue'][] = $customValue;
 893     }
 894   }
 895
 896   /**
 897    * Get the group title.
 898    *
 899    * @param int $id
 900    *   Id of group.
 901    *
 902    * @return string
 903    *   title
 904    */
 905   public static function getTitle($id) {
 906     return CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $id, 'title');
 907   }
 908
 909   /**
 910    * Get custom group details for a group.
 911    *
 912    * An array containing custom group details (including their custom field) is returned.
 913    *
 914    * @param int $groupId
 915    *   Group id whose details are needed.
 916    * @param bool $searchable
 917    *   Is this field searchable.
 918    * @param array $extends
 919    *   Which table does it extend if any.
 920    *
 921    * @param bool $inSelector
 922    *
 923    * @return array
 924    *   array consisting of all group and field details
 925    */
 926   public static function &getGroupDetail($groupId = NULL, $searchable = NULL, &$extends = NULL, $inSelector = NULL) {
 927     // create a new tree
 928     $groupTree = [];
 929
 930     // using tableData to build the queryString
 931     $tableData = [
 932       'civicrm_custom_field' => [
 933         'id',
 934         'label',
 935         'data_type',
 936         'html_type',
 937         'default_value',
 938         'attributes',
 939         'is_required',
 940         'help_pre',
 941         'help_post',
 942         'options_per_line',
 943         'is_searchable',
 944         'start_date_years',
 945         'end_date_years',
 946         'is_search_range',
 947         'date_format',
 948         'time_format',
 949         'note_columns',
 950         'note_rows',
 951         'column_name',
 952         'is_view',
 953         'option_group_id',
 954         'in_selector',
 955       ],
 956       'civicrm_custom_group' => [
 957         'id',
 958         'name',
 959         'title',
 960         'help_pre',
 961         'help_post',
 962         'collapse_display',
 963         'collapse_adv_display',
 964         'extends',
 965         'extends_entity_column_value',
 966         'table_name',
 967         'is_multiple',
 968       ],
 969     ];
 970
 971     // create select
 972     $s = [];
 973     foreach ($tableData as $tableName => $tableColumn) {
 974       foreach ($tableColumn as $columnName) {
 975         $s[] = "{$tableName}.{$columnName} as {$tableName}_{$columnName}";
 976       }
 977     }
 978     $select = 'SELECT ' . implode(', ', $s);
 979     $params = [];
 980     // from, where, order by
 981     $from = " FROM civicrm_custom_field, civicrm_custom_group";
 982     $where = " WHERE civicrm_custom_field.custom_group_id = civicrm_custom_group.id
 983                             AND civicrm_custom_group.is_active = 1
 984                             AND civicrm_custom_field.is_active = 1 ";
 985     if ($groupId) {
 986       $params[1] = [$groupId, 'Integer'];
 987       $where .= " AND civicrm_custom_group.id = %1";
 988     }
 989
 990     if ($searchable) {
 991       $where .= " AND civicrm_custom_field.is_searchable = 1";
 992     }
 993
 994     if ($inSelector) {
 995       $where .= " AND civicrm_custom_field.in_selector = 1 AND civicrm_custom_group.is_multiple = 1 ";
 996     }
 997
 998     if ($extends) {
 999       $clause = [];
1000       foreach ($extends as $e) {
1001         $clause[] = "civicrm_custom_group.extends = '$e'";
1002       }
1003       $where .= " AND ( " . implode(' OR ', $clause) . " ) ";
1004
1005       //include case activities customdata if case is enabled
1006       if (in_array('Activity', $extends)) {
1007         $extendValues = implode(',', array_keys(CRM_Core_PseudoConstant::activityType(TRUE, TRUE, FALSE, 'label', TRUE)));
1008         $where .= " AND ( civicrm_custom_group.extends_entity_column_value IS NULL OR REPLACE( civicrm_custom_group.extends_entity_column_value, %2, ' ') IN ($extendValues) ) ";
1009         $params[2] = [CRM_Core_DAO::VALUE_SEPARATOR, 'String'];
1010       }
1011     }
1012
1013     // ensure that the user has access to these custom groups
1014     $where .= " AND " .
1015       CRM_Core_Permission::customGroupClause(CRM_Core_Permission::VIEW,
1016         'civicrm_custom_group.'
1017       );
1018
1019     $orderBy = " ORDER BY civicrm_custom_group.weight, civicrm_custom_field.weight";
1020
1021     // final query string
1022     $queryString = $select . $from . $where . $orderBy;
1023
1024     // dummy dao needed
1025     $crmDAO = CRM_Core_DAO::executeQuery($queryString, $params);
1026
1027     // process records
1028     while ($crmDAO->fetch()) {
1029       $groupId = $crmDAO->civicrm_custom_group_id;
1030       $fieldId = $crmDAO->civicrm_custom_field_id;
1031
1032       // create an array for groups if it does not exist
1033       if (!array_key_exists($groupId, $groupTree)) {
1034         $groupTree[$groupId] = [];
1035         $groupTree[$groupId]['id'] = $groupId;
1036
1037         foreach ($tableData['civicrm_custom_group'] as $v) {
1038           $fullField = "civicrm_custom_group_" . $v;
1039
1040           if ($v == 'id' || is_null($crmDAO->$fullField)) {
1041             continue;
1042           }
1043
1044           $groupTree[$groupId][$v] = $crmDAO->$fullField;
1045         }
1046
1047         $groupTree[$groupId]['fields'] = [];
1048       }
1049
1050       // add the fields now (note - the query row will always contain a field)
1051       $groupTree[$groupId]['fields'][$fieldId] = [];
1052       $groupTree[$groupId]['fields'][$fieldId]['id'] = $fieldId;
1053
1054       foreach ($tableData['civicrm_custom_field'] as $v) {
1055         $fullField = "civicrm_custom_field_" . $v;
1056         if ($v == 'id' || is_null($crmDAO->$fullField)) {
1057           continue;
1058         }
1059         $groupTree[$groupId]['fields'][$fieldId][$v] = $crmDAO->$fullField;
1060       }
1061     }
1062
1063     return $groupTree;
1064   }
1065
1066   /**
1067    * @param $entityType
1068    * @param $path
1069    * @param string $cidToken
1070    *
1071    * @return array
1072    */
1073   public static function &getActiveGroups($entityType, $path, $cidToken = '%%cid%%') {
1074     // for Group's
1075     $customGroupDAO = new CRM_Core_DAO_CustomGroup();
1076
1077     // get 'Tab' and 'Tab with table' groups
1078     $customGroupDAO->whereAdd("style IN ('Tab', 'Tab with table')");
1079     $customGroupDAO->whereAdd("is_active = 1");
1080
1081     // add whereAdd for entity type
1082     self::_addWhereAdd($customGroupDAO, $entityType, $cidToken);
1083
1084     $groups = [];
1085
1086     $permissionClause = CRM_Core_Permission::customGroupClause(CRM_Core_Permission::VIEW, NULL, TRUE);
1087     $customGroupDAO->whereAdd($permissionClause);
1088
1089     // order by weight
1090     $customGroupDAO->orderBy('weight');
1091     $customGroupDAO->find();
1092
1093     // process each group with menu tab
1094     while ($customGroupDAO->fetch()) {
1095       $group = [];
1096       $group['id'] = $customGroupDAO->id;
1097       $group['path'] = $path;
1098       $group['title'] = "$customGroupDAO->title";
1099       $group['query'] = "reset=1&gid={$customGroupDAO->id}&cid={$cidToken}";
1100       $group['extra'] = ['gid' => $customGroupDAO->id];
1101       $group['table_name'] = $customGroupDAO->table_name;
1102       $group['is_multiple'] = $customGroupDAO->is_multiple;
1103       $group['icon'] = $customGroupDAO->icon;
1104       $groups[] = $group;
1105     }
1106
1107     return $groups;
1108   }
1109
1110   /**
1111    * Get the table name for the entity type
1112    * currently if entity type is 'Contact', 'Individual', 'Household', 'Organization'
1113    * tableName is 'civicrm_contact'
1114    *
1115    * @param string $entityType
1116    *   What entity are we extending here ?.
1117    *
1118    * @return string
1119    *
1120    *
1121    * @see _apachesolr_civiAttachments_dereference_file_parent
1122    */
1123   public static function getTableNameByEntityName($entityType) {
1124     $tableName = '';
1125     switch ($entityType) {
1126       case 'Contact':
1127       case 'Individual':
1128       case 'Household':
1129       case 'Organization':
1130         $tableName = 'civicrm_contact';
1131         break;
1132
1133       case 'Contribution':
1134         $tableName = 'civicrm_contribution';
1135         break;
1136
1137       case 'Group':
1138         $tableName = 'civicrm_group';
1139         break;
1140
1141       // DRAFTING: Verify if we cannot make it pluggable
1142
1143       case 'Activity':
1144         $tableName = 'civicrm_activity';
1145         break;
1146
1147       case 'Relationship':
1148         $tableName = 'civicrm_relationship';
1149         break;
1150
1151       case 'Membership':
1152         $tableName = 'civicrm_membership';
1153         break;
1154
1155       case 'Participant':
1156         $tableName = 'civicrm_participant';
1157         break;
1158
1159       case 'Event':
1160         $tableName = 'civicrm_event';
1161         break;
1162
1163       case 'Grant':
1164         $tableName = 'civicrm_grant';
1165         break;
1166
1167       // need to add cases for Location, Address
1168     }
1169
1170     return $tableName;
1171   }
1172
1173   /**
1174    * Get a list of custom groups which extend a given entity type.
1175    * If there are custom-groups which only apply to certain subtypes,
1176    * those WILL be included.
1177    *
1178    * @param string $entityType
1179    *
1180    * @return CRM_Core_DAO_CustomGroup
1181    */
1182   public static function getAllCustomGroupsByBaseEntity($entityType) {
1183     $customGroupDAO = new CRM_Core_DAO_CustomGroup();
1184     self::_addWhereAdd($customGroupDAO, $entityType, NULL, TRUE);
1185     return $customGroupDAO;
1186   }
1187
1188   /**
1189    * Add the whereAdd clause for the DAO depending on the type of entity
1190    * the custom group is extending.
1191    *
1192    * @param object $customGroupDAO
1193    * @param string $entityType
1194    *   What entity are we extending here ?.
1195    *
1196    * @param int $entityID
1197    * @param bool $allSubtypes
1198    */
1199   private static function _addWhereAdd(&$customGroupDAO, $entityType, $entityID = NULL, $allSubtypes = FALSE) {
1200     $addSubtypeClause = FALSE;
1201     // This function isn't really accessible with user data but since the string
1202     // is not passed as a param to the query CRM_Core_DAO::escapeString seems like a harmless
1203     // precaution.
1204     $entityType = CRM_Core_DAO::escapeString($entityType);
1205
1206     switch ($entityType) {
1207       case 'Contact':
1208         // if contact, get all related to contact
1209         $extendList = "'Contact','Individual','Household','Organization'";
1210         $customGroupDAO->whereAdd("extends IN ( $extendList )");
1211         if (!$allSubtypes) {
1212           $addSubtypeClause = TRUE;
1213         }
1214         break;
1215
1216       case 'Individual':
1217       case 'Household':
1218       case 'Organization':
1219         // is I/H/O then get I/H/O and contact
1220         $extendList = "'Contact','$entityType'";
1221         $customGroupDAO->whereAdd("extends IN ( $extendList )");
1222         if (!$allSubtypes) {
1223           $addSubtypeClause = TRUE;
1224         }
1225         break;
1226
1227       default:
1228         $customGroupDAO->whereAdd("extends IN ('$entityType')");
1229         break;
1230     }
1231
1232     if ($addSubtypeClause) {
1233       $csType = is_numeric($entityID) ? CRM_Contact_BAO_Contact::getContactSubType($entityID) : FALSE;
1234
1235       if (!empty($csType)) {
1236         $subtypeClause = [];
1237         foreach ($csType as $subtype) {
1238           $subtype = CRM_Core_DAO::VALUE_SEPARATOR . $subtype .
1239             CRM_Core_DAO::VALUE_SEPARATOR;
1240           $subtypeClause[] = "extends_entity_column_value LIKE '%{$subtype}%'";
1241         }
1242         $subtypeClause[] = "extends_entity_column_value IS NULL";
1243         $customGroupDAO->whereAdd("( " . implode(' OR ', $subtypeClause) .
1244           " )");
1245       }
1246       else {
1247         $customGroupDAO->whereAdd("extends_entity_column_value IS NULL");
1248       }
1249     }
1250   }
1251
1252   /**
1253    * Delete the Custom Group.
1254    *
1255    * @param CRM_Core_BAO_CustomGroup $group
1256    *   Custom group object.
1257    * @param bool $force
1258    *   whether to force the deletion, even if there are custom fields.
1259    *
1260    * @return bool
1261    *   False if field exists for this group, true if group gets deleted.
1262    */
1263   public static function deleteGroup($group, $force = FALSE) {
1264
1265     //check whether this contain any custom fields
1266     $customField = new CRM_Core_DAO_CustomField();
1267     $customField->custom_group_id = $group->id;
1268     $customField->find();
1269
1270     // return early if there are custom fields and we're not
1271     // forcing the delete, otherwise delete the fields one by one
1272     while ($customField->fetch()) {
1273       if (!$force) {
1274         return FALSE;
1275       }
1276       CRM_Core_BAO_CustomField::deleteField($customField);
1277     }
1278
1279     // drop the table associated with this custom group
1280     CRM_Core_BAO_SchemaHandler::dropTable($group->table_name);
1281
1282     //delete  custom group
1283     $group->delete();
1284
1285     CRM_Utils_Hook::post('delete', 'CustomGroup', $group->id, $group);
1286
1287     return TRUE;
1288   }
1289
1290   /**
1291    * Set defaults.
1292    *
1293    * @param array $groupTree
1294    * @param array $defaults
1295    * @param bool $viewMode
1296    * @param bool $inactiveNeeded
1297    * @param int $action
1298    */
1299   public static function setDefaults(&$groupTree, &$defaults, $viewMode = FALSE, $inactiveNeeded = FALSE, $action = CRM_Core_Action::NONE) {
1300     foreach ($groupTree as $id => $group) {
1301       if (!isset($group['fields'])) {
1302         continue;
1303       }
1304       foreach ($group['fields'] as $field) {
1305         if (isset($field['element_value'])) {
1306           $value = $field['element_value'];
1307         }
1308         elseif (isset($field['default_value']) &&
1309           ($action != CRM_Core_Action::UPDATE ||
1310             // CRM-7548
1311             !array_key_exists('element_value', $field)
1312           )
1313         ) {
1314           $value = $viewMode ? NULL : $field['default_value'];
1315         }
1316         else {
1317           continue;
1318         }
1319
1320         if (empty($field['element_name'])) {
1321           continue;
1322         }
1323
1324         $elementName = $field['element_name'];
1325         $serialize = CRM_Core_BAO_CustomField::isSerialized($field);
1326
1327         if ($serialize) {
1328           if ($field['data_type'] != 'Country' && $field['data_type'] != 'StateProvince') {
1329             $defaults[$elementName] = [];
1330             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($field['id'], $inactiveNeeded);
1331             if ($viewMode) {
1332               $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1333               if (isset($value)) {
1334                 foreach ($customOption as $customValue => $customLabel) {
1335                   if (in_array($customValue, $checkedData)) {
1336                     if ($field['html_type'] == 'CheckBox') {
1337                       $defaults[$elementName][$customValue] = 1;
1338                     }
1339                     else {
1340                       $defaults[$elementName][$customValue] = $customValue;
1341                     }
1342                   }
1343                   else {
1344                     $defaults[$elementName][$customValue] = 0;
1345                   }
1346                 }
1347               }
1348             }
1349             else {
1350               if (isset($field['customValue']['data'])) {
1351                 $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($field['customValue']['data'], 1, -1));
1352                 foreach ($customOption as $val) {
1353                   if (in_array($val['value'], $checkedData)) {
1354                     if ($field['html_type'] == 'CheckBox') {
1355                       $defaults[$elementName][$val['value']] = 1;
1356                     }
1357                     else {
1358                       $defaults[$elementName][$val['value']] = $val['value'];
1359                     }
1360                   }
1361                   else {
1362                     $defaults[$elementName][$val['value']] = 0;
1363                   }
1364                 }
1365               }
1366               else {
1367                 // Values may be "array strings" or actual arrays. Handle both.
1368                 if (is_array($value) && count($value)) {
1369                   CRM_Utils_Array::formatArrayKeys($value);
1370                   $checkedValue = $value;
1371                 }
1372                 else {
1373                   $checkedValue = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1374                 }
1375                 foreach ($customOption as $val) {
1376                   if (in_array($val['value'], $checkedValue)) {
1377                     if ($field['html_type'] == 'CheckBox') {
1378                       $defaults[$elementName][$val['value']] = 1;
1379                     }
1380                     else {
1381                       $defaults[$elementName][$val['value']] = $val['value'];
1382                     }
1383                   }
1384                 }
1385               }
1386             }
1387           }
1388           else {
1389             if (isset($value)) {
1390               // Values may be "array strings" or actual arrays. Handle both.
1391               if (is_array($value) && count($value)) {
1392                 CRM_Utils_Array::formatArrayKeys($value);
1393                 $checkedValue = $value;
1394               }
1395               else {
1396                 $checkedValue = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1397               }
1398               foreach ($checkedValue as $val) {
1399                 if ($val) {
1400                   $defaults[$elementName][$val] = $val;
1401                 }
1402               }
1403             }
1404           }
1405         }
1406         else {
1407           if ($field['data_type'] == 'Country') {
1408             if ($value) {
1409               $defaults[$elementName] = $value;
1410             }
1411             else {
1412               $config = CRM_Core_Config::singleton();
1413               $defaults[$elementName] = $config->defaultContactCountry;
1414             }
1415           }
1416           else {
1417             if ($field['data_type'] == "Float") {
1418               $defaults[$elementName] = (float) $value;
1419             }
1420             elseif ($field['data_type'] == 'Money' &&
1421               $field['html_type'] == 'Text'
1422             ) {
1423               $defaults[$elementName] = CRM_Utils_Money::format($value, NULL, '%a');
1424             }
1425             else {
1426               $defaults[$elementName] = $value;
1427             }
1428           }
1429         }
1430       }
1431     }
1432   }
1433
1434   /**
1435    * Old function only called from one place...
1436    * @see CRM_Dedupe_Finder::formatParams
1437    *
1438    * @param array $groupTree
1439    * @param array $params
1440    * @param bool $skipFile
1441    */
1442   public static function postProcess(&$groupTree, &$params, $skipFile = FALSE) {
1443     // Get the Custom form values and groupTree
1444     foreach ($groupTree as $groupID => $group) {
1445       if ($groupID === 'info') {
1446         continue;
1447       }
1448       foreach ($group['fields'] as $field) {
1449         $fieldId = $field['id'];
1450         $serialize = CRM_Core_BAO_CustomField::isSerialized($field);
1451
1452         // Reset all checkbox, radio and multiselect data
1453         if ($field['html_type'] == 'Radio' || $serialize) {
1454           $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = 'NULL';
1455         }
1456
1457         $v = NULL;
1458         foreach ($params as $key => $val) {
1459           if (preg_match('/^custom_(\d+)_?(-?\d+)?$/', $key, $match) &&
1460             $match[1] == $field['id']
1461           ) {
1462             $v = $val;
1463           }
1464         }
1465
1466         if (!isset($groupTree[$groupID]['fields'][$fieldId]['customValue'])) {
1467           // field exists in db so populate value from "form".
1468           $groupTree[$groupID]['fields'][$fieldId]['customValue'] = [];
1469         }
1470
1471         // Serialize checkbox and multi-select data (using array keys for checkbox)
1472         if ($serialize) {
1473           $v = ($v && $field['html_type'] === 'Checkbox') ? array_keys($v) : $v;
1474           $v = $v ? CRM_Utils_Array::implodePadded($v) : NULL;
1475         }
1476
1477         switch ($field['html_type']) {
1478
1479           case 'Select Date':
1480             $date = CRM_Utils_Date::processDate($v);
1481             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $date;
1482             break;
1483
1484           case 'File':
1485             if ($skipFile) {
1486               break;
1487             }
1488
1489             // store the file in d/b
1490             $entityId = explode('=', $groupTree['info']['where'][0]);
1491             $fileParams = ['upload_date' => date('YmdHis')];
1492
1493             if ($groupTree[$groupID]['fields'][$fieldId]['customValue']['fid']) {
1494               $fileParams['id'] = $groupTree[$groupID]['fields'][$fieldId]['customValue']['fid'];
1495             }
1496             if (!empty($v)) {
1497               $fileParams['uri'] = $v['name'];
1498               $fileParams['mime_type'] = $v['type'];
1499               CRM_Core_BAO_File::filePostProcess($v['name'],
1500                 $groupTree[$groupID]['fields'][$fieldId]['customValue']['fid'],
1501                 $groupTree[$groupID]['table_name'],
1502                 trim($entityId[1]),
1503                 FALSE,
1504                 TRUE,
1505                 $fileParams,
1506                 'custom_' . $fieldId,
1507                 $v['type']
1508               );
1509             }
1510             $defaults = [];
1511             $paramsFile = [
1512               'entity_table' => $groupTree[$groupID]['table_name'],
1513               'entity_id' => $entityId[1],
1514             ];
1515
1516             CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_EntityFile',
1517               $paramsFile,
1518               $defaults
1519             );
1520
1521             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $defaults['file_id'];
1522             break;
1523
1524           default:
1525             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $v;
1526             break;
1527         }
1528       }
1529     }
1530   }
1531
1532   /**
1533    * Generic function to build all the form elements for a specific group tree.
1534    *
1535    * @param CRM_Core_Form $form
1536    *   The form object.
1537    * @param array $groupTree
1538    *   The group tree object.
1539    * @param bool $inactiveNeeded
1540    *   Return inactive custom groups.
1541    * @param string $prefix
1542    *   Prefix for custom grouptree assigned to template.
1543    *
1544    * @throws \CiviCRM_API3_Exception
1545    */
1546   public static function buildQuickForm(&$form, &$groupTree, $inactiveNeeded = FALSE, $prefix = '') {
1547     $form->assign_by_ref("{$prefix}groupTree", $groupTree);
1548
1549     foreach ($groupTree as $id => $group) {
1550       foreach ($group['fields'] as $field) {
1551         $required = $field['is_required'] ?? NULL;
1552         //fix for CRM-1620
1553         if ($field['data_type'] == 'File') {
1554           if (!empty($field['element_value']['data'])) {
1555             $required = 0;
1556           }
1557         }
1558
1559         $fieldId = $field['id'];
1560         $elementName = $field['element_name'];
1561         CRM_Core_BAO_CustomField::addQuickFormElement($form, $elementName, $fieldId, $required);
1562         if ($form->getAction() == CRM_Core_Action::VIEW) {
1563           $form->getElement($elementName)->freeze();
1564         }
1565       }
1566     }
1567   }
1568
1569   /**
1570    * Extract the get params from the url, validate and store it in session.
1571    *
1572    * @param CRM_Core_Form $form
1573    *   The form object.
1574    * @param string $type
1575    *   The type of custom group we are using.
1576    *
1577    * @return array
1578    * @throws \CRM_Core_Exception
1579    * @throws \CiviCRM_API3_Exception
1580    */
1581   public static function extractGetParams(&$form, $type) {
1582     if (empty($_GET)) {
1583       return [];
1584     }
1585
1586     $groupTree = CRM_Core_BAO_CustomGroup::getTree($type);
1587     $customValue = [];
1588     $htmlType = [
1589       'CheckBox',
1590       'Multi-Select',
1591       'Select',
1592       'Radio',
1593     ];
1594
1595     foreach ($groupTree as $group) {
1596       if (!isset($group['fields'])) {
1597         continue;
1598       }
1599       foreach ($group['fields'] as $key => $field) {
1600         $fieldName = 'custom_' . $key;
1601         $value = CRM_Utils_Request::retrieve($fieldName, 'String', $form, FALSE, NULL, 'GET');
1602
1603         if ($value) {
1604           $valid = FALSE;
1605           if (!in_array($field['html_type'], $htmlType) ||
1606             $field['data_type'] == 'Boolean'
1607           ) {
1608             $valid = CRM_Core_BAO_CustomValue::typecheck($field['data_type'], $value);
1609           }
1610           if (CRM_Core_BAO_CustomField::isSerialized($field)) {
1611             $value = str_replace("|", ",", $value);
1612             $mulValues = explode(',', $value);
1613             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($key, TRUE);
1614             $val = [];
1615             foreach ($mulValues as $v1) {
1616               foreach ($customOption as $coID => $coValue) {
1617                 if (strtolower(trim($coValue['label'])) ==
1618                   strtolower(trim($v1))
1619                 ) {
1620                   $val[$coValue['value']] = 1;
1621                 }
1622               }
1623             }
1624             if (!empty($val)) {
1625               $value = $val;
1626               $valid = TRUE;
1627             }
1628             else {
1629               $value = NULL;
1630             }
1631           }
1632           elseif ($field['html_type'] === 'Select' ||
1633             ($field['html_type'] === 'Radio' &&
1634               $field['data_type'] !== 'Boolean'
1635             )
1636           ) {
1637             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($key, TRUE);
1638             foreach ($customOption as $customID => $coValue) {
1639               if (strtolower(trim($coValue['label'])) ==
1640                 strtolower(trim($value))
1641               ) {
1642                 $value = $coValue['value'];
1643                 $valid = TRUE;
1644               }
1645             }
1646           }
1647           elseif ($field['data_type'] === 'Date') {
1648             $valid = CRM_Utils_Rule::date($value);
1649           }
1650
1651           if ($valid) {
1652             $customValue[$fieldName] = $value;
1653           }
1654         }
1655       }
1656     }
1657
1658     return $customValue;
1659   }
1660
1661   /**
1662    * Check the type of custom field type (eg: Used for Individual, Contribution, etc)
1663    * this function is used to get the custom fields of a type (eg: Used for Individual, Contribution, etc )
1664    *
1665    * @param int $customFieldId
1666    *   Custom field id.
1667    * @param array $removeCustomFieldTypes
1668    *   Remove custom fields of a type eg: array("Individual") ;.
1669    *
1670    * @return bool
1671    *   false if it matches else true
1672    *
1673    * @throws \CRM_Core_Exception
1674    */
1675   public static function checkCustomField($customFieldId, &$removeCustomFieldTypes) {
1676     $query = 'SELECT cg.extends as extends
1677                   FROM civicrm_custom_group as cg, civicrm_custom_field as cf
1678                   WHERE cg.id = cf.custom_group_id
1679                     AND cf.id =' .
1680       CRM_Utils_Type::escape($customFieldId, 'Integer');
1681
1682     $extends = CRM_Core_DAO::singleValueQuery($query);
1683
1684     if (in_array($extends, $removeCustomFieldTypes)) {
1685       return FALSE;
1686     }
1687     return TRUE;
1688   }
1689
1690   /**
1691    * @param $table
1692    *
1693    * @return string
1694    * @throws Exception
1695    */
1696   public static function mapTableName($table) {
1697     switch ($table) {
1698       case 'Contact':
1699       case 'Individual':
1700       case 'Household':
1701       case 'Organization':
1702         return 'civicrm_contact';
1703
1704       case 'Activity':
1705         return 'civicrm_activity';
1706
1707       case 'Group':
1708         return 'civicrm_group';
1709
1710       case 'Contribution':
1711         return 'civicrm_contribution';
1712
1713       case 'ContributionRecur':
1714         return 'civicrm_contribution_recur';
1715
1716       case 'Relationship':
1717         return 'civicrm_relationship';
1718
1719       case 'Event':
1720         return 'civicrm_event';
1721
1722       case 'Membership':
1723         return 'civicrm_membership';
1724
1725       case 'Participant':
1726       case 'ParticipantRole':
1727       case 'ParticipantEventName':
1728       case 'ParticipantEventType':
1729         return 'civicrm_participant';
1730
1731       case 'Grant':
1732         return 'civicrm_grant';
1733
1734       case 'Pledge':
1735         return 'civicrm_pledge';
1736
1737       case 'Address':
1738         return 'civicrm_address';
1739
1740       case 'Campaign':
1741         return 'civicrm_campaign';
1742
1743       default:
1744         $query = "
1745 SELECT IF( EXISTS(SELECT name FROM civicrm_contact_type WHERE name like %1), 1, 0 )";
1746         $qParams = [1 => [$table, 'String']];
1747         $result = CRM_Core_DAO::singleValueQuery($query, $qParams);
1748
1749         if ($result) {
1750           return 'civicrm_contact';
1751         }
1752         else {
1753           $extendObjs = CRM_Core_OptionGroup::values('cg_extend_objects', FALSE, FALSE, FALSE, NULL, 'name');
1754           if (array_key_exists($table, $extendObjs)) {
1755             return $extendObjs[$table];
1756           }
1757           throw new CRM_Core_Exception('Unknown error');
1758         }
1759     }
1760   }
1761
1762   /**
1763    * @param $group
1764    *
1765    * @throws \Exception
1766    */
1767   public static function createTable($group) {
1768     $params = [
1769       'name' => $group->table_name,
1770       'is_multiple' => $group->is_multiple ? 1 : 0,
1771       'extends_name' => self::mapTableName($group->extends),
1772     ];
1773
1774     $tableParams = CRM_Core_BAO_CustomField::defaultCustomTableSchema($params);
1775
1776     CRM_Core_BAO_SchemaHandler::createTable($tableParams);
1777   }
1778
1779   /**
1780    * Function returns formatted groupTree, so that form can be easily built in template
1781    *
1782    * @param array $groupTree
1783    * @param int $groupCount
1784    *   Group count by default 1, but can vary for multiple value custom data.
1785    * @param \CRM_Core_Form $form
1786    *
1787    * @return array
1788    * @throws \CRM_Core_Exception
1789    */
1790   public static function formatGroupTree(&$groupTree, $groupCount = 1, &$form = NULL) {
1791     $formattedGroupTree = [];
1792     $uploadNames = $formValues = [];
1793
1794     // retrieve qf key from url
1795     $qfKey = CRM_Utils_Request::retrieve('qf', 'String');
1796
1797     // fetch submitted custom field values later use to set as a default values
1798     if ($qfKey) {
1799       $submittedValues = Civi::cache('customData')->get($qfKey);
1800     }
1801
1802     foreach ($groupTree as $key => $value) {
1803       if ($key === 'info') {
1804         continue;
1805       }
1806
1807       // add group information
1808       $formattedGroupTree[$key]['name'] = $value['name'] ?? NULL;
1809       $formattedGroupTree[$key]['title'] = $value['title'] ?? NULL;
1810       $formattedGroupTree[$key]['help_pre'] = $value['help_pre'] ?? NULL;
1811       $formattedGroupTree[$key]['help_post'] = $value['help_post'] ?? NULL;
1812       $formattedGroupTree[$key]['collapse_display'] = $value['collapse_display'] ?? NULL;
1813       $formattedGroupTree[$key]['collapse_adv_display'] = $value['collapse_adv_display'] ?? NULL;
1814       $formattedGroupTree[$key]['style'] = $value['style'] ?? NULL;
1815
1816       // this params needed of bulding multiple values
1817       $formattedGroupTree[$key]['is_multiple'] = $value['is_multiple'] ?? NULL;
1818       $formattedGroupTree[$key]['extends'] = $value['extends'] ?? NULL;
1819       $formattedGroupTree[$key]['extends_entity_column_id'] = $value['extends_entity_column_id'] ?? NULL;
1820       $formattedGroupTree[$key]['extends_entity_column_value'] = $value['extends_entity_column_value'] ?? NULL;
1821       $formattedGroupTree[$key]['subtype'] = $value['subtype'] ?? NULL;
1822       $formattedGroupTree[$key]['max_multiple'] = $value['max_multiple'] ?? NULL;
1823
1824       // add field information
1825       foreach ($value['fields'] as $k => $properties) {
1826         $properties['element_name'] = "custom_{$k}_-{$groupCount}";
1827         if (isset($properties['customValue']) &&
1828           !CRM_Utils_System::isNull($properties['customValue']) &&
1829           !isset($properties['element_value'])
1830         ) {
1831           if (isset($properties['customValue'][$groupCount])) {
1832             $properties['element_name'] = "custom_{$k}_{$properties['customValue'][$groupCount]['id']}";
1833             $formattedGroupTree[$key]['table_id'] = $properties['customValue'][$groupCount]['id'];
1834             if ($properties['data_type'] === 'File') {
1835               $properties['element_value'] = $properties['customValue'][$groupCount];
1836               $uploadNames[] = $properties['element_name'];
1837             }
1838             else {
1839               $properties['element_value'] = $properties['customValue'][$groupCount]['data'];
1840             }
1841           }
1842         }
1843         if ($value = CRM_Utils_Request::retrieve($properties['element_name'], 'String', $form, FALSE, NULL, 'POST')) {
1844           $formValues[$properties['element_name']] = $value;
1845         }
1846         elseif (isset($submittedValues[$properties['element_name']])) {
1847           $properties['element_value'] = $submittedValues[$properties['element_name']];
1848         }
1849         unset($properties['customValue']);
1850         $formattedGroupTree[$key]['fields'][$k] = $properties;
1851       }
1852     }
1853
1854     if ($form) {
1855       if (count($formValues)) {
1856         $qf = $form->get('qfKey');
1857         $form->assign('qfKey', $qf);
1858         Civi::cache('customData')->set($qf, $formValues);
1859       }
1860
1861       // hack for field type File
1862       $formUploadNames = $form->get('uploadNames');
1863       if (is_array($formUploadNames)) {
1864         $uploadNames = array_unique(array_merge($formUploadNames, $uploadNames));
1865       }
1866
1867       $form->set('uploadNames', $uploadNames);
1868     }
1869
1870     return $formattedGroupTree;
1871   }
1872
1873   /**
1874    * Build custom data view.
1875    *
1876    * @param CRM_Core_Form|CRM_Core_Page $form
1877    *   Page object.
1878    * @param array $groupTree
1879    * @param bool $returnCount
1880    *   True if customValue count needs to be returned.
1881    * @param int $gID
1882    * @param null $prefix
1883    * @param int $customValueId
1884    * @param int $entityId
1885    *
1886    * @return array|int
1887    * @throws \CRM_Core_Exception
1888    */
1889   public static function buildCustomDataView(&$form, &$groupTree, $returnCount = FALSE, $gID = NULL, $prefix = NULL, $customValueId = NULL, $entityId = NULL) {
1890     $details = [];
1891     foreach ($groupTree as $key => $group) {
1892       if ($key === 'info') {
1893         continue;
1894       }
1895
1896       foreach ($group['fields'] as $k => $properties) {
1897         $groupID = $group['id'];
1898         if (!empty($properties['customValue'])) {
1899           foreach ($properties['customValue'] as $values) {
1900             if (!empty($customValueId) && $customValueId != $values['id']) {
1901               continue;
1902             }
1903             $details[$groupID][$values['id']]['title'] = $group['title'] ?? NULL;
1904             $details[$groupID][$values['id']]['name'] = $group['name'] ?? NULL;
1905             $details[$groupID][$values['id']]['help_pre'] = $group['help_pre'] ?? NULL;
1906             $details[$groupID][$values['id']]['help_post'] = $group['help_post'] ?? NULL;
1907             $details[$groupID][$values['id']]['collapse_display'] = $group['collapse_display'] ?? NULL;
1908             $details[$groupID][$values['id']]['collapse_adv_display'] = $group['collapse_adv_display'] ?? NULL;
1909             $details[$groupID][$values['id']]['style'] = $group['style'] ?? NULL;
1910             $details[$groupID][$values['id']]['fields'][$k] = [
1911               'field_title' => $properties['label'] ?? NULL,
1912               'field_type' => $properties['html_type'] ?? NULL,
1913               'field_data_type' => $properties['data_type'] ?? NULL,
1914               'field_value' => CRM_Core_BAO_CustomField::displayValue($values['data'], $properties['id'], $entityId),
1915               'options_per_line' => $properties['options_per_line'] ?? NULL,
1916             ];
1917             // editable = whether this set contains any non-read-only fields
1918             if (!isset($details[$groupID][$values['id']]['editable'])) {
1919               $details[$groupID][$values['id']]['editable'] = FALSE;
1920             }
1921             if (empty($properties['is_view'])) {
1922               $details[$groupID][$values['id']]['editable'] = TRUE;
1923             }
1924             // also return contact reference contact id if user has view all or edit all contacts perm
1925             if ((CRM_Core_Permission::check('view all contacts') ||
1926                 CRM_Core_Permission::check('edit all contacts'))
1927               &&
1928               $details[$groupID][$values['id']]['fields'][$k]['field_data_type'] ==
1929               'ContactReference'
1930             ) {
1931               $details[$groupID][$values['id']]['fields'][$k]['contact_ref_id'] = $values['data'] ?? NULL;
1932             }
1933           }
1934         }
1935         else {
1936           $details[$groupID][0]['title'] = $group['title'] ?? NULL;
1937           $details[$groupID][0]['name'] = $group['name'] ?? NULL;
1938           $details[$groupID][0]['help_pre'] = $group['help_pre'] ?? NULL;
1939           $details[$groupID][0]['help_post'] = $group['help_post'] ?? NULL;
1940           $details[$groupID][0]['collapse_display'] = $group['collapse_display'] ?? NULL;
1941           $details[$groupID][0]['collapse_adv_display'] = $group['collapse_adv_display'] ?? NULL;
1942           $details[$groupID][0]['style'] = $group['style'] ?? NULL;
1943           $details[$groupID][0]['fields'][$k] = ['field_title' => CRM_Utils_Array::value('label', $properties)];
1944         }
1945       }
1946     }
1947
1948     if ($returnCount) {
1949       // return a single value count if group id is passed to function
1950       // else return a groupId and count mapped array
1951       if (!empty($gID)) {
1952         return count($details[$gID]);
1953       }
1954       else {
1955         $countValue = [];
1956         foreach ($details as $key => $value) {
1957           $countValue[$key] = count($details[$key]);
1958         }
1959         return $countValue;
1960       }
1961     }
1962     else {
1963       $form->assign_by_ref("{$prefix}viewCustomData", $details);
1964       return $details;
1965     }
1966   }
1967
1968   /**
1969    * Get the custom group titles by custom field ids.
1970    *
1971    * @param array $fieldIds
1972    *   Array of custom field ids.
1973    *
1974    * @return array|NULL
1975    *   array consisting of groups and fields labels with ids.
1976    */
1977   public static function getGroupTitles($fieldIds) {
1978     if (!is_array($fieldIds) && empty($fieldIds)) {
1979       return NULL;
1980     }
1981
1982     $groupLabels = [];
1983     $fIds = "(" . implode(',', $fieldIds) . ")";
1984
1985     $query = "
1986 SELECT  civicrm_custom_group.id as groupID, civicrm_custom_group.title as groupTitle,
1987         civicrm_custom_field.label as fieldLabel, civicrm_custom_field.id as fieldID
1988   FROM  civicrm_custom_group, civicrm_custom_field
1989  WHERE  civicrm_custom_group.id = civicrm_custom_field.custom_group_id
1990    AND  civicrm_custom_field.id IN {$fIds}";
1991
1992     $dao = CRM_Core_DAO::executeQuery($query);
1993     while ($dao->fetch()) {
1994       $groupLabels[$dao->fieldID] = [
1995         'fieldID' => $dao->fieldID,
1996         'fieldLabel' => $dao->fieldLabel,
1997         'groupID' => $dao->groupID,
1998         'groupTitle' => $dao->groupTitle,
1999       ];
2000     }
2001
2002     return $groupLabels;
2003   }
2004
2005   public static function dropAllTables() {
2006     $query = "SELECT table_name FROM civicrm_custom_group";
2007     $dao = CRM_Core_DAO::executeQuery($query);
2008
2009     while ($dao->fetch()) {
2010       $query = "DROP TABLE IF EXISTS {$dao->table_name}";
2011       CRM_Core_DAO::executeQuery($query);
2012     }
2013   }
2014
2015   /**
2016    * Check whether custom group is empty or not.
2017    *
2018    * @param int $gID
2019    *   Custom group id.
2020    *
2021    * @return bool|NULL
2022    *   true if empty otherwise false.
2023    */
2024   public static function isGroupEmpty($gID) {
2025     if (!$gID) {
2026       return NULL;
2027     }
2028
2029     $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
2030       $gID,
2031       'table_name'
2032     );
2033
2034     $query = "SELECT count(id) FROM {$tableName} WHERE id IS NOT NULL LIMIT 1";
2035     $value = CRM_Core_DAO::singleValueQuery($query);
2036
2037     if (empty($value)) {
2038       return TRUE;
2039     }
2040
2041     return FALSE;
2042   }
2043
2044   /**
2045    * Get the list of types for objects that a custom group extends to.
2046    *
2047    * @param array $types
2048    *   Var which should have the list appended.
2049    *
2050    * @return array
2051    *   Array of types.
2052    * @throws \Exception
2053    */
2054   public static function getExtendedObjectTypes(&$types = []) {
2055     static $flag = FALSE, $objTypes = [];
2056
2057     if (!$flag) {
2058       $extendObjs = [];
2059       CRM_Core_OptionValue::getValues(['name' => 'cg_extend_objects'], $extendObjs, 'weight', TRUE);
2060
2061       foreach ($extendObjs as $ovId => $ovValues) {
2062         if ($ovValues['description']) {
2063           // description is expected to be a callback func to subtypes
2064           list($callback, $args) = explode(';', trim($ovValues['description']));
2065
2066           if (empty($args)) {
2067             $args = [];
2068           }
2069
2070           if (!is_array($args)) {
2071             throw new CRM_Core_Exception('Arg is not of type array');
2072           }
2073
2074           list($className) = explode('::', $callback);
2075           require_once str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
2076
2077           $objTypes[$ovValues['value']] = call_user_func_array($callback, $args);
2078         }
2079       }
2080       $flag = TRUE;
2081     }
2082
2083     $types = array_merge($types, $objTypes);
2084     return $objTypes;
2085   }
2086
2087   /**
2088    * @param int $customGroupId
2089    * @param int $entityId
2090    *
2091    * @return bool
2092    */
2093   public static function hasReachedMaxLimit($customGroupId, $entityId) {
2094     // check whether the group is multiple
2095     $isMultiple = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'is_multiple');
2096     $isMultiple = (bool) $isMultiple;
2097     $hasReachedMax = FALSE;
2098     if ($isMultiple &&
2099       ($maxMultiple = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'max_multiple'))
2100     ) {
2101       if (!$maxMultiple) {
2102         $hasReachedMax = FALSE;
2103       }
2104       else {
2105         $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'table_name');
2106         // count the number of entries for a entity
2107         $sql = "SELECT COUNT(id) FROM {$tableName} WHERE entity_id = %1";
2108         $params = [1 => [$entityId, 'Integer']];
2109         $count = CRM_Core_DAO::singleValueQuery($sql, $params);
2110
2111         if ($count >= $maxMultiple) {
2112           $hasReachedMax = TRUE;
2113         }
2114       }
2115     }
2116     return $hasReachedMax;
2117   }
2118
2119   /**
2120    * @return array
2121    */
2122   public static function getMultipleFieldGroup() {
2123     $multipleGroup = [];
2124     $dao = new CRM_Core_DAO_CustomGroup();
2125     $dao->is_multiple = 1;
2126     $dao->is_active = 1;
2127     $dao->find();
2128     while ($dao->fetch()) {
2129       $multipleGroup[$dao->id] = $dao->title;
2130     }
2131     return $multipleGroup;
2132   }
2133
2134   /**
2135    * Build the metadata tree for the custom group.
2136    *
2137    * @param string $entityType
2138    * @param array $toReturn
2139    * @param array $subTypes
2140    * @param string $queryString
2141    * @param array $params
2142    * @param string $subType
2143    *
2144    * @return array
2145    * @throws \CRM_Core_Exception
2146    */
2147   private static function buildGroupTree($entityType, $toReturn, $subTypes, $queryString, $params, $subType) {
2148     $groupTree = $multipleFieldGroups = [];
2149     $crmDAO = CRM_Core_DAO::executeQuery($queryString, $params);
2150     $customValueTables = [];
2151
2152     // process records
2153     while ($crmDAO->fetch()) {
2154       // get the id's
2155       $groupID = $crmDAO->civicrm_custom_group_id;
2156       $fieldId = $crmDAO->civicrm_custom_field_id;
2157       if ($crmDAO->civicrm_custom_group_is_multiple) {
2158         $multipleFieldGroups[$groupID] = $crmDAO->civicrm_custom_group_table_name;
2159       }
2160       // create an array for groups if it does not exist
2161       if (!array_key_exists($groupID, $groupTree)) {
2162         $groupTree[$groupID] = [];
2163         $groupTree[$groupID]['id'] = $groupID;
2164
2165         // populate the group information
2166         foreach ($toReturn['custom_group'] as $fieldName) {
2167           $fullFieldName = "civicrm_custom_group_$fieldName";
2168           if ($fieldName == 'id' ||
2169             is_null($crmDAO->$fullFieldName)
2170           ) {
2171             continue;
2172           }
2173           // CRM-5507
2174           // This is an old bit of code - per the CRM number & probably does not work reliably if
2175           // that one contact sub-type exists.
2176           if ($fieldName == 'extends_entity_column_value' && !empty($subTypes[0])) {
2177             $groupTree[$groupID]['subtype'] = self::validateSubTypeByEntity($entityType, $subType);
2178           }
2179           $groupTree[$groupID][$fieldName] = $crmDAO->$fullFieldName;
2180         }
2181         $groupTree[$groupID]['fields'] = [];
2182
2183         $customValueTables[$crmDAO->civicrm_custom_group_table_name] = [];
2184       }
2185
2186       // add the fields now (note - the query row will always contain a field)
2187       // we only reset this once, since multiple values come is as multiple rows
2188       if (!array_key_exists($fieldId, $groupTree[$groupID]['fields'])) {
2189         $groupTree[$groupID]['fields'][$fieldId] = [];
2190       }
2191
2192       $customValueTables[$crmDAO->civicrm_custom_group_table_name][$crmDAO->civicrm_custom_field_column_name] = 1;
2193       $groupTree[$groupID]['fields'][$fieldId]['id'] = $fieldId;
2194       // populate information for a custom field
2195       foreach ($toReturn['custom_field'] as $fieldName) {
2196         $fullFieldName = "civicrm_custom_field_$fieldName";
2197         if ($fieldName == 'id' ||
2198           is_null($crmDAO->$fullFieldName)
2199         ) {
2200           continue;
2201         }
2202         $groupTree[$groupID]['fields'][$fieldId][$fieldName] = $crmDAO->$fullFieldName;
2203       }
2204     }
2205
2206     if (!empty($customValueTables)) {
2207       $groupTree['info'] = ['tables' => $customValueTables];
2208     }
2209     return [$multipleFieldGroups, $groupTree];
2210   }
2211
2212 }