CRM/Core/BAO/UFGroup.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.5                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26 */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2014
  32  * $Id$
  33  *
  34  */
  35
  36 /**
  37  *
  38  */
  39 class CRM_Core_BAO_UFGroup extends CRM_Core_DAO_UFGroup {
  40   CONST PUBLIC_VISIBILITY = 1,
  41     ADMIN_VISIBILITY = 2,
  42     LISTINGS_VISIBILITY = 4;
  43
  44   /**
  45    * cache the match clause used in this transaction
  46    *
  47    * @var string
  48    */
  49   static $_matchFields = NULL;
  50
  51   /**
  52    * Takes a bunch of params that are needed to match certain criteria and
  53    * retrieves the relevant objects. Typically the valid params are only
  54    * contact_id. We'll tweak this function to be more full featured over a period
  55    * of time. This is the inverse function of create. It also stores all the retrieved
  56    * values in the default array
  57    *
  58    * @param array $params      (reference) an assoc array of name/value pairs
  59    * @param array $defaults    (reference) an assoc array to hold the flattened values
  60    *
  61    * @return object   CRM_Core_DAO_UFGroup object
  62    * @access public
  63    * @static
  64    */
  65   static function retrieve(&$params, &$defaults) {
  66     return CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_UFGroup', $params, $defaults);
  67   }
  68
  69   /**
  70    * Retrieve the first non-generic contact type
  71    *
  72    * @param int $id  id of uf_group
  73    *
  74    * @return string  contact type
  75    */
  76   static function getContactType($id) {
  77
  78     $validTypes = array_filter(array_keys(CRM_Core_SelectValues::contactType()));
  79     $validSubTypes = CRM_Contact_BAO_ContactType::subTypeInfo();
  80
  81     $typesParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $id, 'group_type'));
  82     $types = explode(',', $typesParts[0]);
  83
  84     $cType = NULL;
  85     foreach ($types as $type) {
  86       if (in_array($type, $validTypes)) {
  87         $cType = $type;
  88       }
  89       elseif (array_key_exists($type, $validSubTypes)) {
  90         $cType = CRM_Utils_Array::value('parent', $validSubTypes[$type]);
  91       }
  92       if ($cType)
  93       break;
  94     }
  95
  96     return $cType;
  97   }
  98
  99   /**
 100    * Get the form title.
 101    *
 102    * @param int $id id of uf_form
 103    *
 104    * @return string title
 105    *
 106    * @access public
 107    * @static
 108    *
 109    */
 110   public static function getTitle($id) {
 111     return CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $id, 'title');
 112   }
 113
 114   /**
 115    * update the is_active flag in the db
 116    *
 117    * @param int      $id           id of the database record
 118    * @param boolean  $is_active    value we want to set the is_active field
 119    *
 120    * @return Object             CRM_Core_DAO_UFGroup object on success, null otherwise
 121    * @access public
 122    * @static
 123    */
 124   static function setIsActive($id, $is_active) {
 125     return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $id, 'is_active', $is_active);
 126   }
 127
 128   /**
 129    * get all the registration fields
 130    *
 131    * @param int $action what action are we doing
 132    * @param int $mode mode
 133    *
 134    * @param null $ctype
 135    *
 136    * @return array the fields that are needed for registration
 137    * @static
 138    * @access public
 139    */
 140   static function getRegistrationFields($action, $mode, $ctype = NULL) {
 141     if ($mode & CRM_Profile_Form::MODE_REGISTER) {
 142       $ufGroups = CRM_Core_BAO_UFGroup::getModuleUFGroup('User Registration');
 143     }
 144     else {
 145       $ufGroups = CRM_Core_BAO_UFGroup::getModuleUFGroup('Profile');
 146     }
 147
 148     if (!is_array($ufGroups)) {
 149       return FALSE;
 150     }
 151
 152     $fields = array();
 153
 154     foreach ($ufGroups as $id => $title) {
 155       if ($ctype) {
 156         $fieldType = CRM_Core_BAO_UFField::getProfileType($id);
 157         if (($fieldType != 'Contact') &&
 158           ($fieldType != $ctype) &&
 159           !CRM_Contact_BAO_ContactType::isExtendsContactType($fieldType, $ctype)
 160         ) {
 161           continue;
 162         }
 163         if (CRM_Contact_BAO_ContactType::isaSubType($fieldType)) {
 164           $profileSubType = $fieldType;
 165         }
 166       }
 167
 168       $subset = self::getFields($id, TRUE, $action,
 169         NULL, NULL, FALSE, NULL, TRUE, $ctype
 170       );
 171
 172       // we do not allow duplicates. the first field is the winner
 173       foreach ($subset as $name => $field) {
 174         if (empty($fields[$name])) {
 175           $fields[$name] = $field;
 176         }
 177       }
 178     }
 179
 180     return $fields;
 181   }
 182
 183   /**
 184    * get all the listing fields
 185    *
 186    * @param int $action what action are we doing
 187    * @param int $visibility visibility of fields we are interested in
 188    * @param bool $considerSelector whether to consider the in_selector parameter
 189    * @param array $ufGroupIds
 190    * @param boolean $searchable
 191    *
 192    * @param null $restrict
 193    * @param bool $skipPermission
 194    * @param int $permissionType
 195    * @return array   the fields that are listings related
 196    * @static
 197    * @access public
 198    */
 199   static function getListingFields(
 200     $action,
 201     $visibility,
 202     $considerSelector = FALSE,
 203     $ufGroupIds       = NULL,
 204     $searchable       = NULL,
 205     $restrict         = NULL,
 206     $skipPermission   = FALSE,
 207     $permissionType   = CRM_Core_Permission::SEARCH
 208   ) {
 209     if ($ufGroupIds) {
 210       $subset = self::getFields($ufGroupIds, FALSE, $action,
 211         $visibility, $searchable,
 212         FALSE, $restrict,
 213         $skipPermission,
 214         NULL,
 215         $permissionType
 216       );
 217       if ($considerSelector) {
 218         // drop the fields not meant for the selector
 219         foreach ($subset as $name => $field) {
 220           if (!$field['in_selector']) {
 221             unset($subset[$name]);
 222           }
 223         }
 224       }
 225       $fields = $subset;
 226     }
 227     else {
 228       $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
 229
 230       $fields = array();
 231       foreach ($ufGroups as $id => $title) {
 232         $subset = self::getFields($id, FALSE, $action,
 233           $visibility, $searchable,
 234           FALSE, $restrict,
 235           $skipPermission,
 236           NULL,
 237           $permissionType
 238         );
 239         if ($considerSelector) {
 240           // drop the fields not meant for the selector
 241           foreach ($subset as $name => $field) {
 242             if (!$field['in_selector'])unset($subset[$name]);
 243           }
 244         }
 245         $fields = array_merge($fields, $subset);
 246       }
 247     }
 248     return $fields;
 249   }
 250
 251   /**
 252    * Get all the fields that belong to the group with the name title,
 253    * and format for use with buildProfile. This is the SQL analog of
 254    * formatUFFields().
 255    *
 256    * @param mix $id the id of the UF group or ids of ufgroup
 257    * @param bool|int $register are we interested in registration fields
 258    * @param int $action what action are we doing
 259    * @param int $visibility visibility of fields we are interested in
 260    * @param          $searchable
 261    * @param bool $showAll
 262    * @param string $restrict should we restrict based on a specified profile type
 263    *
 264    * @param bool $skipPermission
 265    * @param null $ctype
 266    * @param int $permissionType
 267    * @param string $orderBy
 268    * @param null $orderProfiles
 269    *
 270    * @internal param bool $showall
 271    * @return array   the fields that belong to this ufgroup(s)
 272    * @static
 273    * @access public
 274    */
 275   static function getFields(
 276     $id,
 277     $register = FALSE,
 278     $action = NULL,
 279     $visibility     = NULL,
 280     $searchable = NULL,
 281     $showAll        = FALSE,
 282     $restrict = NULL,
 283     $skipPermission = FALSE,
 284     $ctype          = NULL,
 285     $permissionType = CRM_Core_Permission::CREATE,
 286     $orderBy        = 'field_name',
 287     $orderProfiles = NULL
 288   ) {
 289     if (!is_array($id)) {
 290       $id = CRM_Utils_Type::escape($id, 'Positive');
 291       $profileIds = array($id);
 292     }
 293     else {
 294       $profileIds = $id;
 295     }
 296
 297     $gids = implode(',', $profileIds);
 298     $params = array();
 299     if ($restrict) {
 300       $query = "SELECT g.* from civicrm_uf_group g
 301                 LEFT JOIN civicrm_uf_join j ON (j.uf_group_id = g.id)
 302                 WHERE g.id IN ( {$gids} )
 303                 AND ((j.uf_group_id IN ( {$gids} ) AND j.module = %1) OR g.is_reserved = 1 )
 304                 ";
 305       $params = array(1 => array($restrict, 'String'));
 306     }
 307     else {
 308       $query = "SELECT g.* from civicrm_uf_group g WHERE g.id IN ( {$gids} ) ";
 309     }
 310
 311     if (!$showAll) {
 312       $query .= " AND g.is_active = 1";
 313     }
 314
 315     // add permissioning for profiles only if not registration
 316     if (!$skipPermission) {
 317       $permissionClause = CRM_Core_Permission::ufGroupClause($permissionType, 'g.');
 318       $query .= " AND $permissionClause ";
 319     }
 320
 321     if ($orderProfiles AND count($profileIds) > 1) {
 322       $query .= " ORDER BY FIELD(  g.id, {$gids} )";
 323     }
 324     $group      = CRM_Core_DAO::executeQuery($query, $params);
 325     $fields     = array();
 326     $validGroup = FALSE;
 327
 328     while ($group->fetch()) {
 329       $validGroup = TRUE;
 330       $query = self::createUFFieldQuery($group->id, $searchable, $showAll, $visibility, $orderBy);
 331       $field = CRM_Core_DAO::executeQuery($query);
 332
 333       $profileType = CRM_Core_BAO_UFField::getProfileType($group->id);
 334       $contactActivityProfile = CRM_Core_BAO_UFField::checkContactActivityProfileType($group->id);
 335       $importableFields = self::getImportableFields($showAll, $profileType, $contactActivityProfile);
 336       list($customFields, $addressCustomFields) = self::getCustomFields($ctype);
 337
 338       while ($field->fetch()) {
 339         list($name, $formattedField) = self::formatUFField($group, $field, $customFields, $addressCustomFields, $importableFields, $permissionType);
 340         if ($formattedField !== NULL) {
 341           $fields[$name] = $formattedField;
 342         }
 343       }
 344       $field->free();
 345     }
 346
 347     if (empty($fields) && !$validGroup) {
 348       CRM_Core_Error::fatal(ts('The requested Profile (gid=%1) is disabled OR it is not configured to be used for \'Profile\' listings in its Settings OR there is no Profile with that ID OR you do not have permission to access this profile. Please contact the site administrator if you need assistance.',
 349           array(1 => implode(',', $profileIds))
 350         ));
 351     }
 352     else {
 353       self::reformatProfileFields($fields);
 354     }
 355
 356     return $fields;
 357   }
 358
 359   /**
 360    * Format a list of UFFields for use with buildProfile. This is the in-memory analog
 361    * of getFields().
 362    *
 363    * @param array $groupArr (mimic CRM_UF_DAO_UFGroup)
 364    * @param array $fieldArrs list of fields (each mimics CRM_UF_DAO_UFField)
 365    * @param bool $visibility visibility of fields we are interested in
 366    * @param bool $searchable
 367    * @param bool $showAll
 368    * @param null $ctype
 369    * @param int $permissionType
 370    *
 371    * @internal param bool $showall
 372    * @return array
 373    * @see getFields
 374    */
 375   public static function formatUFFields(
 376     $groupArr,
 377     $fieldArrs,
 378     $visibility = NULL,
 379     $searchable = NULL,
 380     $showAll = FALSE,
 381     $ctype = NULL,
 382     $permissionType = CRM_Core_Permission::CREATE
 383   ) {
 384     // $group = new CRM_Core_DAO_UFGroup();
 385     // $group->copyValues($groupArr); // no... converts string('') to string('null')
 386     $group = (object) $groupArr;
 387
 388     // Refactoring note: The $fieldArrs here may be slightly different than the $ufFields
 389     // used by calculateGroupType, but I don't think the missing fields matter, and -- if
 390     // they did -- the obvious fix would produce mutual recursion.
 391     $ufGroupType = self::_calculateGroupType($fieldArrs);
 392     $profileType = CRM_Core_BAO_UFField::calculateProfileType(implode(',',$ufGroupType));
 393     $contactActivityProfile = CRM_Core_BAO_UFField::checkContactActivityProfileTypeByGroupType(implode(',',$ufGroupType));
 394     $importableFields = self::getImportableFields($showAll, $profileType, $contactActivityProfile);
 395     list($customFields, $addressCustomFields) = self::getCustomFields($ctype);
 396
 397     $formattedFields = array();
 398     foreach ($fieldArrs as $fieldArr) {
 399       $field = (object) $fieldArr;
 400       if (!self::filterUFField($field, $searchable, $showAll, $visibility)) {
 401         continue;
 402       }
 403
 404       list($name, $formattedField) = self::formatUFField($group, $field, $customFields, $addressCustomFields, $importableFields, $permissionType);
 405       if ($formattedField !== NULL) {
 406         $formattedFields[$name] = $formattedField;
 407       }
 408     }
 409     return $formattedFields;
 410   }
 411
 412   /**
 413    * Prepare a field for rendering with CRM_Core_BAO_UFGroup::buildProfile.
 414    *
 415    * @param CRM_Core_DAO_UFGroup|CRM_Core_DAO $group
 416    * @param CRM_Core_DAO_UFField|CRM_Core_DAO $field
 417    * @param array $addressCustomFields
 418    * @param array $importableFields
 419    * @param array $customFields
 420    * @param int $permissionType eg CRM_Core_Permission::CREATE
 421    * @return array
 422    */
 423   protected static function formatUFField(
 424     $group,
 425     $field,
 426     $customFields,
 427     $addressCustomFields,
 428     $importableFields,
 429     $permissionType = CRM_Core_Permission::CREATE
 430   ) {
 431     $name = $field->field_name;
 432     $title = $field->label;
 433
 434     $addressCustom = FALSE;
 435     if (in_array($permissionType, array(
 436       CRM_Core_Permission::CREATE,
 437       CRM_Core_Permission::EDIT,
 438     )) &&
 439       in_array($field->field_name, array_keys($addressCustomFields))
 440     ) {
 441       $addressCustom = TRUE;
 442       $name = "address_{$name}";
 443     }
 444     if ($field->field_name == 'url') {
 445       $name .= "-{$field->website_type_id}";
 446     }
 447     elseif (!empty($field->location_type_id)) {
 448       $name .= "-{$field->location_type_id}";
 449     }
 450     else {
 451       $locationFields = self::getLocationFields();
 452       if (in_array($field->field_name, $locationFields) || $addressCustom) {
 453         $name .= '-Primary';
 454       }
 455     }
 456
 457     if (isset($field->phone_type_id)) {
 458       $name .= "-{$field->phone_type_id}";
 459     }
 460
 461     // No lie: this is bizarre; why do we need to mix so many UFGroup properties into UFFields?
 462     // I guess to make field self sufficient with all the required data and avoid additional calls
 463     $formattedField = array(
 464       'name' => $name,
 465       'groupTitle' => $group->title,
 466       'groupName'  => $group->name,
 467       'groupHelpPre' => empty($group->help_pre) ? '' : $group->help_pre,
 468       'groupHelpPost' => empty($group->help_post) ? '' : $group->help_post,
 469       'title' => $title,
 470       'where' => CRM_Utils_Array::value('where', CRM_Utils_Array::value($field->field_name, $importableFields)),
 471       'attributes' => CRM_Core_DAO::makeAttribute(CRM_Utils_Array::value($field->field_name, $importableFields)),
 472       'is_required' => $field->is_required,
 473       'is_view' => $field->is_view,
 474       'help_pre' => $field->help_pre,
 475       'help_post' => $field->help_post,
 476       'visibility' => $field->visibility,
 477       'in_selector' => $field->in_selector,
 478       'rule' => CRM_Utils_Array::value('rule', CRM_Utils_Array::value($field->field_name, $importableFields)),
 479       'location_type_id' => isset($field->location_type_id) ? $field->location_type_id : NULL,
 480       'website_type_id' => isset($field->website_type_id) ? $field->website_type_id : NULL,
 481       'phone_type_id' => isset($field->phone_type_id) ? $field->phone_type_id : NULL,
 482       'group_id' => $group->id,
 483       'add_to_group_id' => isset($group->add_to_group_id) ? $group->add_to_group_id : NULL,
 484       'add_captcha' => isset($group->add_captcha) ? $group->add_captcha : NULL,
 485       'field_type' => $field->field_type,
 486       'field_id' => $field->id,
 487       'pseudoconstant' => CRM_Utils_Array::value(
 488         'pseudoconstant',
 489         CRM_Utils_Array::value($field->field_name, $importableFields)
 490       ),
 491       // obsolete this when we remove the name / dbName discrepancy with gender/suffix/prefix
 492       'dbName' => CRM_Utils_Array::value(
 493         'dbName',
 494         CRM_Utils_Array::value($field->field_name, $importableFields)
 495       ),
 496       'skipDisplay' => 0,
 497     );
 498
 499     //adding custom field property
 500     if (substr($field->field_name, 0, 6) == 'custom' ||
 501       substr($field->field_name, 0, 14) === 'address_custom'
 502     ) {
 503       // if field is not present in customFields, that means the user
 504       // DOES NOT HAVE permission to access that field
 505       if (array_key_exists($field->field_name, $customFields)) {
 506         $formattedField['is_search_range'] = $customFields[$field->field_name]['is_search_range'];
 507         // fix for CRM-1994
 508         $formattedField['options_per_line'] = $customFields[$field->field_name]['options_per_line'];
 509         $formattedField['data_type'] = $customFields[$field->field_name]['data_type'];
 510         $formattedField['html_type'] = $customFields[$field->field_name]['html_type'];
 511
 512         if (CRM_Utils_Array::value('html_type', $formattedField) == 'Select Date') {
 513           $formattedField['date_format'] = $customFields[$field->field_name]['date_format'];
 514           $formattedField['time_format'] = $customFields[$field->field_name]['time_format'];
 515         }
 516
 517         $formattedField['is_multi_summary'] = $field->is_multi_summary;
 518         return array($name, $formattedField);
 519       }
 520       else {
 521         $formattedField = NULL;
 522         return array($name, $formattedField);
 523       }
 524     }
 525     return array($name, $formattedField);
 526   }
 527
 528   /**
 529    * Create a query to find all visible UFFields in a UFGroup
 530    *
 531    * This is the SQL-variant of checkUFFieldDisplayable().
 532    *
 533    * @param int $groupId
 534    * @param bool $searchable
 535    * @param bool $showAll
 536    * @param int $visibility
 537    * @param string $orderBy comma-delimited list of SQL columns
 538    * @return string
 539    */
 540   protected static function createUFFieldQuery($groupId, $searchable, $showAll, $visibility, $orderBy) {
 541     $where = " WHERE uf_group_id = {$groupId}";
 542
 543     if ($searchable) {
 544       $where .= " AND is_searchable = 1";
 545     }
 546
 547     if (!$showAll) {
 548       $where .= " AND is_active = 1";
 549     }
 550
 551     if ($visibility) {
 552       $clause = array();
 553       if ($visibility & self::PUBLIC_VISIBILITY) {
 554         $clause[] = 'visibility = "Public Pages"';
 555       }
 556       if ($visibility & self::ADMIN_VISIBILITY) {
 557         $clause[] = 'visibility = "User and User Admin Only"';
 558       }
 559       if ($visibility & self::LISTINGS_VISIBILITY) {
 560         $clause[] = 'visibility = "Public Pages and Listings"';
 561       }
 562       if (!empty($clause)) {
 563         $where .= ' AND ( ' . implode(' OR ', $clause) . ' ) ';
 564       }
 565     }
 566
 567     $query = "SELECT * FROM civicrm_uf_field $where ORDER BY weight";
 568     if ($orderBy) {
 569       $query .= ", " . $orderBy;
 570       return $query;
 571     }
 572     return $query;
 573   }
 574
 575   /**
 576    * Create a query to find all visible UFFields in a UFGroup
 577    *
 578    * This is the PHP in-memory variant of createUFFieldQuery().
 579    *
 580    * @param CRM_Core_DAO_UFField|CRM_Core_DAO $field
 581    * @param bool $searchable
 582    * @param bool $showAll
 583    * @param int $visibility
 584    * @return bool TRUE if field is displayable
 585    */
 586   protected static function filterUFField($field, $searchable, $showAll, $visibility) {
 587     if ($searchable && $field->is_searchable != 1) {
 588       return FALSE;
 589     }
 590
 591     if (!$showAll && $field->is_active != 1) {
 592       return FALSE;
 593     }
 594
 595     if ($visibility) {
 596       $allowedVisibilities = array();
 597       if ($visibility & self::PUBLIC_VISIBILITY) {
 598         $allowedVisibilities[] = 'Public Pages';
 599       }
 600       if ($visibility & self::ADMIN_VISIBILITY) {
 601         $allowedVisibilities[] = 'User and User Admin Only';
 602       }
 603       if ($visibility & self::LISTINGS_VISIBILITY) {
 604         $allowedVisibilities[] = 'Public Pages and Listings';
 605       }
 606       // !empty($allowedVisibilities) seems silly to me, but it is equivalent to the pre-existing SQL
 607       if (!empty($allowedVisibilities) && !in_array($field->visibility, $allowedVisibilities)) {
 608         return FALSE;
 609       }
 610     }
 611
 612     return TRUE;
 613   }
 614
 615   /**
 616    * @param $showAll
 617    * @param $profileType
 618    * @param $contactActivityProfile
 619    *
 620    * @return array
 621    */
 622   protected static function getImportableFields($showAll, $profileType, $contactActivityProfile) {
 623     if (!$showAll) {
 624       $importableFields = CRM_Contact_BAO_Contact::importableFields('All', FALSE, FALSE, FALSE, TRUE, TRUE);
 625     }
 626     else {
 627       $importableFields = CRM_Contact_BAO_Contact::importableFields('All', FALSE, TRUE, FALSE, TRUE, TRUE);
 628     }
 629
 630     if ($profileType == 'Activity' || $contactActivityProfile) {
 631       $componentFields = CRM_Activity_BAO_Activity::getProfileFields();
 632     }
 633     else {
 634       $componentFields = CRM_Core_Component::getQueryFields();
 635     }
 636
 637     $importableFields = array_merge($importableFields, $componentFields);
 638
 639     $importableFields['group']['title'] = ts('Group(s)');
 640     $importableFields['group']['where'] = NULL;
 641     $importableFields['tag']['title'] = ts('Tag(s)');
 642     $importableFields['tag']['where'] = NULL;
 643     return $importableFields;
 644   }
 645
 646   public static function getLocationFields() {
 647     static $locationFields = array(
 648       'street_address',
 649       'supplemental_address_1',
 650       'supplemental_address_2',
 651       'city',
 652       'postal_code',
 653       'postal_code_suffix',
 654       'geo_code_1',
 655       'geo_code_2',
 656       'state_province',
 657       'country',
 658       'county',
 659       'phone',
 660       'phone_and_ext',
 661       'email',
 662       'im',
 663       'address_name',
 664       'phone_ext',
 665     );
 666     return $locationFields;
 667   }
 668
 669   /**
 670    * @param $ctype
 671    *
 672    * @return mixed
 673    */
 674   protected static function getCustomFields($ctype) {
 675     static $customFieldCache = array();
 676     if (!isset($customFieldCache[$ctype])) {
 677       $customFields = CRM_Core_BAO_CustomField::getFieldsForImport($ctype, FALSE, FALSE, FALSE, TRUE, TRUE);
 678
 679       // hack to add custom data for components
 680       $components = array('Contribution', 'Participant', 'Membership', 'Activity', 'Case');
 681       foreach ($components as $value) {
 682         $customFields = array_merge($customFields, CRM_Core_BAO_CustomField::getFieldsForImport($value));
 683       }
 684       $addressCustomFields = CRM_Core_BAO_CustomField::getFieldsForImport('Address');
 685       $customFields = array_merge($customFields, $addressCustomFields);
 686       $customFieldCache[$ctype] = array($customFields, $addressCustomFields);
 687     }
 688     return $customFieldCache[$ctype];
 689   }
 690
 691   /**
 692    * check the data validity
 693    *
 694    * @param int $userID the user id that we are actually editing
 695    * @param string $title the title of the group we are interested in
 696    * @param bool $register
 697    * @param int $action the action of the form
 698    *
 699    * @pram  boolean $register is this the registrtion form
 700    * @return boolean   true if form is valid
 701    * @static
 702    * @access public
 703    */
 704   static function isValid($userID, $title, $register = FALSE, $action = NULL) {
 705     if ($register) {
 706       $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
 707         ts('Dynamic Form Creator'),
 708         $action
 709       );
 710       $controller->set('id', $userID);
 711       $controller->set('register', 1);
 712       $controller->process();
 713       return $controller->validate();
 714     }
 715     else {
 716       // make sure we have a valid group
 717       $group = new CRM_Core_DAO_UFGroup();
 718
 719       $group->title = $title;
 720
 721       if ($group->find(TRUE) && $userID) {
 722         $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic', ts('Dynamic Form Creator'), $action);
 723         $controller->set('gid', $group->id);
 724         $controller->set('id', $userID);
 725         $controller->set('register', 0);
 726         $controller->process();
 727         return $controller->validate();
 728       }
 729       return TRUE;
 730     }
 731   }
 732
 733   /**
 734    * get the html for the form that represents this particular group
 735    *
 736    * @param int $userID the user id that we are actually editing
 737    * @param string $title the title of the group we are interested in
 738    * @param int $action the action of the form
 739    * @param boolean $register is this the registration form
 740    * @param boolean $reset should we reset the form?
 741    * @param int $profileID do we have the profile ID?
 742    *
 743    * @param bool $doNotProcess
 744    * @param null $ctype
 745    *
 746    * @return string       the html for the form on success, otherwise empty string
 747    * @static
 748    * @access public
 749    */
 750   static function getEditHTML($userID,
 751     $title,
 752     $action       = NULL,
 753     $register     = FALSE,
 754     $reset        = FALSE,
 755     $profileID    = NULL,
 756     $doNotProcess = FALSE,
 757     $ctype        = NULL
 758   ) {
 759
 760     if ($register) {
 761       $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
 762         ts('Dynamic Form Creator'),
 763         $action
 764       );
 765       if ($reset || $doNotProcess) {
 766         // hack to make sure we do not process this form
 767         $oldQFDefault = CRM_Utils_Array::value('_qf_default',
 768           $_POST
 769         );
 770         unset($_POST['_qf_default']);
 771         unset($_REQUEST['_qf_default']);
 772         if ($reset) {
 773           $controller->reset();
 774         }
 775       }
 776
 777       $controller->set('id', $userID);
 778       $controller->set('register', 1);
 779       $controller->set('skipPermission', 1);
 780       $controller->set('ctype', $ctype);
 781       $controller->process();
 782       if ($doNotProcess || !empty($_POST)) {
 783         $controller->validate();
 784       }
 785       $controller->setEmbedded(TRUE);
 786
 787       //CRM-5839 - though we want to process form, get the control back.
 788       $controller->setSkipRedirection(($doNotProcess) ? FALSE : TRUE);
 789
 790       $controller->run();
 791
 792       // we are done processing so restore the POST/REQUEST vars
 793       if (($reset || $doNotProcess) && $oldQFDefault) {
 794         $_POST['_qf_default'] = $_REQUEST['_qf_default'] = $oldQFDefault;
 795       }
 796
 797       $template = CRM_Core_Smarty::singleton();
 798
 799       // Hide CRM error messages if they are displayed using drupal form_set_error.
 800       if (!empty($_POST)) {
 801         $template->assign('suppressForm', TRUE);
 802       }
 803
 804       return trim($template->fetch('CRM/Profile/Form/Dynamic.tpl'));
 805     }
 806     else {
 807       if (!$profileID) {
 808         // make sure we have a valid group
 809         $group = new CRM_Core_DAO_UFGroup();
 810
 811         $group->title = $title;
 812
 813         if ($group->find(TRUE)) {
 814           $profileID = $group->id;
 815         }
 816       }
 817
 818       if ($profileID) {
 819         // make sure profileID and ctype match if ctype exists
 820         if ($ctype) {
 821           $profileType = CRM_Core_BAO_UFField::getProfileType($profileID);
 822           if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
 823             $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
 824           }
 825
 826           if (($profileType != 'Contact') && ($profileType != $ctype)) {
 827             return NULL;
 828           }
 829         }
 830
 831         $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
 832           ts('Dynamic Form Creator'),
 833           $action
 834         );
 835         if ($reset) {
 836           $controller->reset();
 837         }
 838         $controller->set('gid', $profileID);
 839         $controller->set('id', $userID);
 840         $controller->set('register', 0);
 841         $controller->set('skipPermission', 1);
 842         if ($ctype) {
 843           $controller->set('ctype', $ctype);
 844         }
 845         $controller->process();
 846         $controller->setEmbedded(TRUE);
 847
 848         //CRM-5846 - give the control back to drupal.
 849         $controller->setSkipRedirection(($doNotProcess) ? FALSE : TRUE);
 850         $controller->run();
 851
 852         $template = CRM_Core_Smarty::singleton();
 853
 854         // Hide CRM error messages if they are displayed using drupal form_set_error.
 855         if (!empty($_POST) && CRM_Core_Config::singleton()->userFramework == 'Drupal') {
 856           if (arg(0) == 'user' || (arg(0) == 'admin' && arg(1) == 'people')) {
 857             $template->assign('suppressForm', TRUE);
 858           }
 859         }
 860
 861         $templateFile = "CRM/Profile/Form/{$profileID}/Dynamic.tpl";
 862         if (!$template->template_exists($templateFile)) {
 863           $templateFile = 'CRM/Profile/Form/Dynamic.tpl';
 864         }
 865         return trim($template->fetch($templateFile));
 866       }
 867       else {
 868         $userEmail = CRM_Contact_BAO_Contact_Location::getEmailDetails($userID);
 869
 870         // if post not empty then only proceed
 871         if (!empty($_POST)) {
 872           // get the new email
 873           $config = CRM_Core_Config::singleton();
 874           $email = CRM_Utils_Array::value('mail', $_POST);
 875
 876           if (CRM_Utils_Rule::email($email) && ($email != $userEmail[1])) {
 877             CRM_Core_BAO_UFMatch::updateContactEmail($userID, $email);
 878           }
 879         }
 880       }
 881     }
 882     return '';
 883   }
 884
 885   /**
 886    * searches for a contact in the db with similar attributes
 887    *
 888    * @param array $params the list of values to be used in the where clause
 889    * @param int $id the current contact id (hence excluded from matching)
 890    * @param string $contactType
 891    *
 892    * @internal param bool $flatten should we flatten the input params
 893    *
 894    * @return contact_id if found, null otherwise
 895    * @access public
 896    * @static
 897    */
 898   public static function findContact(&$params, $id = NULL, $contactType = 'Individual') {
 899     $dedupeParams = CRM_Dedupe_Finder::formatParams($params, $contactType);
 900     $dedupeParams['check_permission'] = CRM_Utils_Array::value('check_permission', $params, TRUE);
 901     $ids = CRM_Dedupe_Finder::dupesByParams($dedupeParams, $contactType, 'Supervised', array($id));
 902     if (!empty($ids)) {
 903       return implode(',', $ids);
 904     }
 905     else {
 906       return NULL;
 907     }
 908   }
 909
 910   /**
 911    * Given a contact id and a field set, return the values from the db
 912    * for this contact
 913    *
 914    * @param $cid
 915    * @param array $fields the profile fields of interest
 916    * @param array $values the values for the above fields
 917    * @param boolean $searchable searchable or not
 918    * @param array $componentWhere component condition
 919    * @param boolean $absolute return urls in absolute form (useful when sending an email)
 920    *
 921    * @param null $additionalWhereClause
 922    *
 923    * @internal param int $id the contact id
 924    * @return void
 925    * @access public
 926    * @static
 927    */
 928   public static function getValues($cid, &$fields, &$values,
 929     $searchable = TRUE, $componentWhere = NULL,
 930     $absolute = FALSE, $additionalWhereClause = NULL
 931   ) {
 932     if (empty($cid) && empty($componentWhere)) {
 933       return NULL;
 934     }
 935
 936     // get the contact details (hier)
 937     $returnProperties = CRM_Contact_BAO_Contact::makeHierReturnProperties($fields);
 938     $params = $cid ? array(array('contact_id', '=', $cid, 0, 0)) : array();
 939
 940     // add conditions specified by components. eg partcipant_id etc
 941     if (!empty($componentWhere)) {
 942       $params = array_merge($params, $componentWhere);
 943     }
 944
 945     $query = new CRM_Contact_BAO_Query($params, $returnProperties, $fields);
 946     $options = &$query->_options;
 947
 948     $details = $query->searchQuery( 0, 0, NULL, FALSE, FALSE,
 949       FALSE, FALSE, FALSE, $additionalWhereClause);
 950     if (!$details->fetch()) {
 951       return;
 952     }
 953     $query->convertToPseudoNames($details);
 954     $config = CRM_Core_Config::singleton();
 955
 956     $locationTypes = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Address', 'location_type_id');
 957     $imProviders   = CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id');
 958     $websiteTypes  = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Website', 'website_type_id');
 959
 960     $multipleFields = array('url');
 961
 962     //start of code to set the default values
 963     foreach ($fields as $name => $field) {
 964       // fix for CRM-3962
 965       if ($name == 'id') {
 966         $name = 'contact_id';
 967       }
 968
 969       // skip fields that should not be displayed separately
 970       if (!empty($field['skipDisplay'])) {
 971         continue;
 972       }
 973
 974       // Create a unique, non-empty index for each field.
 975       $index = $field['title'];
 976       if ($index === '') $index = ' ';
 977       while (array_key_exists($index, $values))
 978         $index .= ' ';
 979
 980       $params[$index] = $values[$index] = '';
 981       $customFieldName = NULL;
 982       // hack for CRM-665
 983       if (isset($details->$name) || $name == 'group' || $name == 'tag') {
 984         // to handle gender / suffix / prefix
 985         if (in_array(substr($name, 0, -3), array('gender', 'prefix', 'suffix'))) {
 986           $params[$index] = $details->$name;
 987           $values[$index] = $details->$name;
 988         }
 989         elseif (in_array($name, CRM_Contact_BAO_Contact::$_greetingTypes)) {
 990           $dname          = $name . '_display';
 991           $values[$index] = $details->$dname;
 992           $name           = $name . '_id';
 993           $params[$index] = $details->$name;
 994         }
 995         elseif (in_array($name, array(
 996           'state_province', 'country', 'county'))) {
 997           $values[$index] = $details->$name;
 998           $idx            = $name . '_id';
 999           $params[$index] = $details->$idx;
1000         }
1001         elseif ($name === 'preferred_communication_method') {
1002           $communicationFields = CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'preferred_communication_method');
1003           $compref = array();
1004           $pref    = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details->$name);
1005
1006           foreach ($pref as $k) {
1007             if ($k) {
1008               $compref[] = $communicationFields[$k];
1009             }
1010           }
1011           $params[$index] = $details->$name;
1012           $values[$index] = implode(',', $compref);
1013         }
1014         elseif ($name === 'preferred_language') {
1015           $params[$index] = $details->$name;
1016           $values[$index] = CRM_Core_PseudoConstant::getLabel('CRM_Contact_DAO_Contact', 'preferred_language', $details->$name);
1017         }
1018         elseif ($name == 'group') {
1019           $groups = CRM_Contact_BAO_GroupContact::getContactGroup($cid, 'Added', NULL, FALSE, TRUE);
1020           $title = $ids = array();
1021
1022           foreach ($groups as $g) {
1023             // CRM-8362: User and User Admin visibility groups should be included in display if user has
1024             // VIEW permission on that group
1025             $groupPerm = CRM_Contact_BAO_Group::checkPermission($g['group_id'], $g['title']);
1026
1027             if ($g['visibility'] != 'User and User Admin Only' ||
1028               CRM_Utils_Array::key(CRM_Core_Permission::VIEW, $groupPerm)
1029             ) {
1030               $title[] = $g['title'];
1031               if ($g['visibility'] == 'Public Pages') {
1032                 $ids[] = $g['group_id'];
1033               }
1034             }
1035           }
1036           $values[$index] = implode(', ', $title);
1037           $params[$index] = implode(',', $ids);
1038         }
1039         elseif ($name == 'tag') {
1040           $entityTags = CRM_Core_BAO_EntityTag::getTag($cid);
1041           $allTags    = CRM_Core_PseudoConstant::get('CRM_Core_DAO_EntityTag', 'tag_id', array('onlyActive' => FALSE));
1042           $title      = array();
1043           foreach ($entityTags as $tagId) {
1044             $title[] = $allTags[$tagId];
1045           }
1046           $values[$index] = implode(', ', $title);
1047           $params[$index] = implode(',', $entityTags);
1048         }
1049         elseif ($name == 'activity_status_id') {
1050           $activityStatus = CRM_Core_PseudoConstant::activityStatus();
1051           $values[$index] = $activityStatus[$details->$name];
1052           $params[$index] = $details->$name;
1053         }
1054         elseif ($name == 'activity_date_time') {
1055           $values[$index] = CRM_Utils_Date::customFormat($details->$name);
1056           $params[$index] = $details->$name;
1057         }
1058         elseif ($name == 'contact_sub_type') {
1059           $contactSubTypeNames = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details->$name);
1060           if (!empty($contactSubTypeNames)) {
1061             $contactSubTypeLabels = array();
1062             // get all contact subtypes
1063             $allContactSubTypes = CRM_Contact_BAO_ContactType::subTypeInfo();
1064             // build contact subtype labels array
1065             foreach( $contactSubTypeNames as $cstName ) {
1066               if ($cstName) {
1067                 $contactSubTypeLabels[] = $allContactSubTypes[$cstName]['label'];
1068               }
1069             }
1070             $values[$index] = implode(',', $contactSubTypeLabels);
1071           }
1072
1073           $params[$index] = $details->$name;
1074         }
1075         else {
1076           if (substr($name, 0, 7) === 'do_not_' || substr($name, 0, 3) === 'is_') {
1077             if ($details->$name) {
1078               $values[$index] = '[ x ]';
1079             }
1080           }
1081           else {
1082             if ($cfID = CRM_Core_BAO_CustomField::getKeyID($name)) {
1083               $htmlType = $field['html_type'];
1084
1085               // field_type is only set when we are retrieving profile values
1086               // when sending email, we call the same function to get custom field
1087               // values etc, i.e. emulating a profile
1088               $fieldType = CRM_Utils_Array::value('field_type', $field);
1089
1090               if ($htmlType == 'File') {
1091                 $entityId = $cid;
1092                 if (!$cid &&
1093                   $fieldType == 'Activity' && !empty($componentWhere[0][2])) {
1094                   $entityId = $componentWhere[0][2];
1095                 }
1096
1097                 $fileURL = CRM_Core_BAO_CustomField::getFileURL($entityId,
1098                   $cfID,
1099                   NULL,
1100                   $absolute
1101                 );
1102                 $params[$index] = $values[$index] = $fileURL['file_url'];
1103               }
1104               else {
1105                 $customVal = NULL;
1106                 if (isset($dao) && property_exists($dao, 'data_type') &&
1107                   ($dao->data_type == 'Int' ||
1108                     $dao->data_type == 'Boolean'
1109                   )
1110                 ) {
1111                   $customVal = (int )($details->{$name});
1112                 }
1113                 elseif (isset($dao) && property_exists($dao, 'data_type')
1114                   && $dao->data_type == 'Float'
1115                 ) {
1116                   $customVal = (float )($details->{$name});
1117                 }
1118                 elseif (!CRM_Utils_System::isNull(explode(CRM_Core_DAO::VALUE_SEPARATOR,
1119                       $details->{$name}
1120                     ))) {
1121                   $customVal = $details->{$name};
1122                 }
1123
1124                 //CRM-4582
1125                 if (CRM_Utils_System::isNull($customVal)) {
1126                   continue;
1127                 }
1128
1129                 $params[$index] = $customVal;
1130                 $values[$index] = CRM_Core_BAO_CustomField::getDisplayValue($customVal,
1131                   $cfID,
1132                   $options
1133                 );
1134                 if ($field['data_type'] == 'ContactReference') {
1135                   $params[$index] = $values[$index];
1136                 }
1137                 if (CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
1138                     $cfID, 'is_search_range'
1139                   )) {
1140                   $customFieldName = "{$name}_from";
1141                 }
1142               }
1143             }
1144             elseif ($name == 'image_URL') {
1145               list($width, $height) = getimagesize(CRM_Utils_String::unstupifyUrl($details->$name));
1146               list($thumbWidth, $thumbHeight) = CRM_Contact_BAO_Contact::getThumbSize($width, $height);
1147
1148               $image_URL = '<img src="' . $details->$name . '" height= ' . $thumbHeight . ' width= ' . $thumbWidth . '  />';
1149               $values[$index] = "<a href='#' onclick='contactImagePopUp(\"{$details->$name}\", {$width}, {$height});'>{$image_URL}</a>";
1150             }
1151             elseif (in_array($name, array(
1152               'birth_date', 'deceased_date', 'membership_start_date', 'membership_end_date', 'join_date'))) {
1153               $values[$index] = CRM_Utils_Date::customFormat($details->$name);
1154               $params[$index] = CRM_Utils_Date::isoToMysql($details->$name);
1155             }
1156             else {
1157               $dao = '';
1158               if ($index == 'Campaign') {
1159                 $dao = 'CRM_Campaign_DAO_Campaign';
1160               }
1161               elseif ($index == 'Contribution Page') {
1162                 $dao = 'CRM_Contribute_DAO_ContributionPage';
1163               }
1164               if ($dao) {
1165                 $value = CRM_Core_DAO::getFieldValue($dao, $details->$name, 'title');
1166               }
1167               else {
1168                 $value = $details->$name;
1169               }
1170               $values[$index] = $value;
1171             }
1172           }
1173         }
1174       }
1175       elseif (strpos($name, '-') !== FALSE) {
1176         list($fieldName, $id, $type) = CRM_Utils_System::explode('-', $name, 3);
1177
1178         if (!in_array($fieldName, $multipleFields)) {
1179           if ($id == 'Primary') {
1180             // fix for CRM-1543
1181             // not sure why we'd every use Primary location type id
1182             // we need to fix the source if we are using it
1183             // $locationTypeName = CRM_Contact_BAO_Contact::getPrimaryLocationType( $cid );
1184             $locationTypeName = 1;
1185           }
1186           else {
1187             $locationTypeName = CRM_Utils_Array::value($id, $locationTypes);
1188           }
1189
1190           if (!$locationTypeName) {
1191             continue;
1192           }
1193
1194           $detailName = "{$locationTypeName}-{$fieldName}";
1195           $detailName = str_replace(' ', '_', $detailName);
1196
1197           if (in_array($fieldName, array(
1198             'phone', 'im', 'email', 'openid'))) {
1199             if ($type) {
1200               $detailName .= "-{$type}";
1201             }
1202           }
1203
1204           if (in_array($fieldName, array(
1205             'state_province', 'country', 'county'))) {
1206             $values[$index] = $details->$detailName;
1207             $idx            = $detailName . '_id';
1208             $params[$index] = $details->$idx;
1209           }
1210           elseif ($fieldName == 'im') {
1211             $providerId = $detailName . '-provider_id';
1212             if (isset($imProviders[$details->$providerId])) {
1213               $values[$index] = $details->$detailName . " (" . $imProviders[$details->$providerId] . ")";
1214             }
1215             else {
1216               $values[$index] = $details->$detailName;
1217             }
1218             $params[$index] = $details->$detailName;
1219           }
1220           elseif ($fieldName == 'phone') {
1221             $phoneExtField = str_replace('phone', 'phone_ext', $detailName);
1222             if (isset($details->$phoneExtField)) {
1223               $values[$index] = $details->$detailName . " (" . $details->$phoneExtField . ")";
1224             }
1225             else {
1226               $values[$index] = $details->$detailName;
1227             }
1228             $params[$index] = $details->$detailName;
1229           }
1230           else {
1231             $values[$index] = $params[$index] = $details->$detailName;
1232           }
1233         }
1234         else {
1235           $detailName = "website-{$id}-{$fieldName}";
1236           $url = CRM_Utils_System::fixURL($details->$detailName);
1237           if ($details->$detailName) {
1238             $websiteTypeId  = "website-{$id}-website_type_id";
1239             $websiteType    = $websiteTypes[$details->$websiteTypeId];
1240             $values[$index] = "<a href=\"$url\">{$details->$detailName} ( {$websiteType} )</a>";
1241           }
1242           else {
1243             $values[$index] = '';
1244           }
1245         }
1246       }
1247
1248       if ((CRM_Utils_Array::value('visibility', $field) == 'Public Pages and Listings') &&
1249         CRM_Core_Permission::check('profile listings and forms')
1250       ) {
1251
1252         if (CRM_Utils_System::isNull($params[$index])) {
1253           $params[$index] = $values[$index];
1254         }
1255         if (!isset($params[$index])) {
1256           continue;
1257         }
1258         if (!$customFieldName) {
1259           $fieldName = $field['name'];
1260         }
1261         else {
1262           $fieldName = $customFieldName;
1263         }
1264
1265         $url = NULL;
1266         if (CRM_Core_BAO_CustomField::getKeyID($field['name'])) {
1267           $htmlType = $field['html_type'];
1268           if ($htmlType == 'Link') {
1269             $url = $params[$index];
1270           }
1271           elseif (in_array($htmlType, array(
1272             'CheckBox', 'Multi-Select', 'AdvMulti-Select',
1273                 'Multi-Select State/Province', 'Multi-Select Country',
1274               ))) {
1275             $valSeperator = CRM_Core_DAO::VALUE_SEPARATOR;
1276             $selectedOptions = explode($valSeperator, $params[$index]);
1277
1278             foreach ($selectedOptions as $key => $multiOption) {
1279               if ($multiOption) {
1280                 $url[] = CRM_Utils_System::url('civicrm/profile',
1281                   'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1282                   urlencode($fieldName) .
1283                   '=' .
1284                   urlencode($multiOption)
1285                 );
1286               }
1287             }
1288           }
1289           else {
1290             $url = CRM_Utils_System::url('civicrm/profile',
1291               'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1292               urlencode($fieldName) .
1293               '=' .
1294               urlencode($params[$index])
1295             );
1296           }
1297         }
1298         else {
1299           $url = CRM_Utils_System::url('civicrm/profile',
1300             'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1301             urlencode($fieldName) .
1302             '=' .
1303             urlencode($params[$index])
1304           );
1305         }
1306
1307         if ($url &&
1308           !empty($values[$index]) &&
1309           $searchable
1310         ) {
1311
1312           if (is_array($url) && !empty($url)) {
1313             $links = array();
1314             $eachMultiValue = explode(', ', $values[$index]);
1315             foreach ($eachMultiValue as $key => $valueLabel) {
1316               $links[] = '<a href="' . $url[$key] . '">' . $valueLabel . '</a>';
1317             }
1318             $values[$index] = implode(', ', $links);
1319           }
1320           else {
1321             $values[$index] = '<a href="' . $url . '">' . $values[$index] . '</a>';
1322           }
1323         }
1324       }
1325     }
1326   }
1327
1328   /**
1329    * Check if profile Group used by any module.
1330    *
1331    * @param int  $id    profile Id
1332    *
1333    * @return boolean
1334    *
1335    * @access public
1336    * @static
1337    *
1338    */
1339   public static function usedByModule($id) {
1340     //check whether this group is used by any module(check uf join records)
1341     $sql = "SELECT id
1342                  FROM civicrm_uf_join
1343                  WHERE civicrm_uf_join.uf_group_id=$id";
1344
1345     $dao = new CRM_Core_DAO();
1346     $dao->query($sql);
1347     if ($dao->fetch()) {
1348       return TRUE;
1349     }
1350     else {
1351       return FALSE;
1352     }
1353   }
1354
1355   /**
1356    * Delete the profile Group.
1357    *
1358    * @param int  $id    profile Id
1359    *
1360    * @return boolean
1361    *
1362    * @access public
1363    * @static
1364    *
1365    */
1366   public static function del($id) {
1367     //check whether this group contains  any profile fields
1368     $profileField = new CRM_Core_DAO_UFField();
1369     $profileField->uf_group_id = $id;
1370     $profileField->find();
1371     while ($profileField->fetch()) {
1372       CRM_Core_BAO_UFField::del($profileField->id);
1373     }
1374
1375     //delete records from uf join table
1376     $ufJoin = new CRM_Core_DAO_UFJoin();
1377     $ufJoin->uf_group_id = $id;
1378     $ufJoin->delete();
1379
1380     //delete profile group
1381     $group = new CRM_Core_DAO_UFGroup();
1382     $group->id = $id;
1383     $group->delete();
1384     return 1;
1385   }
1386
1387   /**
1388    * function to add the UF Group
1389    *
1390    * @param array $params reference array contains the values submitted by the form
1391    * @param array $ids    reference array contains the id
1392    *
1393    * @access public
1394    * @static
1395    *
1396    * @return object
1397    */
1398   static function add(&$params, $ids = array()) {
1399     $fields = array('is_active', 'add_captcha', 'is_map', 'is_update_dupe', 'is_edit_link', 'is_uf_link', 'is_cms_user');
1400     foreach ($fields as $field) {
1401       $params[$field] = CRM_Utils_Array::value($field, $params, FALSE);
1402     }
1403
1404     $params['limit_listings_group_id'] = CRM_Utils_Array::value('group', $params);
1405     $params['add_to_group_id'] = CRM_Utils_Array::value('add_contact_to_group', $params);
1406
1407     $ufGroup = new CRM_Core_DAO_UFGroup();
1408     $ufGroup->copyValues($params);
1409
1410     $ufGroupID = CRM_Utils_Array::value('ufgroup', $ids, CRM_Utils_Array::value('id', $params));
1411     if (!$ufGroupID) {
1412       $ufGroup->name = CRM_Utils_String::munge($ufGroup->title, '_', 56);
1413     }
1414     $ufGroup->id = $ufGroupID;
1415
1416     $ufGroup->save();
1417
1418     if (!$ufGroupID) {
1419       $ufGroup->name = $ufGroup->name . "_{$ufGroup->id}";
1420       $ufGroup->save();
1421     }
1422
1423     return $ufGroup;
1424   }
1425
1426   /**
1427    * Function to make uf join entries for an uf group
1428    *
1429    * @param array $params       (reference) an assoc array of name/value pairs
1430    * @param int   $ufGroupId    ufgroup id
1431    *
1432    * @return void
1433    * @access public
1434    * @static
1435    */
1436   static function createUFJoin(&$params, $ufGroupId) {
1437     $groupTypes = CRM_Utils_Array::value('uf_group_type', $params);
1438
1439     // get ufjoin records for uf group
1440     $ufGroupRecord = CRM_Core_BAO_UFGroup::getUFJoinRecord($ufGroupId);
1441
1442     // get the list of all ufgroup types
1443     $allUFGroupType = CRM_Core_SelectValues::ufGroupTypes();
1444
1445     // this fix is done to prevent warning generated by array_key_exits incase of empty array is given as input
1446     if (!is_array($groupTypes)) {
1447       $groupTypes = array();
1448     }
1449
1450     // this fix is done to prevent warning generated by array_key_exits incase of empty array is given as input
1451     if (!is_array($ufGroupRecord)) {
1452       $ufGroupRecord = array();
1453     }
1454
1455     // check which values has to be inserted/deleted for contact
1456     $menuRebuild = FALSE;
1457     foreach ($allUFGroupType as $key => $value) {
1458       $joinParams = array();
1459       $joinParams['uf_group_id'] = $ufGroupId;
1460       $joinParams['module'] = $key;
1461       if ($key == 'User Account') {
1462         $menuRebuild = TRUE;
1463       }
1464       if (array_key_exists($key, $groupTypes) && !in_array($key, $ufGroupRecord)) {
1465         // insert a new record
1466         CRM_Core_BAO_UFGroup::addUFJoin($joinParams);
1467       }
1468       elseif (!array_key_exists($key, $groupTypes) && in_array($key, $ufGroupRecord)) {
1469         // delete a record for existing ufgroup
1470         CRM_Core_BAO_UFGroup::delUFJoin($joinParams);
1471       }
1472     }
1473
1474     //update the weight
1475     $query = "
1476 UPDATE civicrm_uf_join
1477 SET    weight = %1
1478 WHERE  uf_group_id = %2
1479 AND    ( entity_id IS NULL OR entity_id <= 0 )
1480 ";
1481     $p = array(1 => array($params['weight'], 'Integer'),
1482       2 => array($ufGroupId, 'Integer'),
1483     );
1484     CRM_Core_DAO::executeQuery($query, $p);
1485
1486     // do a menu rebuild if we are on drupal, so it gets all the new menu entries
1487     // for user account
1488     $config = CRM_Core_Config::singleton();
1489     if ($menuRebuild &&
1490       $config->userSystem->is_drupal
1491     ) {
1492       menu_rebuild();
1493     }
1494   }
1495
1496   /**
1497    * Function to get the UF Join records for an ufgroup id
1498    *
1499    * @params int $ufGroupId uf group id
1500    * @params int $displayName if set return display name in array
1501    * @params int $status if set return module other than default modules (User Account/User registration/Profile)
1502    *
1503    * @param null $ufGroupId
1504    * @param null $displayName
1505    * @param null $status
1506    *
1507    * @return array $ufGroupJoinRecords
1508    *
1509    * @access public
1510    * @static
1511    */
1512   public static function getUFJoinRecord($ufGroupId = NULL, $displayName = NULL, $status = NULL) {
1513     if ($displayName) {
1514       $UFGroupType = array();
1515       $UFGroupType = CRM_Core_SelectValues::ufGroupTypes();
1516     }
1517
1518     $ufJoin = array();
1519     $dao = new CRM_Core_DAO_UFJoin();
1520
1521     if ($ufGroupId) {
1522       $dao->uf_group_id = $ufGroupId;
1523     }
1524
1525     $dao->find();
1526     $ufJoin = array();
1527
1528     while ($dao->fetch()) {
1529       if (!$displayName) {
1530         $ufJoin[$dao->id] = $dao->module;
1531       }
1532       else {
1533         if (isset($UFGroupType[$dao->module])) {
1534           // skip the default modules
1535           if (!$status) {
1536             $ufJoin[$dao->id] = $UFGroupType[$dao->module];
1537           }
1538           // added for CRM-1475
1539         }
1540         elseif (!CRM_Utils_Array::key($dao->module, $ufJoin)) {
1541           $ufJoin[$dao->id] = $dao->module;
1542         }
1543       }
1544     }
1545     return $ufJoin;
1546   }
1547
1548   /**
1549    * Function takes an associative array and creates a ufjoin record for ufgroup
1550    *
1551    * @param array $params (reference) an assoc array of name/value pairs
1552    *
1553    * @return object CRM_Core_BAO_UFJoin object
1554    * @access public
1555    * @static
1556    */
1557   static function addUFJoin(&$params) {
1558     $ufJoin = new CRM_Core_DAO_UFJoin();
1559     $ufJoin->copyValues($params);
1560     $ufJoin->save();
1561     return $ufJoin;
1562   }
1563
1564   /**
1565    * Function to delete the uf join record for an uf group
1566    *
1567    * @param array  $params    (reference) an assoc array of name/value pairs
1568    *
1569    * @return void
1570    * @access public
1571    * @static
1572    */
1573   static function delUFJoin(&$params) {
1574     $ufJoin = new CRM_Core_DAO_UFJoin();
1575     $ufJoin->copyValues($params);
1576     $ufJoin->delete();
1577   }
1578
1579   /**
1580    * Function to get the weight for ufjoin record
1581    *
1582    * @param int $ufGroupId     if $ufGroupId get update weight or add weight
1583    *
1584    * @return int   weight of the UFGroup
1585    * @access public
1586    * @static
1587    */
1588   static function getWeight($ufGroupId = NULL) {
1589     //calculate the weight
1590     $p = array();
1591     if (!$ufGroupId) {
1592       $queryString = "SELECT ( MAX(civicrm_uf_join.weight)+1) as new_weight
1593                             FROM civicrm_uf_join
1594                             WHERE module = 'User Registration' OR module = 'User Account' OR module = 'Profile'";
1595     }
1596     else {
1597       $queryString = "SELECT MAX(civicrm_uf_join.weight) as new_weight
1598                             FROM civicrm_uf_join
1599                             WHERE civicrm_uf_join.uf_group_id = %1
1600                             AND ( entity_id IS NULL OR entity_id <= 0 )";
1601       $p[1] = array($ufGroupId, 'Integer');
1602     }
1603
1604     $dao = CRM_Core_DAO::executeQuery($queryString, $p);
1605     $dao->fetch();
1606     return ($dao->new_weight) ? $dao->new_weight : 1;
1607   }
1608
1609   /**
1610    * Function to get the uf group for a module
1611    *
1612    * @param string $moduleName module name
1613    * @param int $count no to increment the weight
1614    * @param bool $skipPermission
1615    * @param int $op - which operation (view, edit, create, etc) to check permission for
1616    * @param array|NULL $returnFields list of UFGroup fields to return; NULL for default
1617    *
1618    * @internal param bool $skipPermision - whether to add permission clause
1619    * @return array $ufGroups array of ufgroups for a module
1620    * @access public
1621    * @static
1622    */
1623   public static function getModuleUFGroup($moduleName = NULL, $count = 0, $skipPermission = TRUE, $op = CRM_Core_Permission::VIEW, $returnFields = NULL) {
1624     $selectFields = array('id', 'title', 'created_id', 'is_active', 'is_reserved', 'group_type');
1625
1626     if (!CRM_Core_Config::isUpgradeMode()) {
1627       // CRM-13555, since description field was added later (4.4), and to avoid any problems with upgrade
1628       $selectFields[] = 'description';
1629     }
1630
1631     if (!empty($returnFields)) {
1632       $selectFields = array_merge($returnFields, array_diff($selectFields, $returnFields));
1633     }
1634
1635     $queryString = 'SELECT civicrm_uf_group.' . implode(', civicrm_uf_group.', $selectFields) . '
1636                         FROM civicrm_uf_group
1637                         LEFT JOIN civicrm_uf_join ON (civicrm_uf_group.id = uf_group_id)';
1638     $p = array();
1639     if ($moduleName) {
1640       $queryString .= ' AND civicrm_uf_group.is_active = 1
1641                               WHERE civicrm_uf_join.module = %2';
1642       $p[2] = array($moduleName, 'String');
1643     }
1644
1645
1646     // add permissioning for profiles only if not registration
1647     if (!$skipPermission) {
1648       $permissionClause = CRM_Core_Permission::ufGroupClause($op, 'civicrm_uf_group.');
1649       if (strpos($queryString, 'WHERE') !== FALSE) {
1650         $queryString .= " AND $permissionClause ";
1651       }
1652       else {
1653         $queryString .= " $permissionClause ";
1654       }
1655     }
1656
1657     $queryString .= ' ORDER BY civicrm_uf_join.weight, civicrm_uf_group.title';
1658     $dao = CRM_Core_DAO::executeQuery($queryString, $p);
1659
1660     $ufGroups = array();
1661     while ($dao->fetch()) {
1662       //skip mix profiles in user Registration / User Account
1663       if (($moduleName == 'User Registration' || $moduleName == 'User Account') &&
1664         CRM_Core_BAO_UFField::checkProfileType($dao->id)
1665       ) {
1666         continue;
1667       }
1668       foreach ($selectFields as $key => $field) {
1669         if($field == 'id') {
1670           continue;
1671         }
1672         elseif ($field == 'name') {
1673           $ufGroups[$dao->id][$field] = $dao->title;
1674           continue;
1675         }
1676         $ufGroups[$dao->id][$field] = $dao->$field;
1677       }
1678     }
1679
1680     // Allow other modules to alter/override the UFGroups.
1681     CRM_Utils_Hook::buildUFGroupsForModule($moduleName, $ufGroups);
1682
1683     return $ufGroups;
1684   }
1685
1686   /**
1687    * Function to filter ufgroups based on logged in user contact type
1688    *
1689    * @params int $ufGroupId uf group id (profile id)
1690    *
1691    * @param $ufGroupId
1692    * @param null $contactID
1693    *
1694    * @return boolean true or false
1695    * @static
1696    * @access public
1697    */
1698   static function filterUFGroups($ufGroupId, $contactID = NULL) {
1699     if (!$contactID) {
1700       $session = CRM_Core_Session::singleton();
1701       $contactID = $session->get('userID');
1702     }
1703
1704     if ($contactID) {
1705       //get the contact type
1706       $contactType = CRM_Contact_BAO_Contact::getContactType($contactID);
1707
1708       //match if exixting contact type is same as profile contact type
1709       $profileType = CRM_Core_BAO_UFField::getProfileType($ufGroupId);
1710
1711       if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
1712         $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
1713       }
1714
1715       //allow special mix profiles for Contribution and Participant
1716       $specialProfiles = array('Contribution', 'Participant', 'Membership');
1717
1718       if (in_array($profileType, $specialProfiles)) {
1719         return TRUE;
1720       }
1721
1722       if (($contactType == $profileType) || $profileType == 'Contact') {
1723         return TRUE;
1724       }
1725     }
1726
1727     return FALSE;
1728   }
1729
1730   /**
1731    * Function to add profile field to a form
1732    *
1733    * @param CRM_Core_Form $form
1734    * @param array $field properties
1735    * @param int $mode profile mode
1736    * @param int $contactId
1737    * @param bool $online
1738    * @param string $usedFor for building up prefixed fieldname for special cases (e.g. onBehalf, Honor)
1739    * @param int $rowNumber
1740    * @param string $prefix
1741    *
1742    * @return null
1743    * @static
1744    * @access public
1745    */
1746   static function buildProfile(
1747     &$form,
1748     &$field,
1749     $mode,
1750     $contactId = NULL,
1751     $online = FALSE,
1752     $usedFor = NULL,
1753     $rowNumber = NULL ,
1754     $prefix = ''
1755   ) {
1756     $defaultValues = array();
1757     $fieldName = $field['name'];
1758     $title = $field['title'];
1759     $attributes = $field['attributes'];
1760     $rule = $field['rule'];
1761     $view = $field['is_view'];
1762     $required = ($mode == CRM_Profile_Form::MODE_SEARCH) ? FALSE : $field['is_required'];
1763     $search = ($mode == CRM_Profile_Form::MODE_SEARCH) ? TRUE : FALSE;
1764     $isShared = CRM_Utils_Array::value('is_shared', $field, 0);
1765
1766     // do not display view fields in drupal registration form
1767     // CRM-4632
1768     if ($view && $mode == CRM_Profile_Form::MODE_REGISTER) {
1769       return;
1770     }
1771
1772     if ($usedFor == 'onbehalf') {
1773       $name = "onbehalf[$fieldName]";
1774     }
1775     elseif ($usedFor == 'honor') {
1776       $name = "honor[$fieldName]";
1777     }
1778     elseif ($contactId && !$online) {
1779       $name = "field[$contactId][$fieldName]";
1780     }
1781     elseif ($rowNumber) {
1782       $name = "field[$rowNumber][$fieldName]";
1783     }
1784     elseif (!empty($prefix)) {
1785       $name = $prefix ."[$fieldName]";
1786     }
1787     else {
1788       $name = $fieldName;
1789     }
1790
1791     $selectAttributes = array('class' => 'crm-select2', 'placeholder' => TRUE);
1792
1793     // CRM-15172 - keep track of all the fields we've processed
1794     // This is hackish but we can't always rely on $form->_fields depending on how this is called
1795     static $fieldsProcessed = array();
1796     $fieldsProcessed[] = $name;
1797
1798     if ($fieldName == 'image_URL' && $mode == CRM_Profile_Form::MODE_EDIT) {
1799       $deleteExtra = ts('Are you sure you want to delete contact image.');
1800       $deleteURL = array(
1801         CRM_Core_Action::DELETE =>
1802         array(
1803           'name' => ts('Delete Contact Image'),
1804           'url' => 'civicrm/contact/image',
1805           'qs' => 'reset=1&id=%%id%%&gid=%%gid%%&action=delete',
1806           'extra' =>
1807           'onclick = "if (confirm( \'' . $deleteExtra . '\' ) ) this.href+=\'&amp;confirmed=1\'; else return false;"',
1808         ),
1809       );
1810       $deleteURL = CRM_Core_Action::formLink($deleteURL,
1811         CRM_Core_Action::DELETE,
1812         array('id' => $form->get('id'),
1813           'gid' => $form->get('gid'),
1814         ),
1815         ts('more'),
1816         FALSE,
1817         'contact.profileimage.delete',
1818         'Contact',
1819         $form->get('id')
1820       );
1821       $form->assign('deleteURL', $deleteURL);
1822     }
1823     $addressOptions = CRM_Core_BAO_Setting::valueOptions(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME,
1824       'address_options', TRUE, NULL, TRUE
1825     );
1826
1827     if (substr($fieldName, 0, 14) === 'state_province') {
1828       $controlField = str_replace('state_province', 'country', $name);
1829       if (isset($form->_fields[$controlField]) || in_array($controlField, $fieldsProcessed)) {
1830           $form->addChainSelect($name, array('label' => $title, 'required' => $required));
1831       }
1832       else {
1833         $options = CRM_Core_PseudoConstant::stateProvince();
1834         $form->add('select', $name, $title, $options, $required && $options, $selectAttributes);
1835       }
1836       $config = CRM_Core_Config::singleton();
1837       if (!in_array($mode, array(
1838         CRM_Profile_Form::MODE_EDIT, CRM_Profile_Form::MODE_SEARCH)) &&
1839         $config->defaultContactStateProvince
1840       ) {
1841         $defaultValues[$name] = $config->defaultContactStateProvince;
1842         $form->setDefaults($defaultValues);
1843       }
1844     }
1845     elseif (substr($fieldName, 0, 7) === 'country') {
1846       $form->add('select', $name, $title, array('' => ts('- select -')) + CRM_Core_PseudoConstant::country(), $required, $selectAttributes);
1847       $config = CRM_Core_Config::singleton();
1848       if (!in_array($mode, array(
1849         CRM_Profile_Form::MODE_EDIT, CRM_Profile_Form::MODE_SEARCH)) &&
1850         $config->defaultContactCountry
1851       ) {
1852         $defaultValues[$name] = $config->defaultContactCountry;
1853         $form->setDefaults($defaultValues);
1854       }
1855     }
1856     elseif (substr($fieldName, 0, 6) === 'county') {
1857       if ($addressOptions['county']) {
1858         $controlField = str_replace('county', 'state_province', $name);
1859         if (isset($form->_fields[$controlField]) || in_array($controlField, $fieldsProcessed)) {
1860           $form->addChainSelect($name, array('label' => $title, 'required' => $required));
1861         }
1862         else {
1863           $options = CRM_Core_PseudoConstant::county();
1864           $form->add('select', $name, $title, $options, $required && $options, $selectAttributes);
1865         }
1866       }
1867     }
1868     elseif (substr($fieldName, 0, 9) === 'image_URL') {
1869       $form->add('file', $name, $title, $attributes, $required);
1870       $form->addUploadElement($name);
1871     }
1872     elseif (substr($fieldName, 0, 2) === 'im') {
1873       $form->add('text', $name, $title, $attributes, $required);
1874       if (!$contactId) {
1875         if ($usedFor) {
1876           if (substr($name, -1) == ']') {
1877             $providerName = substr($name, 0, -1) . '-provider_id]';
1878           }
1879           $form->add('select', $providerName, NULL,
1880             array(
1881               '' => ts('- select -')) + CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id'), $required
1882           );
1883         }
1884         else {
1885           $form->add('select', $name . '-provider_id', $title,
1886             array(
1887               '' => ts('- select -')) + CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id'), $required
1888           );
1889         }
1890
1891         if ($view && $mode != CRM_Profile_Form::MODE_SEARCH) {
1892           $form->freeze($name . '-provider_id');
1893         }
1894       }
1895     }
1896     elseif (($fieldName === 'birth_date') || ($fieldName === 'deceased_date')) {
1897       $form->addDate($name, $title, $required, array('formatType' => 'birth'));
1898     }
1899     elseif (in_array($fieldName, array(
1900       'membership_start_date', 'membership_end_date', 'join_date'))) {
1901       $form->addDate($name, $title, $required, array('formatType' => 'custom'));
1902     }
1903     elseif (CRM_Utils_Array::value('name',$field) == 'membership_type') {
1904       list($orgInfo, $types) = CRM_Member_BAO_MembershipType::getMembershipTypeInfo();
1905       $sel = &$form->addElement('hierselect', $name, $title);
1906       $select = array('' => ts('- select -') );
1907       if(count($orgInfo) == 1 && $field['is_required']) {
1908         // we only have one org - so we should default to it. Not sure about defaulting to first type
1909         // as it could be missed - so adding a select
1910         // however, possibly that is more similar to the membership form
1911         if(count($types[1]) > 1) {
1912           $types[1] = $select + $types[1];
1913         }
1914       }
1915       else {
1916         $orgInfo = $select + $orgInfo;
1917       }
1918       $sel->setOptions(array($orgInfo, $types));
1919     }
1920     elseif (CRM_Utils_Array::value('name',$field) == 'membership_status') {
1921       $form->add('select', $name, $title,
1922         array(
1923           '' => ts('- select -')) + CRM_Member_PseudoConstant::membershipStatus(NULL, NULL, 'label'), $required
1924       );
1925     }
1926     elseif ($fieldName === 'gender_id') {
1927       $genderOptions = array();
1928       $gender = CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'gender_id');
1929       foreach ($gender as $key => $var) {
1930         $genderOptions[$key] = $form->createElement('radio', NULL, ts('Gender'), $var, $key);
1931       }
1932       $group = $form->addGroup($genderOptions, $name, $title);
1933       if ($required) {
1934         $form->addRule($name, ts('%1 is a required field.', array(1 => $title)), 'required');
1935       }
1936       else {
1937         $group->setAttribute('allowClear', TRUE);
1938       }
1939     }
1940     elseif ($fieldName === 'prefix_id' || $fieldName === 'suffix_id') {
1941       $form->addSelect($name, array(
1942         'label' => $title,
1943         'entity' => 'contact',
1944         'field' => $fieldName,
1945         'class' => 'six',
1946         'placeholder' => '',
1947       ), $required);
1948     }
1949     elseif ($fieldName === 'contact_sub_type') {
1950       $gId = $form->get('gid') ? $form->get('gid') : CRM_Utils_Array::value('group_id', $field);
1951       if ($usedFor == 'onbehalf') {
1952         $profileType = 'Organization';
1953       }
1954       elseif ($usedFor == 'honor') {
1955         $profileType = CRM_Core_BAO_UFField::getProfileType($form->_params['honoree_profile_id']);
1956       }
1957       else {
1958         $profileType = $gId ? CRM_Core_BAO_UFField::getProfileType($gId) : NULL;
1959         if ($profileType == 'Contact') {
1960           $profileType = 'Individual';
1961         }
1962       }
1963
1964       $setSubtype = FALSE;
1965       if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
1966         $setSubtype = $profileType;
1967         $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
1968       }
1969
1970       $subtypes = $profileType ? CRM_Contact_BAO_ContactType::subTypePairs($profileType) : array();
1971
1972       if ($setSubtype) {
1973         $subtypeList = array();
1974         $subtypeList[$setSubtype] = $subtypes[$setSubtype];
1975       }
1976       else {
1977         $subtypeList = $subtypes;
1978       }
1979
1980       $sel = $form->add('select', $name, $title, $subtypeList, $required);
1981       $sel->setMultiple(TRUE);
1982     }
1983     elseif (in_array($fieldName, CRM_Contact_BAO_Contact::$_greetingTypes)) {
1984       //add email greeting, postal greeting, addressee, CRM-4575
1985       $gId = $form->get('gid') ? $form->get('gid') : CRM_Utils_Array::value('group_id', $field);
1986       $profileType = CRM_Core_BAO_UFField::getProfileType($gId, TRUE, FALSE, TRUE);
1987
1988       if (empty($profileType) || in_array($profileType, array(
1989         'Contact', 'Contribution', 'Participant', 'Membership'))) {
1990         $profileType = 'Individual';
1991       }
1992       if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
1993         $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
1994       }
1995       $greeting = array(
1996         'contact_type' => $profileType,
1997         'greeting_type' => $fieldName,
1998       );
1999       $form->add('select', $name, $title,
2000         array(
2001           '' => ts('- select -')) + CRM_Core_PseudoConstant::greeting($greeting), $required
2002       );
2003       // add custom greeting element
2004       $form->add('text', $fieldName . '_custom', ts('Custom %1', array(1 => ucwords(str_replace('_', ' ', $fieldName)))),
2005         NULL, FALSE
2006       );
2007     }
2008     elseif ($fieldName === 'preferred_communication_method') {
2009       $communicationFields = CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'preferred_communication_method');
2010       foreach ($communicationFields as $key => $var) {
2011         if ($key == '') {
2012           continue;
2013         }
2014         $communicationOptions[] = $form->createElement('checkbox', $key, NULL, $var);
2015       }
2016       $form->addGroup($communicationOptions, $name, $title, '<br/>');
2017     }
2018     elseif ($fieldName === 'preferred_mail_format') {
2019       $form->add('select', $name, $title, CRM_Core_SelectValues::pmf());
2020     }
2021     elseif ($fieldName === 'preferred_language') {
2022       $form->add('select', $name, $title, array('' => ts('- select -')) + CRM_Contact_BAO_Contact::buildOptions('preferred_language'));
2023     }
2024     elseif ($fieldName == 'external_identifier') {
2025       $form->add('text', $name, $title, $attributes, $required);
2026       $contID = $contactId;
2027       if (!$contID) {
2028         $contID = $form->get('id');
2029       }
2030       $form->addRule($name,
2031         ts('External ID already exists in Database.'),
2032         'objectExists',
2033         array('CRM_Contact_DAO_Contact', $contID, 'external_identifier')
2034       );
2035     }
2036     elseif ($fieldName === 'group') {
2037       CRM_Contact_Form_Edit_TagsAndGroups::buildQuickForm($form, $contactId,
2038         CRM_Contact_Form_Edit_TagsAndGroups::GROUP,
2039         TRUE, $required,
2040         $title, NULL, $name
2041       );
2042     }
2043     elseif ($fieldName === 'tag') {
2044       CRM_Contact_Form_Edit_TagsAndGroups::buildQuickForm($form, $contactId,
2045         CRM_Contact_Form_Edit_TagsAndGroups::TAG,
2046         FALSE, $required,
2047         NULL, $title, $name
2048       );
2049     }
2050     elseif (substr($fieldName, 0, 4) === 'url-') {
2051       $form->add('text', $name, $title,
2052         array_merge(CRM_Core_DAO::getAttribute('CRM_Core_DAO_Website', 'url'),
2053           array(
2054             'onfocus' => "if (!this.value) {  this.value='http://';} else return false",
2055             'onblur' => "if ( this.value == 'http://') {  this.value='';} else return false",
2056           )
2057        ), $required
2058       );
2059
2060       $form->addRule($name, ts('Enter a valid Website.'), 'url');
2061     }
2062     // Note should be rendered as textarea
2063     elseif (substr($fieldName, -4) == 'note') {
2064       $form->add('textarea', $name, $title, $attributes, $required);
2065     }
2066     elseif (substr($fieldName, 0, 6) === 'custom') {
2067       $customFieldID = CRM_Core_BAO_CustomField::getKeyID($fieldName);
2068       if ($customFieldID) {
2069         CRM_Core_BAO_CustomField::addQuickFormElement($form, $name, $customFieldID, FALSE, $required, $search, $title);
2070       }
2071     }
2072     elseif (substr($fieldName, 0, 14) === 'address_custom') {
2073       list($fName, $locTypeId) = CRM_Utils_System::explode('-', $fieldName, 2);
2074       $customFieldID = CRM_Core_BAO_CustomField::getKeyID(substr($fName, 8));
2075       if ($customFieldID) {
2076         CRM_Core_BAO_CustomField::addQuickFormElement($form, $name, $customFieldID, FALSE, $required, $search, $title);
2077       }
2078     }
2079     elseif (in_array($fieldName, array(
2080       'receive_date', 'receipt_date', 'thankyou_date', 'cancel_date'))) {
2081       $form->addDateTime($name, $title, $required, array('formatType' => 'activityDateTime'));
2082     }
2083     elseif ($fieldName == 'send_receipt') {
2084       $form->addElement('checkbox', $name, $title);
2085     }
2086     elseif ($fieldName == 'soft_credit') {
2087       $form->addEntityRef("soft_credit_contact_id[$rowNumber]", ts('Soft Credit To'), array('create' => TRUE));
2088       $form->addMoney("soft_credit_amount[{$rowNumber}]", ts('Amount'), FALSE, NULL, FALSE);
2089     }
2090     elseif ($fieldName == 'product_name') {
2091       list($products, $options) = CRM_Contribute_BAO_Premium::getPremiumProductInfo();
2092       $sel = &$form->addElement('hierselect', $name, $title);
2093       $products = array(
2094         '0' => ts('- select -')) + $products;
2095       $sel->setOptions(array($products, $options));
2096     }
2097     elseif ($fieldName == 'payment_instrument') {
2098       $form->add('select', $name, $title,
2099                        array(''=>ts( '- select -' )) + CRM_Contribute_PseudoConstant::paymentInstrument( ), $required );
2100     }
2101     else if ($fieldName == 'financial_type' ) {
2102       $form->add('select', $name, $title,
2103         array(
2104           '' => ts('- select -')) + CRM_Contribute_PseudoConstant::financialType(), $required
2105       );
2106     }
2107     elseif ($fieldName == 'contribution_status_id') {
2108       $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus();
2109       $statusName = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
2110       foreach (array(
2111                  'In Progress',
2112                  'Overdue',
2113                  'Refunded'
2114                ) as $suppress) {
2115         unset($contributionStatuses[CRM_Utils_Array::key($suppress, $statusName)]);
2116       }
2117
2118       $form->add('select', $name, $title,
2119         array(
2120           '' => ts('- select -')) + $contributionStatuses, $required
2121       );
2122     }
2123     elseif ($fieldName == 'soft_credit_type') {
2124       $form->add('select', $name, $title,
2125         array(
2126           '' => ts('- select -')) + CRM_Core_OptionGroup::values("soft_credit_type")
2127       );
2128       $form->addElement('hidden', 'sct_default_id',
2129         CRM_Core_OptionGroup::getDefaultValue("soft_credit_type"),
2130         array('id' => 'sct_default_id')
2131       );
2132     }
2133     elseif ($fieldName == 'currency') {
2134       $form->addCurrency($name, $title, $required);
2135     }
2136     elseif ($fieldName == 'contribution_page_id') {
2137       $form->add('select', $name, $title,
2138         array(
2139           '' => ts('- select -')) + CRM_Contribute_PseudoConstant::contributionPage(), $required, 'class="big"'
2140       );
2141     }
2142     elseif ($fieldName == 'participant_register_date') {
2143       $form->addDateTime($name, $title, $required, array('formatType' => 'activityDateTime'));
2144     }
2145     elseif ($fieldName == 'activity_status_id') {
2146       $form->add('select', $name, $title,
2147         array(
2148           '' => ts('- select -')) + CRM_Core_PseudoConstant::activityStatus(), $required
2149       );
2150     }
2151     elseif ($fieldName == 'activity_engagement_level') {
2152       $form->add('select', $name, $title,
2153         array(
2154           '' => ts('- select -')) + CRM_Campaign_PseudoConstant::engagementLevel(), $required
2155       );
2156     }
2157     elseif ($fieldName == 'activity_date_time') {
2158       $form->addDateTime($name, $title, $required, array('formatType' => 'activityDateTime'));
2159     }
2160     elseif ($fieldName == 'participant_status') {
2161       $cond = NULL;
2162       if ($online == TRUE) {
2163         $cond = 'visibility_id = 1';
2164       }
2165       $form->add('select', $name, $title,
2166         array(
2167           '' => ts('- select -')) + CRM_Event_PseudoConstant::participantStatus(NULL, $cond, 'label'), $required
2168       );
2169     }
2170     elseif ($fieldName == 'participant_role') {
2171       if (!empty($field['is_multiple'])) {
2172         $form->addCheckBox($name, $title, CRM_Event_PseudoConstant::participantRole(), NULL, NULL, NULL, NULL, '&nbsp', TRUE);
2173       }
2174       else {
2175         $form->add('select', $name, $title,
2176           array(
2177             '' => ts('- select -')) + CRM_Event_PseudoConstant::participantRole(), $required
2178         );
2179       }
2180     }
2181     elseif ($fieldName == 'world_region') {
2182       $form->add('select', $name, $title, CRM_Core_PseudoConstant::worldRegion(), $required, $selectAttributes);
2183     }
2184     elseif ($fieldName == 'signature_html') {
2185       $form->addWysiwyg($name, $title, CRM_Core_DAO::getAttribute('CRM_Core_DAO_Email', $fieldName));
2186     }
2187     elseif ($fieldName == 'signature_text') {
2188       $form->add('textarea', $name, $title, CRM_Core_DAO::getAttribute('CRM_Core_DAO_Email', $fieldName));
2189     }
2190     elseif (substr($fieldName, -11) == 'campaign_id') {
2191       if (CRM_Campaign_BAO_Campaign::isCampaignEnable()) {
2192         $campaigns = CRM_Campaign_BAO_Campaign::getCampaigns(CRM_Utils_Array::value($contactId,
2193           $form->_componentCampaigns
2194         ));
2195         $form->add('select', $name, $title,
2196           array(
2197             '' => ts('- select -')) + $campaigns, $required, 'class="crm-select2 big"'
2198         );
2199       }
2200     }
2201     elseif ($fieldName == 'activity_details') {
2202       $form->addWysiwyg($fieldName, $title, array('rows' => 4, 'cols' => 60), $required);
2203     }
2204     elseif ($fieldName == 'activity_duration') {
2205       $form->add('text', $name, $title, $attributes, $required);
2206       $form->addRule($name, ts('Please enter the duration as number of minutes (integers only).'), 'positiveInteger');
2207     }
2208     else {
2209       if (substr($fieldName, 0, 3) === 'is_' or substr($fieldName, 0, 7) === 'do_not_') {
2210         $form->add('advcheckbox', $name, $title, $attributes, $required);
2211       }
2212       else {
2213         $form->add('text', $name, $title, $attributes, $required);
2214       }
2215     }
2216
2217     static $hiddenSubtype = FALSE;
2218     if (!$hiddenSubtype && CRM_Contact_BAO_ContactType::isaSubType($field['field_type'])) {
2219       // In registration mode params are submitted via POST and we don't have any clue
2220       // about profile-id or the profile-type (which could be a subtype)
2221       // To generalize the  behavior and simplify the process,
2222       // lets always add the hidden
2223       //subtype value if there is any, and we won't have to
2224       // compute it while processing.
2225       if ($usedFor) {
2226         $form->addElement('hidden', $usedFor . '[contact_sub_type]', $field['field_type']);
2227       }
2228       else {
2229         $form->addElement('hidden', 'contact_sub_type_hidden', $field['field_type']);
2230       }
2231       $hiddenSubtype = TRUE;
2232     }
2233
2234     if (($view && $mode != CRM_Profile_Form::MODE_SEARCH) || $isShared) {
2235       $form->freeze($name);
2236     }
2237
2238     //add the rules
2239     if (in_array($fieldName, array(
2240       'non_deductible_amount', 'total_amount', 'fee_amount', 'net_amount'))) {
2241       $form->addRule($name, ts('Please enter a valid amount.'), 'money');
2242     }
2243     if ($rule) {
2244       if (!($rule == 'email' && $mode == CRM_Profile_Form::MODE_SEARCH)) {
2245         $form->addRule($name, ts('Please enter a valid %1', array(1 => $title)), $rule);
2246       }
2247     }
2248   }
2249
2250   /**
2251    * Function to set profile defaults
2252    *
2253    * @params int     $contactId      contact id
2254    * @params array   $fields         associative array of fields
2255    * @params array   $defaults       defaults array
2256    * @params boolean $singleProfile  true for single profile else false(batch update)
2257    * @params int     $componentId    id for specific components like contribute, event etc
2258    *
2259    * @param $contactId
2260    * @param $fields
2261    * @param $defaults
2262    * @param bool $singleProfile
2263    * @param null $componentId
2264    * @param null $component
2265    *
2266    * @return null
2267    * @static
2268    * @access public
2269    */
2270   static function setProfileDefaults($contactId, &$fields, &$defaults,
2271     $singleProfile = TRUE, $componentId = NULL, $component = NULL
2272   ) {
2273     if (!$componentId) {
2274       //get the contact details
2275       list($contactDetails, $options) = CRM_Contact_BAO_Contact::getHierContactDetails($contactId, $fields);
2276       $details = CRM_Utils_Array::value($contactId, $contactDetails);
2277       $multipleFields = array('website' => 'url');
2278
2279       //start of code to set the default values
2280       foreach ($fields as $name => $field) {
2281         // skip pseudo fields
2282         if (substr($name, 0, 9) == 'phone_ext') {
2283           continue;
2284         }
2285
2286         //set the field name depending upon the profile mode(single/batch)
2287         if ($singleProfile) {
2288           $fldName = $name;
2289         }
2290         else {
2291           $fldName = "field[$contactId][$name]";
2292         }
2293
2294         if ($name == 'group') {
2295           CRM_Contact_Form_Edit_TagsAndGroups::setDefaults($contactId, $defaults, CRM_Contact_Form_Edit_TagsAndGroups::GROUP, $fldName);
2296         }
2297         if ($name == 'tag') {
2298           CRM_Contact_Form_Edit_TagsAndGroups::setDefaults($contactId, $defaults, CRM_Contact_Form_Edit_TagsAndGroups::TAG, $fldName);
2299         }
2300
2301         if (!empty($details[$name]) || isset($details[$name])) {
2302           //to handle custom data (checkbox) to be written
2303           // to handle birth/deceased date, greeting_type and few other fields
2304           if (($name == 'birth_date') || ($name == 'deceased_date')) {
2305             list($defaults[$fldName]) = CRM_Utils_Date::setDateDefaults($details[$name], 'birth');
2306           }
2307           elseif (in_array($name, CRM_Contact_BAO_Contact::$_greetingTypes)) {
2308             $defaults[$fldName] = $details[$name . '_id'];
2309             $defaults[$name . '_custom'] = $details[$name . '_custom'];
2310           }
2311           elseif ($name == 'preferred_communication_method') {
2312             $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2313             foreach ($v as $item) {
2314               if ($item) {
2315                 $defaults[$fldName . "[$item]"] = 1;
2316               }
2317             }
2318           }
2319           elseif ($name == 'contact_sub_type') {
2320             $defaults[$fldName] = explode(CRM_Core_DAO::VALUE_SEPARATOR, trim($details[$name], CRM_Core_DAO::VALUE_SEPARATOR));
2321           }
2322           elseif ($name == 'world_region') {
2323             $defaults[$fldName] = $details['worldregion_id'];
2324           }
2325           elseif ($customFieldId = CRM_Core_BAO_CustomField::getKeyID($name)) {
2326             //fix for custom fields
2327             $customFields = CRM_Core_BAO_CustomField::getFields(CRM_Utils_Array::value('contact_type', $details));
2328
2329             // hack to add custom data for components
2330             $components = array('Contribution', 'Participant', 'Membership', 'Activity');
2331             foreach ($components as $value) {
2332               $customFields = CRM_Utils_Array::crmArrayMerge($customFields,
2333                 CRM_Core_BAO_CustomField::getFieldsForImport($value)
2334               );
2335             }
2336
2337             switch ($customFields[$customFieldId]['html_type']) {
2338               case 'Multi-Select State/Province':
2339               case 'Multi-Select Country':
2340               case 'AdvMulti-Select':
2341               case 'Multi-Select':
2342                 $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2343                 foreach ($v as $item) {
2344                   if ($item) {
2345                     $defaults[$fldName][$item] = $item;
2346                   }
2347                 }
2348                 break;
2349
2350               case 'CheckBox':
2351                 $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2352                 foreach ($v as $item) {
2353                   if ($item) {
2354                     $defaults[$fldName][$item] = 1;
2355                     // seems like we need this for QF style checkboxes in profile where its multiindexed
2356                     // CRM-2969
2357                     $defaults["{$fldName}[{$item}]"] = 1;
2358                   }
2359                 }
2360                 break;
2361
2362               case 'Select Date':
2363                 // CRM-6681, set defult values according to date and time format (if any).
2364                 $dateFormat = NULL;
2365                 if (!empty($customFields[$customFieldId]['date_format'])) {
2366                   $dateFormat = $customFields[$customFieldId]['date_format'];
2367                 }
2368
2369                 if (empty($customFields[$customFieldId]['time_format'])) {
2370                   list($defaults[$fldName]) = CRM_Utils_Date::setDateDefaults($details[$name], NULL,
2371                     $dateFormat
2372                   );
2373                 }
2374                 else {
2375                   $timeElement = $fldName . '_time';
2376                   if (substr($fldName, -1) == ']') {
2377                     $timeElement = substr($fldName, 0, -1) . '_time]';
2378                   }
2379                   list($defaults[$fldName], $defaults[$timeElement]) = CRM_Utils_Date::setDateDefaults($details[$name],
2380                     NULL, $dateFormat, $customFields[$customFieldId]['time_format']);
2381                 }
2382                 break;
2383
2384               default:
2385                 $defaults[$fldName] = $details[$name];
2386                 break;
2387             }
2388           }
2389           else {
2390             $defaults[$fldName] = $details[$name];
2391           }
2392         }
2393         else {
2394           $blocks = array('email', 'phone', 'im', 'openid');
2395           list($fieldName, $locTypeId, $phoneTypeId) = CRM_Utils_System::explode('-', $name, 3);
2396           if (!in_array($fieldName, $multipleFields)) {
2397             if (is_array($details)) {
2398               foreach ($details as $key => $value) {
2399                 // when we fixed CRM-5319 - get primary loc
2400                 // type as per loc field and removed below code.
2401                 $primaryLocationType = FALSE;
2402                 if ($locTypeId == 'Primary') {
2403                   if (is_array($value) && array_key_exists($fieldName, $value)){
2404                     $primaryLocationType = TRUE;
2405                     if (in_array($fieldName, $blocks)){
2406                       $locTypeId = CRM_Contact_BAO_Contact::getPrimaryLocationType($contactId, FALSE, $fieldName);
2407                     }
2408                     else{
2409                       $locTypeId = CRM_Contact_BAO_Contact::getPrimaryLocationType($contactId, FALSE, 'address');
2410                     }
2411                   }
2412                 }
2413
2414                 // fixed for CRM-665
2415                 if (is_numeric($locTypeId)) {
2416                   if ($primaryLocationType || $locTypeId == CRM_Utils_Array::value('location_type_id', $value)) {
2417                     if (!empty($value[$fieldName])) {
2418                       //to handle stateprovince and country
2419                       if ($fieldName == 'state_province') {
2420                         $defaults[$fldName] = $value['state_province_id'];
2421                       }
2422                       elseif ($fieldName == 'county') {
2423                         $defaults[$fldName] = $value['county_id'];
2424                       }
2425                       elseif ($fieldName == 'country') {
2426                         if (!isset($value['country_id']) || !$value['country_id']) {
2427                           $config = CRM_Core_Config::singleton();
2428                           if ($config->defaultContactCountry) {
2429                             $defaults[$fldName] = $config->defaultContactCountry;
2430                           }
2431                         }
2432                         else {
2433                           $defaults[$fldName] = $value['country_id'];
2434                         }
2435                       }
2436                       elseif ($fieldName == 'phone') {
2437                         if ($phoneTypeId) {
2438                           if (isset($value['phone'][$phoneTypeId])) {
2439                             $defaults[$fldName] = $value['phone'][$phoneTypeId];
2440                           }
2441                           if (isset($value['phone_ext'][$phoneTypeId])) {
2442                             $defaults[str_replace('phone', 'phone_ext', $fldName)] = $value['phone_ext'][$phoneTypeId];
2443                           }
2444                         }
2445                         else {
2446                           $phoneDefault = CRM_Utils_Array::value('phone', $value);
2447                           // CRM-9216
2448                           if (!is_array($phoneDefault)) {
2449                             $defaults[$fldName] = $phoneDefault;
2450                           }
2451                         }
2452                       }
2453                       elseif ($fieldName == 'email') {
2454                         //adding the first email (currently we don't support multiple emails of same location type)
2455                         $defaults[$fldName] = $value['email'];
2456                       }
2457                       elseif ($fieldName == 'im') {
2458                         //adding the first im (currently we don't support multiple ims of same location type)
2459                         $defaults[$fldName] = $value['im'];
2460                         $defaults[$fldName . '-provider_id'] = $value['im_provider_id'];
2461                       }
2462                       else {
2463                         $defaults[$fldName] = $value[$fieldName];
2464                       }
2465                     }
2466                     elseif (substr($fieldName, 0, 14) === 'address_custom' &&
2467                       CRM_Utils_Array::value(substr($fieldName, 8), $value)
2468                     ) {
2469                       $defaults[$fldName] = $value[substr($fieldName, 8)];
2470                     }
2471                   }
2472                 }
2473               }
2474             }
2475           }
2476           else {
2477             if (is_array($details)) {
2478               if ($fieldName === 'url'
2479                 && !empty($details['website'])
2480                 && !empty($details['website'][$locTypeId])) {
2481                 $defaults[$fldName] = CRM_Utils_Array::value('url', $details['website'][$locTypeId]);
2482               }
2483             }
2484           }
2485         }
2486       }
2487     }
2488
2489     //Handling Contribution Part of the batch profile
2490     if (CRM_Core_Permission::access('CiviContribute') && $component == 'Contribute') {
2491       self::setComponentDefaults($fields, $componentId, $component, $defaults);
2492     }
2493
2494     //Handling Event Participation Part of the batch profile
2495     if (CRM_Core_Permission::access('CiviEvent') && $component == 'Event') {
2496       self::setComponentDefaults($fields, $componentId, $component, $defaults);
2497     }
2498
2499     //Handling membership Part of the batch profile
2500     if (CRM_Core_Permission::access('CiviMember') && $component == 'Membership') {
2501       self::setComponentDefaults($fields, $componentId, $component, $defaults);
2502     }
2503
2504     //Handling Activity Part of the batch profile
2505     if ($component == 'Activity') {
2506       self::setComponentDefaults($fields, $componentId, $component, $defaults);
2507     }
2508   }
2509
2510   /**
2511    * Function to get profiles by type  eg: pure Individual etc
2512    *
2513    * @param array   $types      associative array of types eg: types('Individual')
2514    * @param boolean $onlyPure   true if only pure profiles are required
2515    *
2516    * @return array  $profiles  associative array of profiles
2517    * @static
2518    * @access public
2519    */
2520   static function getProfiles($types, $onlyPure = FALSE) {
2521     $profiles = array();
2522     $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
2523
2524     CRM_Utils_Hook::aclGroup(CRM_Core_Permission::ADMIN, NULL, 'civicrm_uf_group', $ufGroups, $ufGroups);
2525
2526     // Exclude Batch Data Entry profiles - CRM-10901
2527     $batchProfiles = CRM_Core_BAO_UFGroup::getBatchProfiles();
2528
2529     foreach ($ufGroups as $id => $title) {
2530       $ptype = CRM_Core_BAO_UFField::getProfileType($id, FALSE, $onlyPure);
2531       if (in_array($ptype, $types) && !array_key_exists($id, $batchProfiles)) {
2532         $profiles[$id] = $title;
2533       }
2534     }
2535     return $profiles;
2536   }
2537
2538   /**
2539    * Function to check whether a profile is valid combination of
2540    * required and/or optional profile types
2541    *
2542    * @param array   $required   array of types those are required
2543    * @param array   $optional   array of types those are optional
2544    *
2545    * @return array  $profiles  associative array of profiles
2546    * @static
2547    * @access public
2548    */
2549   static function getValidProfiles($required, $optional = NULL) {
2550     if (!is_array($required) || empty($required)) {
2551       return;
2552     }
2553
2554     $profiles = array();
2555     $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
2556
2557     CRM_Utils_Hook::aclGroup(CRM_Core_Permission::ADMIN, NULL, 'civicrm_uf_group', $ufGroups, $ufGroups);
2558
2559     foreach ($ufGroups as $id => $title) {
2560       $type = CRM_Core_BAO_UFField::checkValidProfileType($id, $required, $optional);
2561       if ($type) {
2562         $profiles[$id] = $title;
2563       }
2564     }
2565
2566     return $profiles;
2567   }
2568
2569   /**
2570    * Function to check whether a profile is valid combination of
2571    * required profile fields
2572    *
2573    * @param array   $ufId       integer id of the profile
2574    * @param array   $required   array of fields those are required in the profile
2575    *
2576    * @return array  $profiles  associative array of profiles
2577    * @static
2578    * @access public
2579    */
2580   static function checkValidProfile($ufId, $required = NULL) {
2581     $validProfile = FALSE;
2582     if (!$ufId) {
2583       return $validProfile;
2584     }
2585
2586     if (!CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $ufId, 'is_active')) {
2587       return $validProfile;
2588     }
2589
2590     $profileFields = self::getFields($ufId, FALSE, CRM_Core_Action::VIEW, NULL,
2591       NULL, FALSE, NULL, FALSE, NULL,
2592       CRM_Core_Permission::CREATE, NULL
2593     );
2594
2595     $validProfile = array();
2596     if (!empty($profileFields)) {
2597       $fields = array_keys($profileFields);
2598       foreach ($fields as $val) {
2599         foreach ($required as $key => $field) {
2600           if (strpos($val, $field) === 0) {
2601             unset($required[$key]);
2602           }
2603         }
2604       }
2605
2606       $validProfile = (empty($required)) ? TRUE : FALSE;
2607     }
2608
2609     return $validProfile;
2610   }
2611
2612   /**
2613    * Function to get default value for Register.
2614    *
2615    * @param $fields
2616    * @param $defaults
2617    *
2618    * @return mixed $defaults@static
2619    * @access public
2620    */
2621   static function setRegisterDefaults(&$fields, &$defaults) {
2622     $config = CRM_Core_Config::singleton();
2623     foreach ($fields as $name => $field) {
2624       if (substr($name, 0, 8) == 'country-') {
2625         if (!empty($config->defaultContactCountry)) {
2626           $defaults[$name] = $config->defaultContactCountry;
2627         }
2628       }
2629       elseif (substr($name, 0, 15) == 'state_province-') {
2630         if (!empty($config->defaultContactStateProvince)) {
2631           $defaults[$name] = $config->defaultContactStateProvince;
2632         }
2633       }
2634     }
2635     return $defaults;
2636   }
2637
2638   /**
2639    * This function is to make a copy of a profile, including
2640    * all the fields in the profile
2641    *
2642    * @param int $id the profile id to copy
2643    *
2644    * @return void
2645    * @access public
2646    */
2647   static function copy($id) {
2648     $fieldsFix = array('prefix' => array('title' => ts('Copy of ')));
2649     $copy = &CRM_Core_DAO::copyGeneric('CRM_Core_DAO_UFGroup',
2650       array('id' => $id),
2651       NULL,
2652       $fieldsFix
2653     );
2654
2655     if ($pos = strrpos($copy->name, "_{$id}")) {
2656       $copy->name = substr_replace($copy->name, '', $pos);
2657     }
2658     $copy->name = CRM_Utils_String::munge($copy->name, '_', 56) . "_{$copy->id}";
2659     $copy->save();
2660
2661     $copyUFJoin = &CRM_Core_DAO::copyGeneric('CRM_Core_DAO_UFJoin',
2662       array('uf_group_id' => $id),
2663       array('uf_group_id' => $copy->id),
2664       NULL,
2665       'entity_table'
2666     );
2667
2668     $copyUFField = &CRM_Core_DAO::copyGeneric('CRM_Core_BAO_UFField',
2669       array('uf_group_id' => $id),
2670       array('uf_group_id' => $copy->id)
2671     );
2672
2673     $maxWeight = CRM_Utils_Weight::getMax('CRM_Core_DAO_UFJoin', NULL, 'weight');
2674
2675     //update the weight
2676     $query = "
2677 UPDATE civicrm_uf_join
2678 SET    weight = %1
2679 WHERE  uf_group_id = %2
2680 AND    ( entity_id IS NULL OR entity_id <= 0 )
2681 ";
2682     $p = array(1 => array($maxWeight + 1, 'Integer'),
2683       2 => array($copy->id, 'Integer'),
2684     );
2685     CRM_Core_DAO::executeQuery($query, $p);
2686     if ($copy->is_reserved) {
2687       $query = "UPDATE civicrm_uf_group SET is_reserved = 0 WHERE id = %1";
2688       $params = array(1 => array($copy->id, 'Integer'));
2689       CRM_Core_DAO::executeQuery($query, $params);
2690     }
2691     CRM_Utils_Hook::copy('UFGroup', $copy);
2692
2693     return $copy;
2694   }
2695
2696   /**
2697    * Process that send notification e-mails
2698    *
2699    * @params int     $contactId      contact id
2700    * @params array   $values         associative array of name/value pair
2701    *
2702    * @param $contactID
2703    * @param $values
2704    *
2705    * @return void
2706    * @access public
2707    */
2708
2709   static function commonSendMail($contactID, &$values) {
2710     if (!$contactID || !$values) {
2711       return;
2712
2713     }
2714     $template = CRM_Core_Smarty::singleton();
2715
2716     $displayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact',
2717       $contactID,
2718       'display_name'
2719     );
2720
2721     self::profileDisplay($values['id'], $values['values'], $template);
2722     $emailList = explode(',', $values['email']);
2723
2724     $contactLink = CRM_Utils_System::url('civicrm/contact/view',
2725       "reset=1&cid=$contactID",
2726        TRUE, NULL, FALSE, FALSE, TRUE
2727     );
2728
2729     //get the default domain email address.
2730     list($domainEmailName, $domainEmailAddress) = CRM_Core_BAO_Domain::getNameAndEmail();
2731
2732     if (!$domainEmailAddress || $domainEmailAddress == 'info@EXAMPLE.ORG') {
2733       $fixUrl = CRM_Utils_System::url('civicrm/admin/domain', 'action=update&reset=1');
2734       CRM_Core_Error::fatal(ts('The site administrator needs to enter a valid \'FROM Email Address\' in <a href="%1">Administer CiviCRM &raquo; Communications &raquo; FROM Email Addresses</a>. The email address used may need to be a valid mail account with your email service provider.', array(1 => $fixUrl)));
2735     }
2736
2737     foreach ($emailList as $emailTo) {
2738       // FIXME: take the below out of the foreach loop
2739       CRM_Core_BAO_MessageTemplate::sendTemplate(
2740         array(
2741           'groupName' => 'msg_tpl_workflow_uf',
2742           'valueName' => 'uf_notify',
2743           'contactId' => $contactID,
2744           'tplParams' => array(
2745             'displayName' => $displayName,
2746             'currentDate' => date('r'),
2747             'contactLink' => $contactLink,
2748           ),
2749           'from' => "$domainEmailName <$domainEmailAddress>",
2750           'toEmail' => $emailTo,
2751         )
2752       );
2753     }
2754   }
2755
2756   /**
2757    * Given a contact id and a group id, returns the field values from the db
2758    * for this group and notify email only if group's notify field is
2759    * set and field values are not empty
2760    *
2761    * @params $gid      group id
2762    * @params $cid      contact id
2763    * @params $params   associative array
2764    *
2765    * @param $gid
2766    * @param $cid
2767    * @param $params
2768    * @param bool $skipCheck
2769    *
2770    * @return array
2771    * @access public
2772    */
2773   function checkFieldsEmptyValues($gid, $cid, $params, $skipCheck = FALSE) {
2774     if ($gid) {
2775       if (CRM_Core_BAO_UFGroup::filterUFGroups($gid, $cid) || $skipCheck) {
2776         $values = array();
2777         $fields = CRM_Core_BAO_UFGroup::getFields($gid, FALSE, CRM_Core_Action::VIEW);
2778         CRM_Core_BAO_UFGroup::getValues($cid, $fields, $values, FALSE, $params, TRUE);
2779
2780         $email = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $gid, 'notify');
2781
2782         if (!empty($values) &&
2783           !empty($email)
2784         ) {
2785           $val = array(
2786             'id' => $gid,
2787             'values' => $values,
2788             'email' => $email,
2789           );
2790           return $val;
2791         }
2792       }
2793     }
2794     return NULL;
2795   }
2796
2797   /**
2798    * Function to assign uf fields to template
2799    *
2800    * @params int     $gid      group id
2801    * @params array   $values   associative array of fields
2802    *
2803    * @param $gid
2804    * @param $values
2805    * @param $template
2806    *
2807    * @return void
2808    * @access public
2809    */
2810   function profileDisplay($gid, $values, $template) {
2811     $groupTitle = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $gid, 'title');
2812     $template->assign('grouptitle', $groupTitle);
2813     if (count($values)) {
2814       $template->assign('values', $values);
2815     }
2816   }
2817
2818   /**
2819    * Format fields for dupe Contact Matching
2820    *
2821    * @param array $params associated array
2822    *
2823    * @param null $contactId
2824    *
2825    * @return array $data assoicated formatted array
2826    * @access public
2827    * @static
2828    */
2829   static function formatFields($params, $contactId = NULL) {
2830     if ($contactId) {
2831       // get the primary location type id and email
2832       list($name, $primaryEmail, $primaryLocationType) = CRM_Contact_BAO_Contact_Location::getEmailDetails($contactId);
2833     }
2834     else {
2835       $defaultLocationType = CRM_Core_BAO_LocationType::getDefault();
2836       $primaryLocationType = $defaultLocationType->id;
2837     }
2838
2839     $data            = array();
2840     $locationType    = array();
2841     $count           = 1;
2842     $primaryLocation = 0;
2843     foreach ($params as $key => $value) {
2844       list($fieldName, $locTypeId, $phoneTypeId) = explode('-', $key);
2845
2846       if ($locTypeId == 'Primary') {
2847         $locTypeId = $primaryLocationType;
2848       }
2849
2850       if (is_numeric($locTypeId)) {
2851         if (!in_array($locTypeId, $locationType)) {
2852           $locationType[$count] = $locTypeId;
2853           $count++;
2854         }
2855         $loc = CRM_Utils_Array::key($locTypeId, $locationType);
2856
2857         $data['location'][$loc]['location_type_id'] = $locTypeId;
2858
2859         // if we are getting in a new primary email, dont overwrite the new one
2860         if ($locTypeId == $primaryLocationType) {
2861           if (!empty($params['email-' . $primaryLocationType])) {
2862             $data['location'][$loc]['email'][$loc]['email'] = $fields['email-' . $primaryLocationType];
2863           }
2864           elseif (isset($primaryEmail)) {
2865             $data['location'][$loc]['email'][$loc]['email'] = $primaryEmail;
2866           }
2867           $primaryLocation++;
2868         }
2869
2870         if ($loc == 1) {
2871           $data['location'][$loc]['is_primary'] = 1;
2872         }
2873         if ($fieldName == 'phone') {
2874           if ($phoneTypeId) {
2875             $data['location'][$loc]['phone'][$loc]['phone_type_id'] = $phoneTypeId;
2876           }
2877           else {
2878             $data['location'][$loc]['phone'][$loc]['phone_type_id'] = '';
2879           }
2880           $data['location'][$loc]['phone'][$loc]['phone'] = $value;
2881         }
2882         elseif ($fieldName == 'email') {
2883           $data['location'][$loc]['email'][$loc]['email'] = $value;
2884         }
2885         elseif ($fieldName == 'im') {
2886           $data['location'][$loc]['im'][$loc]['name'] = $value;
2887         }
2888         else {
2889           if ($fieldName === 'state_province') {
2890             $data['location'][$loc]['address']['state_province_id'] = $value;
2891           }
2892           elseif ($fieldName === 'country') {
2893             $data['location'][$loc]['address']['country_id'] = $value;
2894           }
2895           else {
2896             $data['location'][$loc]['address'][$fieldName] = $value;
2897           }
2898         }
2899       }
2900       else {
2901         // TODO: prefix, suffix and gender translation may no longer be necessary - check inputs
2902         if ($key === 'individual_suffix') {
2903           $data['suffix_id'] = $value;
2904         }
2905         elseif ($key === 'individual_prefix') {
2906           $data['prefix_id'] = $value;
2907         }
2908         elseif ($key === 'gender') {
2909           $data['gender_id'] = $value;
2910         }
2911         elseif (substr($key, 0, 6) === 'custom') {
2912           if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
2913             //fix checkbox
2914             if ($customFields[$customFieldID]['html_type'] == 'CheckBox') {
2915               $value = implode(CRM_Core_DAO::VALUE_SEPARATOR, array_keys($value));
2916             }
2917             // fix the date field
2918             if ($customFields[$customFieldID]['data_type'] == 'Date') {
2919               $date = CRM_Utils_Date::format($value);
2920               if (!$date) {
2921                 $date = '';
2922               }
2923               $value = $date;
2924             }
2925
2926             $data['custom'][$customFieldID] = array(
2927               'id' => $id,
2928               'value' => $value,
2929               'extends' => $customFields[$customFieldID]['extends'],
2930               'type' => $customFields[$customFieldID]['data_type'],
2931               'custom_field_id' => $customFieldID,
2932             );
2933           }
2934         }
2935         elseif ($key == 'edit') {
2936           continue;
2937         }
2938         else {
2939           $data[$key] = $value;
2940         }
2941       }
2942     }
2943
2944     if (!$primaryLocation) {
2945       $loc++;
2946       $data['location'][$loc]['email'][$loc]['email'] = $primaryEmail;
2947     }
2948
2949
2950     return $data;
2951   }
2952
2953   /**
2954    * calculate the profile type 'group_type' as per profile fields.
2955    *
2956    * @param $gId
2957    * @param bool $includeTypeValues
2958    * @param int $ignoreFieldId ignore particular profile field
2959    *
2960    * @internal param int $gid profile id
2961    * @return array list of calculated group type
2962    */
2963   static function calculateGroupType($gId, $includeTypeValues = FALSE, $ignoreFieldId = NULL) {
2964     //get the profile fields.
2965     $ufFields = self::getFields($gId, FALSE, NULL, NULL, NULL, TRUE, NULL, TRUE);
2966     return self::_calculateGroupType($ufFields, $includeTypeValues, $ignoreFieldId);
2967   }
2968
2969   /**
2970    * calculate the profile type 'group_type' as per profile fields.
2971    *
2972    * @param $ufFields
2973    * @param bool $includeTypeValues
2974    * @param int $ignoreFieldId ignore perticular profile field
2975    *
2976    * @internal param int $gid profile id
2977    * @return array list of calculated group type
2978    */
2979   static function _calculateGroupType($ufFields, $includeTypeValues = FALSE, $ignoreFieldId = NULL) {
2980     $groupType = $groupTypeValues = $customFieldIds = array();
2981     if (!empty($ufFields)) {
2982       foreach ($ufFields as $fieldName => $fieldValue) {
2983         //ignore field from group type when provided.
2984         //in case of update profile field.
2985         if ($ignoreFieldId && ($ignoreFieldId == $fieldValue['field_id'])) {
2986           continue;
2987         }
2988         if (!in_array($fieldValue['field_type'], $groupType)) {
2989           $groupType[$fieldValue['field_type']] = $fieldValue['field_type'];
2990         }
2991
2992         if ($includeTypeValues && ($fldId = CRM_Core_BAO_CustomField::getKeyID($fieldName))) {
2993           $customFieldIds[$fldId] = $fldId;
2994         }
2995       }
2996     }
2997
2998     if (!empty($customFieldIds)) {
2999       $query = 'SELECT DISTINCT(cg.id), cg.extends, cg.extends_entity_column_id, cg.extends_entity_column_value FROM civicrm_custom_group cg LEFT JOIN civicrm_custom_field cf ON cf.custom_group_id = cg.id WHERE cg.extends_entity_column_value IS NOT NULL AND cf.id IN (' . implode(',', $customFieldIds) . ')';
3000
3001       $customGroups = CRM_Core_DAO::executeQuery($query);
3002       while ($customGroups->fetch()) {
3003         if (!$customGroups->extends_entity_column_value) {
3004           continue;
3005         }
3006
3007         $groupTypeName = "{$customGroups->extends}Type";
3008         if ($customGroups->extends == 'Participant' && $customGroups->extends_entity_column_id) {
3009           $groupTypeName = CRM_Core_OptionGroup::getValue('custom_data_type', $customGroups->extends_entity_column_id, 'value', 'String', 'name');
3010         }
3011
3012         foreach (explode(CRM_Core_DAO::VALUE_SEPARATOR, $customGroups->extends_entity_column_value) as $val) {
3013           if ($val) {
3014             $groupTypeValues[$groupTypeName][$val] = $val;
3015           }
3016         }
3017       }
3018
3019       if (!empty($groupTypeValues)) {
3020         $groupType = array_merge($groupType, $groupTypeValues);
3021       }
3022     }
3023
3024     return $groupType;
3025   }
3026
3027   /**
3028    * Update the profile type 'group_type' as per profile fields including group types and group subtype values.
3029    * Build and store string like: group_type1,group_type2[VALUE_SEPERATOR]group_type1Type:1:2:3,group_type2Type:1:2
3030    *
3031    * FIELDS                                                   GROUP_TYPE
3032    * BirthDate + Email                                        Individual,Contact
3033    * BirthDate + Subject                                      Individual,Activity
3034    * BirthDate + Subject + SurveyOnlyField                    Individual,Activity\0ActivityType:28
3035    * BirthDate + Subject + SurveyOnlyField + PhoneOnlyField   (Not allowed)
3036    * BirthDate + SurveyOnlyField                              Individual,Activity\0ActivityType:28
3037    * BirthDate + Subject + SurveyOrPhoneField                 Individual,Activity\0ActivityType:2:28
3038    * BirthDate + SurveyOrPhoneField                           Individual,Activity\0ActivityType:2:28
3039    * BirthDate + SurveyOrPhoneField + SurveyOnlyField         Individual,Activity\0ActivityType:2:28
3040    * BirthDate + StudentField + Subject + SurveyOnlyField     Individual,Activity,Student\0ActivityType:28
3041    *
3042    * @param $gId
3043    * @param  Array $groupTypes With key having group type names
3044    *
3045    * @internal param int $gid profile id
3046    * @return Boolean
3047    */
3048   static function updateGroupTypes($gId, $groupTypes = array(
3049     )) {
3050     if (!is_array($groupTypes) || !$gId) {
3051       return FALSE;
3052     }
3053
3054     // If empty group types set group_type as 'null'
3055     if (empty($groupTypes)) {
3056       return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $gId, 'group_type', 'null');
3057     }
3058
3059     $componentGroupTypes = array('Contribution', 'Participant', 'Membership', 'Activity', 'Case');
3060     $validGroupTypes = array_merge(array('Contact', 'Individual', 'Organization', 'Household'), $componentGroupTypes, CRM_Contact_BAO_ContactType::subTypes());
3061
3062     $gTypes = $gTypeValues = array();
3063
3064     $participantExtends = array('ParticipantRole', 'ParticipantEventName', 'ParticipantEventType');
3065     // Get valid group type and group subtypes
3066     foreach ($groupTypes as $groupType => $value) {
3067       if (in_array($groupType, $validGroupTypes) && !in_array($groupType, $gTypes)) {
3068         $gTypes[] = $groupType;
3069       }
3070
3071       $subTypesOf = NULL;
3072
3073       if (in_array($groupType, $participantExtends)) {
3074         $subTypesOf = $groupType;
3075       }
3076       elseif (strpos($groupType, 'Type') > 0) {
3077         $subTypesOf = substr($groupType, 0, strpos($groupType, 'Type'));
3078       }
3079       else {
3080         continue;
3081       }
3082
3083       if (!empty($value) &&
3084         (in_array($subTypesOf, $componentGroupTypes) ||
3085           in_array($subTypesOf, $participantExtends)
3086         )
3087       ) {
3088         $gTypeValues[$subTypesOf] = $groupType . ":" . implode(':', $value);
3089       }
3090     }
3091
3092     if (empty($gTypes)) {
3093       return FALSE;
3094     }
3095
3096     // Build String to store group types and group subtypes
3097     $groupTypeString = implode(',', $gTypes);
3098     if (!empty($gTypeValues)) {
3099       $groupTypeString .= CRM_Core_DAO::VALUE_SEPARATOR . implode(',', $gTypeValues);
3100     }
3101
3102     return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $gId, 'group_type', $groupTypeString);
3103   }
3104
3105   /**
3106    * Create a "group_type" string
3107    *
3108    * @param array $coreTypes e.g. array('Individual','Contact','Student')
3109    * @param array $subTypes e.g. array('ActivityType' => array(7, 11))
3110    * @param string $delim
3111    *
3112    * @return string
3113    * @throws CRM_Core_Exception
3114    */
3115   static function encodeGroupType($coreTypes, $subTypes, $delim = CRM_Core_DAO::VALUE_SEPARATOR) {
3116     $groupTypeExpr = '';
3117     if ($coreTypes) {
3118       $groupTypeExpr .= implode(',', $coreTypes);
3119     }
3120     if ($subTypes) {
3121       if (count($subTypes) > 1) {
3122         throw new CRM_Core_Exception("Multiple subtype filtering is not currently supported by widget.");
3123       }
3124       foreach ($subTypes as $subType => $subTypeIds) {
3125         $groupTypeExpr .= $delim . $subType . ':' . implode(':', $subTypeIds);
3126       }
3127     }
3128     return $groupTypeExpr;
3129   }
3130
3131   /**
3132    * This function is used to setDefault componet specific profile fields.
3133    *
3134    * @param array $fields profile fields.
3135    * @param int $componentId componetID
3136    * @param string $component component name
3137    * @param array $defaults an array of default values.
3138    *
3139    * @param bool $isStandalone
3140    *
3141    * @return void.
3142    */
3143   public static function setComponentDefaults(&$fields, $componentId, $component, &$defaults, $isStandalone = FALSE) {
3144     if (!$componentId ||
3145       !in_array($component, array('Contribute', 'Membership', 'Event', 'Activity'))
3146     ) {
3147       return;
3148     }
3149
3150     $componentBAO = $componentSubType = NULL;
3151     switch ($component) {
3152       case 'Membership':
3153         $componentBAO     = 'CRM_Member_BAO_Membership';
3154         $componentBAOName = 'Membership';
3155         $componentSubType = array('membership_type_id');
3156         break;
3157
3158       case 'Contribute':
3159         $componentBAO     = 'CRM_Contribute_BAO_Contribution';
3160         $componentBAOName = 'Contribution';
3161             $componentSubType = array( 'financial_type_id' );
3162         break;
3163
3164       case 'Event':
3165         $componentBAO     = 'CRM_Event_BAO_Participant';
3166         $componentBAOName = 'Participant';
3167         $componentSubType = array('role_id', 'event_id', 'event_type_id');
3168         break;
3169
3170       case 'Activity':
3171         $componentBAO     = 'CRM_Activity_BAO_Activity';
3172         $componentBAOName = 'Activity';
3173         $componentSubType = array('activity_type_id');
3174         break;
3175     }
3176
3177     $values = array();
3178     $params = array('id' => $componentId);
3179
3180     //get the component values.
3181     CRM_Core_DAO::commonRetrieve($componentBAO, $params, $values);
3182     if ($componentBAOName == 'Participant') {
3183       $values += array('event_type_id' => CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Event', $values['event_id'], 'event_type_id'));
3184     }
3185
3186     $formattedGroupTree = array();
3187     $dateTimeFields = array('participant_register_date', 'activity_date_time', 'receive_date', 'receipt_date', 'cancel_date', 'thankyou_date', 'membership_start_date', 'membership_end_date', 'join_date');
3188     foreach ($fields as $name => $field) {
3189       $fldName = $isStandalone ? $name : "field[$componentId][$name]";
3190       if (in_array($name, $dateTimeFields)) {
3191         $timefldName = $isStandalone ? "{$name}_time" : "field[$componentId][{$name}_time]";
3192         if (!empty($values[$name])) {
3193           list($defaults[$fldName], $defaults[$timefldName]) = CRM_Utils_Date::setDateDefaults($values[$name]);
3194         }
3195       }
3196       elseif (array_key_exists($name, $values)) {
3197         $defaults[$fldName] = $values[$name];
3198       }
3199       elseif ($name == 'participant_note') {
3200         $noteDetails        = CRM_Core_BAO_Note::getNote($componentId, 'civicrm_participant');
3201         $defaults[$fldName] = array_pop($noteDetails);
3202       }
3203       elseif (in_array($name, array(
3204         'financial_type', 'payment_instrument', 'participant_status', 'participant_role'))) {
3205         $defaults[$fldName] = $values["{$name}_id"];
3206       }
3207       elseif ($name == 'membership_type') {
3208         // since membership_type field is a hierselect -
3209         $defaults[$fldName][0] =
3210           CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipType',$values['membership_type_id'],'member_of_contact_id','id');
3211         $defaults[$fldName][1] = $values['membership_type_id'];
3212       }
3213       elseif ($name == 'membership_status') {
3214         $defaults[$fldName] = $values['status_id'];
3215       }
3216       elseif ($customFieldInfo = CRM_Core_BAO_CustomField::getKeyID($name, TRUE)) {
3217         if (empty($formattedGroupTree)) {
3218           //get the groupTree as per subTypes.
3219           $groupTree = array();
3220           foreach ($componentSubType as $subType) {
3221             $subTree = CRM_Core_BAO_CustomGroup::getTree($componentBAOName, CRM_Core_DAO::$_nullObject,
3222               $componentId, 0, $values[$subType]
3223             );
3224             $groupTree = CRM_Utils_Array::crmArrayMerge($groupTree, $subTree);
3225           }
3226           $formattedGroupTree = CRM_Core_BAO_CustomGroup::formatGroupTree($groupTree, 1, CRM_Core_DAO::$_nullObject);
3227           CRM_Core_BAO_CustomGroup::setDefaults($formattedGroupTree, $defaults);
3228         }
3229
3230         //FIX ME: We need to loop defaults, but once we move to custom_1_x convention this code can be simplified.
3231         foreach ($defaults as $customKey => $customValue) {
3232           if ($customFieldDetails = CRM_Core_BAO_CustomField::getKeyID($customKey, TRUE)) {
3233             if ($name == 'custom_' . $customFieldDetails[0]) {
3234
3235               //hack to set default for checkbox
3236               //basically this is for weired field name like field[33][custom_19]
3237               //we are converting this field name to array structure and assign value.
3238               $skipValue = FALSE;
3239
3240               foreach ($formattedGroupTree as $tree) {
3241                 if (!empty($tree['fields'][$customFieldDetails[0]])) {
3242                   if ('CheckBox' == CRM_Utils_Array::value('html_type', $tree['fields'][$customFieldDetails[0]])) {
3243                     $skipValue = TRUE;
3244                     $defaults['field'][$componentId][$name] = $customValue;
3245                     break;
3246                   }
3247                   elseif (CRM_Utils_Array::value('data_type', $tree['fields'][$customFieldDetails[0]]) == 'Date') {
3248                     $skipValue = TRUE;
3249
3250                     // CRM-6681, $default contains formatted date, time values.
3251                     $defaults[$fldName] = $customValue;
3252                     if (!empty($defaults[$customKey . '_time'])) {
3253                       $defaults['field'][$componentId][$name . '_time'] = $defaults[$customKey . '_time'];
3254                     }
3255                   }
3256                 }
3257               }
3258
3259               if (!$skipValue || $isStandalone) {
3260                 $defaults[$fldName] = $customValue;
3261               }
3262               unset($defaults[$customKey]);
3263               break;
3264             }
3265           }
3266         }
3267       }
3268     }
3269   }
3270
3271   /**
3272    * @param array|string $profiles - name of profile(s) to create links for
3273    * @param array $appendProfiles - name of profile(s) to append to each link
3274    *
3275    * @return array
3276    */
3277   static function getCreateLinks($profiles = '', $appendProfiles = array()) {
3278     // Default to contact profiles
3279     if (!$profiles) {
3280       $profiles = array('new_individual', 'new_organization', 'new_household');
3281     }
3282     $profiles = (array) $profiles;
3283     $toGet = array_merge($profiles, (array) $appendProfiles);
3284     $retrieved = civicrm_api3('uf_group', 'get', array(
3285       'name' => array('IN' => $toGet),
3286       'is_active' => 1,
3287     ));
3288     $links = $append = array();
3289     if (!empty($retrieved['values'])) {
3290       foreach($retrieved['values'] as $id => $profile) {
3291         if (in_array($profile['name'], $profiles)) {
3292           $links[] = array(
3293             'label' => $profile['title'],
3294             'url' => CRM_Utils_System::url('civicrm/profile/create', "reset=1&context=dialog&gid=$id",
3295               NULL, NULL, FALSE, NULL, FALSE) ,
3296             'type' => ucfirst(str_replace('new_', '', $profile['name'])),
3297           );
3298         }
3299         else {
3300           $append[] = $id;
3301         }
3302       }
3303       foreach ($append as $id) {
3304         foreach ($links as &$link) {
3305           $link['url'] .= ",$id";
3306         }
3307       }
3308     }
3309     return $links;
3310   }
3311
3312   /**
3313    * Function to retrieve groups of  profiles
3314    *
3315    * @param integer $profileID id of the profile
3316    *
3317    * @return array  returns array
3318    * @static
3319    */
3320   static function profileGroups($profileID) {
3321     $groupTypes = array();
3322     $profileTypes = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $profileID, 'group_type');
3323     if ($profileTypes) {
3324       $groupTypeParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, $profileTypes);
3325       $groupTypes = explode(',', $groupTypeParts[0]);
3326     }
3327     return $groupTypes;
3328   }
3329
3330   /**
3331    * Function to alter contact params by filtering existing subscribed groups and returns
3332    * unsubscribed groups array for subscription.
3333    *
3334    * @param  array  $params             contact params
3335    * @param  int    $contactId          user contact id
3336    *
3337    * @return array  $subscribeGroupIds  This contains array of groups for subscription
3338    */
3339   static function getDoubleOptInGroupIds(&$params, $contactId = NULL) {
3340     $config = CRM_Core_Config::singleton();
3341     $subscribeGroupIds = array();
3342
3343     // process further only if profileDoubleOptIn enabled and if groups exist
3344     if (!array_key_exists('group', $params) ||
3345       !self::isProfileDoubleOptin() ||
3346       CRM_Utils_System::isNull($params['group'])
3347     ) {
3348       return $subscribeGroupIds;
3349     }
3350
3351     //check if contact email exist.
3352     $hasEmails = FALSE;
3353     foreach ($params as $name => $value) {
3354       if (strpos($name, 'email-') !== FALSE) {
3355         $hasEmails = TRUE;
3356         break;
3357       }
3358     }
3359
3360     //Proceed furthur only if email present
3361     if (!$hasEmails) {
3362       return $subscribeGroupIds;
3363     }
3364
3365     //do check for already subscriptions.
3366     $contactGroups = array();
3367     if ($contactId) {
3368       $query = "
3369 SELECT  group_id
3370   FROM  civicrm_group_contact
3371   WHERE status = 'Added'
3372     AND contact_id = %1";
3373
3374       $dao = CRM_Core_DAO::executeQuery($query, array(1 => array($contactId, 'Integer')));
3375       while ($dao->fetch()) {
3376         $contactGroups[$dao->group_id] = $dao->group_id;
3377       }
3378     }
3379
3380     //since we don't have names, compare w/ label.
3381     $mailingListGroupType = array_search('Mailing List', CRM_Core_OptionGroup::values('group_type'));
3382
3383     //actual processing start.
3384     foreach ($params['group'] as $groupId => $isSelected) {
3385       //unset group those are not selected.
3386       if (!$isSelected) {
3387         unset($params['group'][$groupId]);
3388         continue;
3389       }
3390
3391       $groupTypes = explode(CRM_Core_DAO::VALUE_SEPARATOR,
3392         CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $groupId, 'group_type', 'id')
3393       );
3394       //get only mailing type group and unset it from params
3395       if (in_array($mailingListGroupType, $groupTypes) && !in_array($groupId, $contactGroups)) {
3396         $subscribeGroupIds[$groupId] = $groupId;
3397         unset($params['group'][$groupId]);
3398       }
3399     }
3400
3401     return $subscribeGroupIds;
3402   }
3403
3404   /**
3405    * Function to check if we are rendering mixed profiles
3406    *
3407    * @param array $profileIds associated array of profile ids
3408    *
3409    * @return boolean $mixProfile true if profile is mixed
3410    * @static
3411    * @access public
3412    */
3413   static function checkForMixProfiles($profileIds) {
3414     $mixProfile = FALSE;
3415
3416     $contactTypes = array('Individual', 'Household', 'Organization');
3417     $subTypes = CRM_Contact_BAO_ContactType::subTypes();
3418
3419     $components = array('Contribution', 'Participant', 'Membership', 'Activity');
3420
3421     $typeCount = array('ctype' => array(), 'subtype' => array());
3422     foreach ($profileIds as $gid) {
3423       $profileType = CRM_Core_BAO_UFField::getProfileType($gid);
3424       // ignore profile of type Contact
3425       if ($profileType == 'Contact') {
3426         continue;
3427       }
3428       if (in_array($profileType, $contactTypes)) {
3429         if (!isset($typeCount['ctype'][$profileType])) {
3430           $typeCount['ctype'][$profileType] = 1;
3431         }
3432
3433         // check if we are rendering profile of different contact types
3434         if (count($typeCount['ctype']) == 2) {
3435           $mixProfile = TRUE;
3436           break;
3437         }
3438       }
3439       elseif (in_array($profileType, $components)) {
3440         $mixProfile = TRUE;
3441         break;
3442       }
3443       else {
3444         if (!isset($typeCount['subtype'][$profileType])) {
3445           $typeCount['subtype'][$profileType] = 1;
3446         }
3447         // check if we are rendering profile of different contact sub types
3448         if (count($typeCount['subtype']) == 2) {
3449           $mixProfile = TRUE;
3450           break;
3451         }
3452       }
3453     }
3454     return $mixProfile;
3455   }
3456
3457   /**
3458    * Function to determine of we show overlay profile or not
3459    *
3460    * @return boolean true if profile should be shown else false
3461    * @static
3462    * @access public
3463    */
3464   static function showOverlayProfile() {
3465     $showOverlay = TRUE;
3466
3467     // get the id of overlay profile
3468     $overlayProfileId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', 'summary_overlay', 'id', 'name');
3469     $query = "SELECT count(id) FROM civicrm_uf_field WHERE uf_group_id = {$overlayProfileId} AND visibility IN ('Public Pages', 'Public Pages and Listings') ";
3470
3471     $count = CRM_Core_DAO::singleValueQuery($query);
3472
3473     //check if there are no public fields and use is anonymous
3474     $session = CRM_Core_Session::singleton();
3475     if (!$count && !$session->get('userID')) {
3476       $showOverlay = FALSE;
3477     }
3478
3479     return $showOverlay;
3480   }
3481
3482   /**
3483    * function to get group type values of the profile
3484    *
3485    * @params Integer $profileId       Profile Id
3486    * @params String  $groupType       Group Type
3487    *
3488    * @param $profileId
3489    * @param null $groupType
3490    *
3491    * @return Array   group type values
3492    * @static
3493    * @access public
3494    */
3495   static function groupTypeValues($profileId, $groupType = NULL) {
3496     $groupTypeValue = array();
3497     $groupTypes = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $profileId, 'group_type');
3498
3499     $groupTypeParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, $groupTypes);
3500     if (empty($groupTypeParts[1])) {
3501       return $groupTypeValue;
3502     }
3503     $participantExtends = array('ParticipantRole', 'ParticipantEventName', 'ParticipantEventType');
3504
3505     foreach (explode(',', $groupTypeParts[1]) as $groupTypeValues) {
3506       $values = array();
3507       $valueParts = explode(':', $groupTypeValues);
3508       if ($groupType &&
3509         ($valueParts[0] != "{$groupType}Type" ||
3510           ($groupType == 'Participant' &&
3511             !in_array($valueParts[0], $participantExtends)
3512           )
3513         )
3514       ) {
3515         continue;
3516       }
3517       foreach ($valueParts as $val) {
3518         if (CRM_Utils_Rule::integer($val)) {
3519           $values[$val] = $val;
3520         }
3521       }
3522       if (!empty($values)) {
3523         $typeName = substr($valueParts[0], 0, -4);
3524         if (in_array($valueParts[0], $participantExtends)) {
3525           $typeName = $valueParts[0];
3526         }
3527         $groupTypeValue[$typeName] = $values;
3528       }
3529     }
3530
3531     return $groupTypeValue;
3532   }
3533
3534   /**
3535    * @return bool|object
3536    */
3537   static function isProfileDoubleOptin() {
3538     // check for double optin
3539     $config = CRM_Core_Config::singleton();
3540     if (in_array('CiviMail', $config->enableComponents)) {
3541       return CRM_Core_BAO_Setting::getItem(CRM_Core_BAO_Setting::MAILING_PREFERENCES_NAME,
3542         'profile_double_optin', NULL, FALSE
3543       );
3544     }
3545     return FALSE;
3546   }
3547
3548   /**
3549    * @return bool|object
3550    */
3551   static function isProfileAddToGroupDoubleOptin() {
3552     // check for add to group double optin
3553     $config = CRM_Core_Config::singleton();
3554     if (in_array('CiviMail', $config->enableComponents)) {
3555       return CRM_Core_BAO_Setting::getItem(CRM_Core_BAO_Setting::MAILING_PREFERENCES_NAME,
3556         'profile_add_to_group_double_optin', NULL, FALSE
3557       );
3558     }
3559     return FALSE;
3560   }
3561
3562   /**
3563    * get profiles used for batch entry
3564    *
3565    * @return array profileIds profile ids
3566    * @static
3567    */
3568   static function getBatchProfiles() {
3569     $query = "SELECT id
3570       FROM civicrm_uf_group
3571       WHERE name IN ('contribution_batch_entry', 'membership_batch_entry')";
3572     $dao = CRM_Core_DAO::executeQuery( $query );
3573     $profileIds = array();
3574     while( $dao->fetch() ) {
3575       $profileIds[$dao->id] = $dao->id;
3576     }
3577     return $profileIds;
3578   }
3579
3580   /**
3581    * @todo what do I do?
3582    * @param $source
3583    * @param $destination
3584    * @param bool $returnMultiSummaryFields
3585    *
3586    * @return array|null
3587    */
3588   static function shiftMultiRecordFields(&$source, &$destination, $returnMultiSummaryFields = FALSE) {
3589     $multiSummaryFields = $returnMultiSummaryFields ? array( ) : NULL;
3590     foreach ($source as $field => $properties) {
3591       if (!CRM_Core_BAO_CustomField::getKeyID($field)) {
3592         continue;
3593       }
3594       if (CRM_Core_BAO_CustomField::isMultiRecordField($field)) {
3595         $destination[$field] = $properties;
3596         if ($returnMultiSummaryFields) {
3597           if ($properties['is_multi_summary']) {
3598             $multiSummaryFields[$field] = $properties;
3599           }
3600         }
3601         unset($source[$field]);
3602       }
3603     }
3604     return $multiSummaryFields;
3605   }
3606
3607   /**
3608    * This is function is used to format pseudo fields
3609    *
3610    * @param array $fields associated array of profile fields
3611    *
3612    * @static
3613    */
3614   static function reformatProfileFields(&$fields) {
3615     //reformat fields array
3616     foreach ($fields as $name => $field) {
3617       //reformat phone and extension field
3618       if ( substr($field['name'], 0, 13) == 'phone_and_ext') {
3619         $fieldSuffix = str_replace('phone_and_ext-', '', $field['name']);
3620
3621         // retain existing element properties and just update and replace key
3622         CRM_Utils_Array::crmReplaceKey($fields, $name, "phone-{$fieldSuffix}");
3623         $fields["phone-{$fieldSuffix}"]['name'] = "phone-{$fieldSuffix}";
3624         $fields["phone-{$fieldSuffix}"]['where'] = 'civicrm_phone.phone';
3625
3626         // add additional phone extension field
3627         $fields["phone_ext-{$fieldSuffix}"] = $field;
3628         $fields["phone_ext-{$fieldSuffix}"]['title'] = $field['title'] .' - '.ts('Ext.');
3629         $fields["phone_ext-{$fieldSuffix}"]['name'] = "phone_ext-{$fieldSuffix}";
3630         $fields["phone_ext-{$fieldSuffix}"]['where'] = 'civicrm_phone.phone_ext';
3631         $fields["phone_ext-{$fieldSuffix}"]['skipDisplay'] = 1;
3632         //ignore required for extension field
3633         $fields["phone_ext-{$fieldSuffix}"]['is_required'] = 0;
3634       }
3635     }
3636   }
3637 }