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     switch ($entityType) {
1125       case 'Contact':
1126       case 'Individual':
1127       case 'Household':
1128       case 'Organization':
1129         return 'civicrm_contact';
1130
1131       default:
1132         return CRM_Core_DAO_AllCoreTables::getTableForEntityName($entityType);
1133     }
1134   }
1135
1136   /**
1137    * Get a list of custom groups which extend a given entity type.
1138    * If there are custom-groups which only apply to certain subtypes,
1139    * those WILL be included.
1140    *
1141    * @param string $entityType
1142    *
1143    * @return CRM_Core_DAO_CustomGroup
1144    */
1145   public static function getAllCustomGroupsByBaseEntity($entityType) {
1146     $customGroupDAO = new CRM_Core_DAO_CustomGroup();
1147     self::_addWhereAdd($customGroupDAO, $entityType, NULL, TRUE);
1148     return $customGroupDAO;
1149   }
1150
1151   /**
1152    * Add the whereAdd clause for the DAO depending on the type of entity
1153    * the custom group is extending.
1154    *
1155    * @param object $customGroupDAO
1156    * @param string $entityType
1157    *   What entity are we extending here ?.
1158    *
1159    * @param int $entityID
1160    * @param bool $allSubtypes
1161    */
1162   private static function _addWhereAdd(&$customGroupDAO, $entityType, $entityID = NULL, $allSubtypes = FALSE) {
1163     $addSubtypeClause = FALSE;
1164     // This function isn't really accessible with user data but since the string
1165     // is not passed as a param to the query CRM_Core_DAO::escapeString seems like a harmless
1166     // precaution.
1167     $entityType = CRM_Core_DAO::escapeString($entityType);
1168
1169     switch ($entityType) {
1170       case 'Contact':
1171         // if contact, get all related to contact
1172         $extendList = "'Contact','Individual','Household','Organization'";
1173         $customGroupDAO->whereAdd("extends IN ( $extendList )");
1174         if (!$allSubtypes) {
1175           $addSubtypeClause = TRUE;
1176         }
1177         break;
1178
1179       case 'Individual':
1180       case 'Household':
1181       case 'Organization':
1182         // is I/H/O then get I/H/O and contact
1183         $extendList = "'Contact','$entityType'";
1184         $customGroupDAO->whereAdd("extends IN ( $extendList )");
1185         if (!$allSubtypes) {
1186           $addSubtypeClause = TRUE;
1187         }
1188         break;
1189
1190       default:
1191         $customGroupDAO->whereAdd("extends IN ('$entityType')");
1192         break;
1193     }
1194
1195     if ($addSubtypeClause) {
1196       $csType = is_numeric($entityID) ? CRM_Contact_BAO_Contact::getContactSubType($entityID) : FALSE;
1197
1198       if (!empty($csType)) {
1199         $subtypeClause = [];
1200         foreach ($csType as $subtype) {
1201           $subtype = CRM_Core_DAO::VALUE_SEPARATOR . $subtype .
1202             CRM_Core_DAO::VALUE_SEPARATOR;
1203           $subtypeClause[] = "extends_entity_column_value LIKE '%{$subtype}%'";
1204         }
1205         $subtypeClause[] = "extends_entity_column_value IS NULL";
1206         $customGroupDAO->whereAdd("( " . implode(' OR ', $subtypeClause) .
1207           " )");
1208       }
1209       else {
1210         $customGroupDAO->whereAdd("extends_entity_column_value IS NULL");
1211       }
1212     }
1213   }
1214
1215   /**
1216    * Delete the Custom Group.
1217    *
1218    * @param CRM_Core_BAO_CustomGroup $group
1219    *   Custom group object.
1220    * @param bool $force
1221    *   whether to force the deletion, even if there are custom fields.
1222    *
1223    * @return bool
1224    *   False if field exists for this group, true if group gets deleted.
1225    */
1226   public static function deleteGroup($group, $force = FALSE) {
1227
1228     //check whether this contain any custom fields
1229     $customField = new CRM_Core_DAO_CustomField();
1230     $customField->custom_group_id = $group->id;
1231     $customField->find();
1232
1233     // return early if there are custom fields and we're not
1234     // forcing the delete, otherwise delete the fields one by one
1235     while ($customField->fetch()) {
1236       if (!$force) {
1237         return FALSE;
1238       }
1239       CRM_Core_BAO_CustomField::deleteField($customField);
1240     }
1241
1242     // drop the table associated with this custom group
1243     CRM_Core_BAO_SchemaHandler::dropTable($group->table_name);
1244
1245     //delete  custom group
1246     $group->delete();
1247
1248     CRM_Utils_Hook::post('delete', 'CustomGroup', $group->id, $group);
1249
1250     return TRUE;
1251   }
1252
1253   /**
1254    * Set defaults.
1255    *
1256    * @param array $groupTree
1257    * @param array $defaults
1258    * @param bool $viewMode
1259    * @param bool $inactiveNeeded
1260    * @param int $action
1261    */
1262   public static function setDefaults(&$groupTree, &$defaults, $viewMode = FALSE, $inactiveNeeded = FALSE, $action = CRM_Core_Action::NONE) {
1263     foreach ($groupTree as $id => $group) {
1264       if (!isset($group['fields'])) {
1265         continue;
1266       }
1267       foreach ($group['fields'] as $field) {
1268         if (isset($field['element_value'])) {
1269           $value = $field['element_value'];
1270         }
1271         elseif (isset($field['default_value']) &&
1272           ($action != CRM_Core_Action::UPDATE ||
1273             // CRM-7548
1274             !array_key_exists('element_value', $field)
1275           )
1276         ) {
1277           $value = $viewMode ? NULL : $field['default_value'];
1278         }
1279         else {
1280           continue;
1281         }
1282
1283         if (empty($field['element_name'])) {
1284           continue;
1285         }
1286
1287         $elementName = $field['element_name'];
1288         $serialize = CRM_Core_BAO_CustomField::isSerialized($field);
1289
1290         if ($serialize) {
1291           if ($field['data_type'] != 'Country' && $field['data_type'] != 'StateProvince' && $field['data_type'] != 'ContactReference') {
1292             $defaults[$elementName] = [];
1293             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($field['id'], $inactiveNeeded);
1294             if ($viewMode) {
1295               $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1296               if (isset($value)) {
1297                 foreach ($customOption as $customValue => $customLabel) {
1298                   if (in_array($customValue, $checkedData)) {
1299                     if ($field['html_type'] == 'CheckBox') {
1300                       $defaults[$elementName][$customValue] = 1;
1301                     }
1302                     else {
1303                       $defaults[$elementName][$customValue] = $customValue;
1304                     }
1305                   }
1306                   else {
1307                     $defaults[$elementName][$customValue] = 0;
1308                   }
1309                 }
1310               }
1311             }
1312             else {
1313               if (isset($field['customValue']['data'])) {
1314                 $checkedData = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($field['customValue']['data'], 1, -1));
1315                 foreach ($customOption as $val) {
1316                   if (in_array($val['value'], $checkedData)) {
1317                     if ($field['html_type'] == 'CheckBox') {
1318                       $defaults[$elementName][$val['value']] = 1;
1319                     }
1320                     else {
1321                       $defaults[$elementName][$val['value']] = $val['value'];
1322                     }
1323                   }
1324                   else {
1325                     $defaults[$elementName][$val['value']] = 0;
1326                   }
1327                 }
1328               }
1329               else {
1330                 // Values may be "array strings" or actual arrays. Handle both.
1331                 if (is_array($value) && count($value)) {
1332                   CRM_Utils_Array::formatArrayKeys($value);
1333                   $checkedValue = $value;
1334                 }
1335                 else {
1336                   $checkedValue = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1337                 }
1338                 foreach ($customOption as $val) {
1339                   if (in_array($val['value'], $checkedValue)) {
1340                     if ($field['html_type'] == 'CheckBox') {
1341                       $defaults[$elementName][$val['value']] = 1;
1342                     }
1343                     else {
1344                       $defaults[$elementName][$val['value']] = $val['value'];
1345                     }
1346                   }
1347                 }
1348               }
1349             }
1350           }
1351           else {
1352             if (isset($value)) {
1353               // Values may be "array strings" or actual arrays. Handle both.
1354               if (is_array($value) && count($value)) {
1355                 CRM_Utils_Array::formatArrayKeys($value);
1356                 $checkedValue = $value;
1357               }
1358               else {
1359                 $checkedValue = explode(CRM_Core_DAO::VALUE_SEPARATOR, substr($value, 1, -1));
1360               }
1361               foreach ($checkedValue as $val) {
1362                 if ($val) {
1363                   $defaults[$elementName][$val] = $val;
1364                 }
1365               }
1366             }
1367           }
1368         }
1369         else {
1370           if ($field['data_type'] == 'Country') {
1371             if ($value) {
1372               $defaults[$elementName] = $value;
1373             }
1374             else {
1375               $config = CRM_Core_Config::singleton();
1376               $defaults[$elementName] = $config->defaultContactCountry;
1377             }
1378           }
1379           else {
1380             if ($field['data_type'] == "Float") {
1381               $defaults[$elementName] = (float) $value;
1382             }
1383             elseif ($field['data_type'] == 'Money' &&
1384               $field['html_type'] == 'Text'
1385             ) {
1386               $defaults[$elementName] = CRM_Utils_Money::format($value, NULL, '%a');
1387             }
1388             else {
1389               $defaults[$elementName] = $value;
1390             }
1391           }
1392         }
1393       }
1394     }
1395   }
1396
1397   /**
1398    * Old function only called from one place...
1399    * @see CRM_Dedupe_Finder::formatParams
1400    *
1401    * @param array $groupTree
1402    * @param array $params
1403    * @param bool $skipFile
1404    */
1405   public static function postProcess(&$groupTree, &$params, $skipFile = FALSE) {
1406     // Get the Custom form values and groupTree
1407     foreach ($groupTree as $groupID => $group) {
1408       if ($groupID === 'info') {
1409         continue;
1410       }
1411       foreach ($group['fields'] as $field) {
1412         $fieldId = $field['id'];
1413         $serialize = CRM_Core_BAO_CustomField::isSerialized($field);
1414
1415         // Reset all checkbox, radio and multiselect data
1416         if ($field['html_type'] == 'Radio' || $serialize) {
1417           $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = 'NULL';
1418         }
1419
1420         $v = NULL;
1421         foreach ($params as $key => $val) {
1422           if (preg_match('/^custom_(\d+)_?(-?\d+)?$/', $key, $match) &&
1423             $match[1] == $field['id']
1424           ) {
1425             $v = $val;
1426           }
1427         }
1428
1429         if (!isset($groupTree[$groupID]['fields'][$fieldId]['customValue'])) {
1430           // field exists in db so populate value from "form".
1431           $groupTree[$groupID]['fields'][$fieldId]['customValue'] = [];
1432         }
1433
1434         // Serialize checkbox and multi-select data (using array keys for checkbox)
1435         if ($serialize) {
1436           $v = ($v && $field['html_type'] === 'Checkbox') ? array_keys($v) : $v;
1437           $v = $v ? CRM_Utils_Array::implodePadded($v) : NULL;
1438         }
1439
1440         switch ($field['html_type']) {
1441
1442           case 'Select Date':
1443             $date = CRM_Utils_Date::processDate($v);
1444             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $date;
1445             break;
1446
1447           case 'File':
1448             if ($skipFile) {
1449               break;
1450             }
1451
1452             // store the file in d/b
1453             $entityId = explode('=', $groupTree['info']['where'][0]);
1454             $fileParams = ['upload_date' => date('YmdHis')];
1455
1456             if ($groupTree[$groupID]['fields'][$fieldId]['customValue']['fid']) {
1457               $fileParams['id'] = $groupTree[$groupID]['fields'][$fieldId]['customValue']['fid'];
1458             }
1459             if (!empty($v)) {
1460               $fileParams['uri'] = $v['name'];
1461               $fileParams['mime_type'] = $v['type'];
1462               CRM_Core_BAO_File::filePostProcess($v['name'],
1463                 $groupTree[$groupID]['fields'][$fieldId]['customValue']['fid'],
1464                 $groupTree[$groupID]['table_name'],
1465                 trim($entityId[1]),
1466                 FALSE,
1467                 TRUE,
1468                 $fileParams,
1469                 'custom_' . $fieldId,
1470                 $v['type']
1471               );
1472             }
1473             $defaults = [];
1474             $paramsFile = [
1475               'entity_table' => $groupTree[$groupID]['table_name'],
1476               'entity_id' => $entityId[1],
1477             ];
1478
1479             CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_EntityFile',
1480               $paramsFile,
1481               $defaults
1482             );
1483
1484             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $defaults['file_id'];
1485             break;
1486
1487           default:
1488             $groupTree[$groupID]['fields'][$fieldId]['customValue']['data'] = $v;
1489             break;
1490         }
1491       }
1492     }
1493   }
1494
1495   /**
1496    * Generic function to build all the form elements for a specific group tree.
1497    *
1498    * @param CRM_Core_Form $form
1499    *   The form object.
1500    * @param array $groupTree
1501    *   The group tree object.
1502    * @param bool $inactiveNeeded
1503    *   Return inactive custom groups.
1504    * @param string $prefix
1505    *   Prefix for custom grouptree assigned to template.
1506    *
1507    * @throws \CiviCRM_API3_Exception
1508    */
1509   public static function buildQuickForm(&$form, &$groupTree, $inactiveNeeded = FALSE, $prefix = '') {
1510     $form->assign_by_ref("{$prefix}groupTree", $groupTree);
1511
1512     foreach ($groupTree as $id => $group) {
1513       foreach ($group['fields'] as $field) {
1514         $required = $field['is_required'] ?? NULL;
1515         //fix for CRM-1620
1516         if ($field['data_type'] == 'File') {
1517           if (!empty($field['element_value']['data'])) {
1518             $required = 0;
1519           }
1520         }
1521
1522         $fieldId = $field['id'];
1523         $elementName = $field['element_name'];
1524         CRM_Core_BAO_CustomField::addQuickFormElement($form, $elementName, $fieldId, $required);
1525         if ($form->getAction() == CRM_Core_Action::VIEW) {
1526           $form->getElement($elementName)->freeze();
1527         }
1528       }
1529     }
1530   }
1531
1532   /**
1533    * Extract the get params from the url, validate and store it in session.
1534    *
1535    * @param CRM_Core_Form $form
1536    *   The form object.
1537    * @param string $type
1538    *   The type of custom group we are using.
1539    *
1540    * @return array
1541    * @throws \CRM_Core_Exception
1542    * @throws \CiviCRM_API3_Exception
1543    */
1544   public static function extractGetParams(&$form, $type) {
1545     if (empty($_GET)) {
1546       return [];
1547     }
1548
1549     $groupTree = CRM_Core_BAO_CustomGroup::getTree($type);
1550     $customValue = [];
1551     $htmlType = [
1552       'CheckBox',
1553       'Multi-Select',
1554       'Select',
1555       'Radio',
1556     ];
1557
1558     foreach ($groupTree as $group) {
1559       if (!isset($group['fields'])) {
1560         continue;
1561       }
1562       foreach ($group['fields'] as $key => $field) {
1563         $fieldName = 'custom_' . $key;
1564         $value = CRM_Utils_Request::retrieve($fieldName, 'String', $form, FALSE, NULL, 'GET');
1565
1566         if ($value) {
1567           $valid = FALSE;
1568           if (!in_array($field['html_type'], $htmlType) ||
1569             $field['data_type'] == 'Boolean'
1570           ) {
1571             $valid = CRM_Core_BAO_CustomValue::typecheck($field['data_type'], $value);
1572           }
1573           if (CRM_Core_BAO_CustomField::isSerialized($field)) {
1574             $value = str_replace("|", ",", $value);
1575             $mulValues = explode(',', $value);
1576             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($key, TRUE);
1577             $val = [];
1578             foreach ($mulValues as $v1) {
1579               foreach ($customOption as $coID => $coValue) {
1580                 if (strtolower(trim($coValue['label'])) ==
1581                   strtolower(trim($v1))
1582                 ) {
1583                   $val[$coValue['value']] = 1;
1584                 }
1585               }
1586             }
1587             if (!empty($val)) {
1588               $value = $val;
1589               $valid = TRUE;
1590             }
1591             else {
1592               $value = NULL;
1593             }
1594           }
1595           elseif ($field['html_type'] === 'Select' ||
1596             ($field['html_type'] === 'Radio' &&
1597               $field['data_type'] !== 'Boolean'
1598             )
1599           ) {
1600             $customOption = CRM_Core_BAO_CustomOption::getCustomOption($key, TRUE);
1601             foreach ($customOption as $customID => $coValue) {
1602               if (strtolower(trim($coValue['label'])) ==
1603                 strtolower(trim($value))
1604               ) {
1605                 $value = $coValue['value'];
1606                 $valid = TRUE;
1607               }
1608             }
1609           }
1610           elseif ($field['data_type'] === 'Date') {
1611             $valid = CRM_Utils_Rule::date($value);
1612           }
1613
1614           if ($valid) {
1615             $customValue[$fieldName] = $value;
1616           }
1617         }
1618       }
1619     }
1620
1621     return $customValue;
1622   }
1623
1624   /**
1625    * Check the type of custom field type (eg: Used for Individual, Contribution, etc)
1626    * this function is used to get the custom fields of a type (eg: Used for Individual, Contribution, etc )
1627    *
1628    * @param int $customFieldId
1629    *   Custom field id.
1630    * @param array $removeCustomFieldTypes
1631    *   Remove custom fields of a type eg: array("Individual") ;.
1632    *
1633    * @return bool
1634    *   false if it matches else true
1635    *
1636    * @throws \CRM_Core_Exception
1637    */
1638   public static function checkCustomField($customFieldId, &$removeCustomFieldTypes) {
1639     $query = 'SELECT cg.extends as extends
1640                   FROM civicrm_custom_group as cg, civicrm_custom_field as cf
1641                   WHERE cg.id = cf.custom_group_id
1642                     AND cf.id =' .
1643       CRM_Utils_Type::escape($customFieldId, 'Integer');
1644
1645     $extends = CRM_Core_DAO::singleValueQuery($query);
1646
1647     if (in_array($extends, $removeCustomFieldTypes)) {
1648       return FALSE;
1649     }
1650     return TRUE;
1651   }
1652
1653   /**
1654    * @param $table
1655    *
1656    * @return string
1657    * @throws Exception
1658    */
1659   public static function mapTableName($table) {
1660     switch ($table) {
1661       case 'Contact':
1662       case 'Individual':
1663       case 'Household':
1664       case 'Organization':
1665         return 'civicrm_contact';
1666
1667       case 'Activity':
1668         return 'civicrm_activity';
1669
1670       case 'Group':
1671         return 'civicrm_group';
1672
1673       case 'Contribution':
1674         return 'civicrm_contribution';
1675
1676       case 'ContributionRecur':
1677         return 'civicrm_contribution_recur';
1678
1679       case 'Relationship':
1680         return 'civicrm_relationship';
1681
1682       case 'Event':
1683         return 'civicrm_event';
1684
1685       case 'Membership':
1686         return 'civicrm_membership';
1687
1688       case 'Participant':
1689       case 'ParticipantRole':
1690       case 'ParticipantEventName':
1691       case 'ParticipantEventType':
1692         return 'civicrm_participant';
1693
1694       case 'Grant':
1695         return 'civicrm_grant';
1696
1697       case 'Pledge':
1698         return 'civicrm_pledge';
1699
1700       case 'Address':
1701         return 'civicrm_address';
1702
1703       case 'Campaign':
1704         return 'civicrm_campaign';
1705
1706       default:
1707         $query = "
1708 SELECT IF( EXISTS(SELECT name FROM civicrm_contact_type WHERE name like %1), 1, 0 )";
1709         $qParams = [1 => [$table, 'String']];
1710         $result = CRM_Core_DAO::singleValueQuery($query, $qParams);
1711
1712         if ($result) {
1713           return 'civicrm_contact';
1714         }
1715         else {
1716           $extendObjs = CRM_Core_OptionGroup::values('cg_extend_objects', FALSE, FALSE, FALSE, NULL, 'name');
1717           if (array_key_exists($table, $extendObjs)) {
1718             return $extendObjs[$table];
1719           }
1720           throw new CRM_Core_Exception('Unknown error');
1721         }
1722     }
1723   }
1724
1725   /**
1726    * @param $group
1727    *
1728    * @throws \Exception
1729    */
1730   public static function createTable($group) {
1731     $params = [
1732       'name' => $group->table_name,
1733       'is_multiple' => $group->is_multiple ? 1 : 0,
1734       'extends_name' => self::mapTableName($group->extends),
1735     ];
1736
1737     $tableParams = CRM_Core_BAO_CustomField::defaultCustomTableSchema($params);
1738
1739     CRM_Core_BAO_SchemaHandler::createTable($tableParams);
1740   }
1741
1742   /**
1743    * Function returns formatted groupTree, so that form can be easily built in template
1744    *
1745    * @param array $groupTree
1746    * @param int $groupCount
1747    *   Group count by default 1, but can vary for multiple value custom data.
1748    * @param \CRM_Core_Form $form
1749    *
1750    * @return array
1751    * @throws \CRM_Core_Exception
1752    */
1753   public static function formatGroupTree(&$groupTree, $groupCount = 1, &$form = NULL) {
1754     $formattedGroupTree = [];
1755     $uploadNames = $formValues = [];
1756
1757     // retrieve qf key from url
1758     $qfKey = CRM_Utils_Request::retrieve('qf', 'String');
1759
1760     // fetch submitted custom field values later use to set as a default values
1761     if ($qfKey) {
1762       $submittedValues = Civi::cache('customData')->get($qfKey);
1763     }
1764
1765     foreach ($groupTree as $key => $value) {
1766       if ($key === 'info') {
1767         continue;
1768       }
1769
1770       // add group information
1771       $formattedGroupTree[$key]['name'] = $value['name'] ?? NULL;
1772       $formattedGroupTree[$key]['title'] = $value['title'] ?? NULL;
1773       $formattedGroupTree[$key]['help_pre'] = $value['help_pre'] ?? NULL;
1774       $formattedGroupTree[$key]['help_post'] = $value['help_post'] ?? NULL;
1775       $formattedGroupTree[$key]['collapse_display'] = $value['collapse_display'] ?? NULL;
1776       $formattedGroupTree[$key]['collapse_adv_display'] = $value['collapse_adv_display'] ?? NULL;
1777       $formattedGroupTree[$key]['style'] = $value['style'] ?? NULL;
1778
1779       // this params needed of bulding multiple values
1780       $formattedGroupTree[$key]['is_multiple'] = $value['is_multiple'] ?? NULL;
1781       $formattedGroupTree[$key]['extends'] = $value['extends'] ?? NULL;
1782       $formattedGroupTree[$key]['extends_entity_column_id'] = $value['extends_entity_column_id'] ?? NULL;
1783       $formattedGroupTree[$key]['extends_entity_column_value'] = $value['extends_entity_column_value'] ?? NULL;
1784       $formattedGroupTree[$key]['subtype'] = $value['subtype'] ?? NULL;
1785       $formattedGroupTree[$key]['max_multiple'] = $value['max_multiple'] ?? NULL;
1786
1787       // add field information
1788       foreach ($value['fields'] as $k => $properties) {
1789         $properties['element_name'] = "custom_{$k}_-{$groupCount}";
1790         if (isset($properties['customValue']) &&
1791           !CRM_Utils_System::isNull($properties['customValue']) &&
1792           !isset($properties['element_value'])
1793         ) {
1794           if (isset($properties['customValue'][$groupCount])) {
1795             $properties['element_name'] = "custom_{$k}_{$properties['customValue'][$groupCount]['id']}";
1796             $formattedGroupTree[$key]['table_id'] = $properties['customValue'][$groupCount]['id'];
1797             if ($properties['data_type'] === 'File') {
1798               $properties['element_value'] = $properties['customValue'][$groupCount];
1799               $uploadNames[] = $properties['element_name'];
1800             }
1801             else {
1802               $properties['element_value'] = $properties['customValue'][$groupCount]['data'];
1803             }
1804           }
1805         }
1806         if ($value = CRM_Utils_Request::retrieve($properties['element_name'], 'String', $form, FALSE, NULL, 'POST')) {
1807           $formValues[$properties['element_name']] = $value;
1808         }
1809         elseif (isset($submittedValues[$properties['element_name']])) {
1810           $properties['element_value'] = $submittedValues[$properties['element_name']];
1811         }
1812         unset($properties['customValue']);
1813         $formattedGroupTree[$key]['fields'][$k] = $properties;
1814       }
1815     }
1816
1817     if ($form) {
1818       if (count($formValues)) {
1819         $qf = $form->get('qfKey');
1820         $form->assign('qfKey', $qf);
1821         Civi::cache('customData')->set($qf, $formValues);
1822       }
1823
1824       // hack for field type File
1825       $formUploadNames = $form->get('uploadNames');
1826       if (is_array($formUploadNames)) {
1827         $uploadNames = array_unique(array_merge($formUploadNames, $uploadNames));
1828       }
1829
1830       $form->set('uploadNames', $uploadNames);
1831     }
1832
1833     return $formattedGroupTree;
1834   }
1835
1836   /**
1837    * Build custom data view.
1838    *
1839    * @param CRM_Core_Form|CRM_Core_Page $form
1840    *   Page object.
1841    * @param array $groupTree
1842    * @param bool $returnCount
1843    *   True if customValue count needs to be returned.
1844    * @param int $gID
1845    * @param null $prefix
1846    * @param int $customValueId
1847    * @param int $entityId
1848    *
1849    * @return array|int
1850    * @throws \CRM_Core_Exception
1851    */
1852   public static function buildCustomDataView(&$form, &$groupTree, $returnCount = FALSE, $gID = NULL, $prefix = NULL, $customValueId = NULL, $entityId = NULL) {
1853     $details = [];
1854     foreach ($groupTree as $key => $group) {
1855       if ($key === 'info') {
1856         continue;
1857       }
1858
1859       foreach ($group['fields'] as $k => $properties) {
1860         $groupID = $group['id'];
1861         if (!empty($properties['customValue'])) {
1862           foreach ($properties['customValue'] as $values) {
1863             if (!empty($customValueId) && $customValueId != $values['id']) {
1864               continue;
1865             }
1866             $details[$groupID][$values['id']]['title'] = $group['title'] ?? NULL;
1867             $details[$groupID][$values['id']]['name'] = $group['name'] ?? NULL;
1868             $details[$groupID][$values['id']]['help_pre'] = $group['help_pre'] ?? NULL;
1869             $details[$groupID][$values['id']]['help_post'] = $group['help_post'] ?? NULL;
1870             $details[$groupID][$values['id']]['collapse_display'] = $group['collapse_display'] ?? NULL;
1871             $details[$groupID][$values['id']]['collapse_adv_display'] = $group['collapse_adv_display'] ?? NULL;
1872             $details[$groupID][$values['id']]['style'] = $group['style'] ?? NULL;
1873             $details[$groupID][$values['id']]['fields'][$k] = [
1874               'field_title' => $properties['label'] ?? NULL,
1875               'field_type' => $properties['html_type'] ?? NULL,
1876               'field_data_type' => $properties['data_type'] ?? NULL,
1877               'field_value' => CRM_Core_BAO_CustomField::displayValue($values['data'], $properties['id'], $entityId),
1878               'options_per_line' => $properties['options_per_line'] ?? NULL,
1879             ];
1880             // editable = whether this set contains any non-read-only fields
1881             if (!isset($details[$groupID][$values['id']]['editable'])) {
1882               $details[$groupID][$values['id']]['editable'] = FALSE;
1883             }
1884             if (empty($properties['is_view'])) {
1885               $details[$groupID][$values['id']]['editable'] = TRUE;
1886             }
1887             // also return contact reference contact id if user has view all or edit all contacts perm
1888             if ($details[$groupID][$values['id']]['fields'][$k]['field_data_type'] === 'ContactReference'
1889               && CRM_Core_Permission::check([['view all contacts', 'edit all contacts']])
1890             ) {
1891               $details[$groupID][$values['id']]['fields'][$k]['contact_ref_links'] = [];
1892               $path = CRM_Contact_DAO_Contact::getEntityPaths()['view'];
1893               foreach (CRM_Utils_Array::explodePadded($values['data'] ?? []) as $contactId) {
1894                 $displayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $contactId, 'display_name');
1895                 if ($displayName) {
1896                   $url = CRM_Utils_System::url(str_replace('[id]', $contactId, $path));
1897                   $details[$groupID][$values['id']]['fields'][$k]['contact_ref_links'][] = '<a href="' . $url . '" title="' . htmlspecialchars(ts('View Contact')) . '">' .
1898                     $displayName . '</a>';
1899                 }
1900               }
1901             }
1902           }
1903         }
1904         else {
1905           $details[$groupID][0]['title'] = $group['title'] ?? NULL;
1906           $details[$groupID][0]['name'] = $group['name'] ?? NULL;
1907           $details[$groupID][0]['help_pre'] = $group['help_pre'] ?? NULL;
1908           $details[$groupID][0]['help_post'] = $group['help_post'] ?? NULL;
1909           $details[$groupID][0]['collapse_display'] = $group['collapse_display'] ?? NULL;
1910           $details[$groupID][0]['collapse_adv_display'] = $group['collapse_adv_display'] ?? NULL;
1911           $details[$groupID][0]['style'] = $group['style'] ?? NULL;
1912           $details[$groupID][0]['fields'][$k] = ['field_title' => $properties['label'] ?? NULL];
1913         }
1914       }
1915     }
1916
1917     if ($returnCount) {
1918       // return a single value count if group id is passed to function
1919       // else return a groupId and count mapped array
1920       if (!empty($gID)) {
1921         return count($details[$gID]);
1922       }
1923       else {
1924         $countValue = [];
1925         foreach ($details as $key => $value) {
1926           $countValue[$key] = count($details[$key]);
1927         }
1928         return $countValue;
1929       }
1930     }
1931     else {
1932       $form->assign_by_ref("{$prefix}viewCustomData", $details);
1933       return $details;
1934     }
1935   }
1936
1937   /**
1938    * Get the custom group titles by custom field ids.
1939    *
1940    * @param array $fieldIds
1941    *   Array of custom field ids.
1942    *
1943    * @return array|NULL
1944    *   array consisting of groups and fields labels with ids.
1945    */
1946   public static function getGroupTitles($fieldIds) {
1947     if (!is_array($fieldIds) && empty($fieldIds)) {
1948       return NULL;
1949     }
1950
1951     $groupLabels = [];
1952     $fIds = "(" . implode(',', $fieldIds) . ")";
1953
1954     $query = "
1955 SELECT  civicrm_custom_group.id as groupID, civicrm_custom_group.title as groupTitle,
1956         civicrm_custom_field.label as fieldLabel, civicrm_custom_field.id as fieldID
1957   FROM  civicrm_custom_group, civicrm_custom_field
1958  WHERE  civicrm_custom_group.id = civicrm_custom_field.custom_group_id
1959    AND  civicrm_custom_field.id IN {$fIds}";
1960
1961     $dao = CRM_Core_DAO::executeQuery($query);
1962     while ($dao->fetch()) {
1963       $groupLabels[$dao->fieldID] = [
1964         'fieldID' => $dao->fieldID,
1965         'fieldLabel' => $dao->fieldLabel,
1966         'groupID' => $dao->groupID,
1967         'groupTitle' => $dao->groupTitle,
1968       ];
1969     }
1970
1971     return $groupLabels;
1972   }
1973
1974   public static function dropAllTables() {
1975     $query = "SELECT table_name FROM civicrm_custom_group";
1976     $dao = CRM_Core_DAO::executeQuery($query);
1977
1978     while ($dao->fetch()) {
1979       $query = "DROP TABLE IF EXISTS {$dao->table_name}";
1980       CRM_Core_DAO::executeQuery($query);
1981     }
1982   }
1983
1984   /**
1985    * Check whether custom group is empty or not.
1986    *
1987    * @param int $gID
1988    *   Custom group id.
1989    *
1990    * @return bool|NULL
1991    *   true if empty otherwise false.
1992    */
1993   public static function isGroupEmpty($gID) {
1994     if (!$gID) {
1995       return NULL;
1996     }
1997
1998     $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup',
1999       $gID,
2000       'table_name'
2001     );
2002
2003     $query = "SELECT count(id) FROM {$tableName} WHERE id IS NOT NULL LIMIT 1";
2004     $value = CRM_Core_DAO::singleValueQuery($query);
2005
2006     if (empty($value)) {
2007       return TRUE;
2008     }
2009
2010     return FALSE;
2011   }
2012
2013   /**
2014    * Get the list of types for objects that a custom group extends to.
2015    *
2016    * @param array $types
2017    *   Var which should have the list appended.
2018    *
2019    * @return array
2020    *   Array of types.
2021    * @throws \Exception
2022    */
2023   public static function getExtendedObjectTypes(&$types = []) {
2024     static $flag = FALSE, $objTypes = [];
2025
2026     if (!$flag) {
2027       $extendObjs = [];
2028       CRM_Core_OptionValue::getValues(['name' => 'cg_extend_objects'], $extendObjs, 'weight', TRUE);
2029
2030       foreach ($extendObjs as $ovId => $ovValues) {
2031         if ($ovValues['description']) {
2032           // description is expected to be a callback func to subtypes
2033           list($callback, $args) = explode(';', trim($ovValues['description']));
2034
2035           if (empty($args)) {
2036             $args = [];
2037           }
2038
2039           if (!is_array($args)) {
2040             throw new CRM_Core_Exception('Arg is not of type array');
2041           }
2042
2043           list($className) = explode('::', $callback);
2044           require_once str_replace('_', DIRECTORY_SEPARATOR, $className) . '.php';
2045
2046           $objTypes[$ovValues['value']] = call_user_func_array($callback, $args);
2047         }
2048       }
2049       $flag = TRUE;
2050     }
2051
2052     $types = array_merge($types, $objTypes);
2053     return $objTypes;
2054   }
2055
2056   /**
2057    * @param int $customGroupId
2058    * @param int $entityId
2059    *
2060    * @return bool
2061    */
2062   public static function hasReachedMaxLimit($customGroupId, $entityId) {
2063     // check whether the group is multiple
2064     $isMultiple = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'is_multiple');
2065     $isMultiple = (bool) $isMultiple;
2066     $hasReachedMax = FALSE;
2067     if ($isMultiple &&
2068       ($maxMultiple = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'max_multiple'))
2069     ) {
2070       if (!$maxMultiple) {
2071         $hasReachedMax = FALSE;
2072       }
2073       else {
2074         $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $customGroupId, 'table_name');
2075         // count the number of entries for a entity
2076         $sql = "SELECT COUNT(id) FROM {$tableName} WHERE entity_id = %1";
2077         $params = [1 => [$entityId, 'Integer']];
2078         $count = CRM_Core_DAO::singleValueQuery($sql, $params);
2079
2080         if ($count >= $maxMultiple) {
2081           $hasReachedMax = TRUE;
2082         }
2083       }
2084     }
2085     return $hasReachedMax;
2086   }
2087
2088   /**
2089    * @return array
2090    */
2091   public static function getMultipleFieldGroup() {
2092     $multipleGroup = [];
2093     $dao = new CRM_Core_DAO_CustomGroup();
2094     $dao->is_multiple = 1;
2095     $dao->is_active = 1;
2096     $dao->find();
2097     while ($dao->fetch()) {
2098       $multipleGroup[$dao->id] = $dao->title;
2099     }
2100     return $multipleGroup;
2101   }
2102
2103   /**
2104    * Build the metadata tree for the custom group.
2105    *
2106    * @param string $entityType
2107    * @param array $toReturn
2108    * @param array $subTypes
2109    * @param string $queryString
2110    * @param array $params
2111    * @param string $subType
2112    *
2113    * @return array
2114    * @throws \CRM_Core_Exception
2115    */
2116   private static function buildGroupTree($entityType, $toReturn, $subTypes, $queryString, $params, $subType) {
2117     $groupTree = $multipleFieldGroups = [];
2118     $crmDAO = CRM_Core_DAO::executeQuery($queryString, $params);
2119     $customValueTables = [];
2120
2121     // process records
2122     while ($crmDAO->fetch()) {
2123       // get the id's
2124       $groupID = $crmDAO->civicrm_custom_group_id;
2125       $fieldId = $crmDAO->civicrm_custom_field_id;
2126       if ($crmDAO->civicrm_custom_group_is_multiple) {
2127         $multipleFieldGroups[$groupID] = $crmDAO->civicrm_custom_group_table_name;
2128       }
2129       // create an array for groups if it does not exist
2130       if (!array_key_exists($groupID, $groupTree)) {
2131         $groupTree[$groupID] = [];
2132         $groupTree[$groupID]['id'] = $groupID;
2133
2134         // populate the group information
2135         foreach ($toReturn['custom_group'] as $fieldName) {
2136           $fullFieldName = "civicrm_custom_group_$fieldName";
2137           if ($fieldName == 'id' ||
2138             is_null($crmDAO->$fullFieldName)
2139           ) {
2140             continue;
2141           }
2142           // CRM-5507
2143           // This is an old bit of code - per the CRM number & probably does not work reliably if
2144           // that one contact sub-type exists.
2145           if ($fieldName == 'extends_entity_column_value' && !empty($subTypes[0])) {
2146             $groupTree[$groupID]['subtype'] = self::validateSubTypeByEntity($entityType, $subType);
2147           }
2148           $groupTree[$groupID][$fieldName] = $crmDAO->$fullFieldName;
2149         }
2150         $groupTree[$groupID]['fields'] = [];
2151
2152         $customValueTables[$crmDAO->civicrm_custom_group_table_name] = [];
2153       }
2154
2155       // add the fields now (note - the query row will always contain a field)
2156       // we only reset this once, since multiple values come is as multiple rows
2157       if (!array_key_exists($fieldId, $groupTree[$groupID]['fields'])) {
2158         $groupTree[$groupID]['fields'][$fieldId] = [];
2159       }
2160
2161       $customValueTables[$crmDAO->civicrm_custom_group_table_name][$crmDAO->civicrm_custom_field_column_name] = 1;
2162       $groupTree[$groupID]['fields'][$fieldId]['id'] = $fieldId;
2163       // populate information for a custom field
2164       foreach ($toReturn['custom_field'] as $fieldName) {
2165         $fullFieldName = "civicrm_custom_field_$fieldName";
2166         if ($fieldName == 'id' ||
2167           is_null($crmDAO->$fullFieldName)
2168         ) {
2169           continue;
2170         }
2171         $groupTree[$groupID]['fields'][$fieldId][$fieldName] = $crmDAO->$fullFieldName;
2172       }
2173     }
2174
2175     if (!empty($customValueTables)) {
2176       $groupTree['info'] = ['tables' => $customValueTables];
2177     }
2178     return [$multipleFieldGroups, $groupTree];
2179   }
2180
2181 }