CRM/Contact/BAO/Contact.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 /**
  13  *
  14  * @package CRM
  15  * @copyright CiviCRM LLC https://civicrm.org/licensing
  16  */
  17 class CRM_Contact_BAO_Contact extends CRM_Contact_DAO_Contact {
  18
  19   /**
  20    * SQL function used to format the phone_numeric field via trigger.
  21    *
  22    * @see self::triggerInfo()
  23    *
  24    * Note that this is also used by the 4.3 upgrade script.
  25    * @see CRM_Upgrade_Incremental_php_FourThree
  26    */
  27   const DROP_STRIP_FUNCTION_43 = "DROP FUNCTION IF EXISTS civicrm_strip_non_numeric";
  28
  29   const CREATE_STRIP_FUNCTION_43 = "
  30     CREATE FUNCTION civicrm_strip_non_numeric(input VARCHAR(255))
  31       RETURNS VARCHAR(255)
  32       DETERMINISTIC
  33       NO SQL
  34     BEGIN
  35       DECLARE output   VARCHAR(255) DEFAULT '';
  36       DECLARE iterator INT          DEFAULT 1;
  37       WHILE iterator < (LENGTH(input) + 1) DO
  38         IF SUBSTRING(input, iterator, 1) IN ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9') THEN
  39           SET output = CONCAT(output, SUBSTRING(input, iterator, 1));
  40         END IF;
  41         SET iterator = iterator + 1;
  42       END WHILE;
  43       RETURN output;
  44     END";
  45
  46   /**
  47    * The types of communication preferences.
  48    *
  49    * @var array
  50    */
  51   public static $_commPrefs = [
  52     'do_not_phone',
  53     'do_not_email',
  54     'do_not_mail',
  55     'do_not_sms',
  56     'do_not_trade',
  57   ];
  58
  59   /**
  60    * Types of greetings.
  61    *
  62    * @var array
  63    */
  64   public static $_greetingTypes = [
  65     'addressee',
  66     'email_greeting',
  67     'postal_greeting',
  68   ];
  69
  70   /**
  71    * Static field for all the contact information that we can potentially import.
  72    *
  73    * @var array
  74    */
  75   public static $_importableFields = [];
  76
  77   /**
  78    * Static field for all the contact information that we can potentially export.
  79    *
  80    * @var array
  81    */
  82   public static $_exportableFields = NULL;
  83
  84   /**
  85    * Class constructor.
  86    */
  87   public function __construct() {
  88     parent::__construct();
  89   }
  90
  91   /**
  92    * Takes an associative array and creates a contact object.
  93    *
  94    * The function extracts all the params it needs to initialize the create a
  95    * contact object. the params array could contain additional unused name/value
  96    * pairs
  97    *
  98    * @param array $params
  99    *   (reference) an assoc array of name/value pairs.
 100    *
 101    * @return CRM_Contact_DAO_Contact|CRM_Core_Error|NULL
 102    *   Created or updated contact object or error object.
 103    *   (error objects are being phased out in favour of exceptions)
 104    * @throws \CRM_Core_Exception
 105    */
 106   public static function add(&$params) {
 107     $contact = new CRM_Contact_DAO_Contact();
 108     $contactID = $params['contact_id'] ?? NULL;
 109     if (empty($params)) {
 110       return NULL;
 111     }
 112
 113     // Fix for validate contact sub type CRM-5143.
 114     if (isset($params['contact_sub_type'])) {
 115       if (empty($params['contact_sub_type'])) {
 116         $params['contact_sub_type'] = 'null';
 117       }
 118       elseif ($params['contact_sub_type'] !== 'null') {
 119         if (!CRM_Contact_BAO_ContactType::isExtendsContactType($params['contact_sub_type'],
 120           $params['contact_type'], TRUE
 121         )
 122         ) {
 123           // we'll need to fix tests to handle this
 124           // CRM-7925
 125           throw new CRM_Core_Exception(ts('The Contact Sub Type does not match the Contact type for this record'));
 126         }
 127         $params['contact_sub_type'] = CRM_Utils_Array::implodePadded($params['contact_sub_type']);
 128       }
 129     }
 130
 131     if (isset($params['preferred_communication_method']) && is_array($params['preferred_communication_method'])) {
 132       CRM_Utils_Array::formatArrayKeys($params['preferred_communication_method']);
 133       $contact->preferred_communication_method = CRM_Utils_Array::implodePadded($params['preferred_communication_method']);
 134       unset($params['preferred_communication_method']);
 135     }
 136
 137     $defaults = ['source' => $params['contact_source'] ?? NULL];
 138     if ($params['contact_type'] === 'Organization' && isset($params['organization_name'])) {
 139       $defaults['display_name'] = $params['organization_name'];
 140       $defaults['sort_name'] = $params['organization_name'];
 141     }
 142     if ($params['contact_type'] === 'Household' && isset($params['household_name'])) {
 143       $defaults['display_name'] = $params['household_name'];
 144       $defaults['sort_name'] = $params['household_name'];
 145     }
 146     $params = array_merge($defaults, $params);
 147
 148     $allNull = $contact->copyValues($params);
 149
 150     $contact->id = $contactID;
 151
 152     if ($contact->contact_type === 'Individual') {
 153       $allNull = FALSE;
 154       // @todo allow the lines below to be overridden by input or hooks & add tests,
 155       // as has been done for households and organizations.
 156       // Format individual fields.
 157       CRM_Contact_BAO_Individual::format($params, $contact);
 158     }
 159
 160     if (strlen($contact->display_name) > 128) {
 161       $contact->display_name = substr($contact->display_name, 0, 128);
 162     }
 163     if (strlen($contact->sort_name) > 128) {
 164       $contact->sort_name = substr($contact->sort_name, 0, 128);
 165     }
 166
 167     $privacy = $params['privacy'] ?? NULL;
 168     if ($privacy && is_array($privacy)) {
 169       $allNull = FALSE;
 170       foreach (self::$_commPrefs as $name) {
 171         $contact->$name = $privacy[$name] ?? FALSE;
 172       }
 173     }
 174
 175     // Since hash was required, make sure we have a 0 value for it (CRM-1063).
 176     // @todo - does this mean we can remove this block?
 177     // Fixed in 1.5 by making hash optional, only do this in create mode, not update.
 178     if ((!isset($contact->hash) || !$contact->hash) && !$contact->id) {
 179       $allNull = FALSE;
 180       $contact->hash = md5(uniqid(rand(), TRUE));
 181     }
 182
 183     // Even if we don't need $employerId, it's important to call getFieldValue() before
 184     // the contact is saved because we want the existing value to be cached.
 185     // createCurrentEmployerRelationship() needs the old value not the updated one. CRM-10788
 186     $employerId = (!$contactID || $contact->contact_type !== 'Individual') ? NULL : CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $contact->id, 'employer_id');
 187
 188     if (!$allNull) {
 189       $contact->save();
 190
 191       CRM_Core_BAO_Log::register($contact->id,
 192         'civicrm_contact',
 193         $contact->id
 194       );
 195     }
 196
 197     if ($contact->contact_type === 'Individual' && (isset($params['current_employer']) || isset($params['employer_id']))) {
 198       // Create current employer.
 199       $newEmployer = !empty($params['employer_id']) ? $params['employer_id'] : $params['current_employer'] ?? NULL;
 200
 201       $newContact = empty($params['contact_id']);
 202       if ($newEmployer) {
 203         CRM_Contact_BAO_Contact_Utils::createCurrentEmployerRelationship($contact->id, $newEmployer, $employerId, $newContact);
 204       }
 205       elseif ($employerId) {
 206         CRM_Contact_BAO_Contact_Utils::clearCurrentEmployer($contact->id, $employerId);
 207       }
 208     }
 209
 210     // Update cached employer name if the name of an existing organization is being updated.
 211     if ($contact->contact_type === 'Organization' && !empty($params['organization_name']) && $contactID) {
 212       CRM_Contact_BAO_Contact_Utils::updateCurrentEmployer($contact->id);
 213     }
 214
 215     return $contact;
 216   }
 217
 218   /**
 219    * Create contact.
 220    *
 221    * takes an associative array and creates a contact object and all the associated
 222    * derived objects (i.e. individual, location, email, phone etc)
 223    *
 224    * This function is invoked from within the web form layer and also from the api layer
 225    *
 226    * @param array $params
 227    *   (reference ) an assoc array of name/value pairs.
 228    * @param bool $fixAddress
 229    *   If we need to fix address.
 230    * @param bool $invokeHooks
 231    *   If we need to invoke hooks.
 232    *
 233    * @param bool $skipDelete
 234    *   Unclear parameter, passed to website create
 235    *
 236    * @return CRM_Contact_BAO_Contact|CRM_Core_Error
 237    *   Created or updated contribution object. We are deprecating returning an error in
 238    *   favour of exceptions
 239    *
 240    * @throws \CRM_Core_Exception
 241    * @throws \CiviCRM_API3_Exception
 242    * @throws \Civi\API\Exception\UnauthorizedException
 243    */
 244   public static function &create(&$params, $fixAddress = TRUE, $invokeHooks = TRUE, $skipDelete = FALSE) {
 245     $contact = NULL;
 246     if (empty($params['contact_type']) && empty($params['contact_id'])) {
 247       return $contact;
 248     }
 249
 250     $isEdit = !empty($params['contact_id']);
 251
 252     if ($isEdit && empty($params['contact_type'])) {
 253       $params['contact_type'] = self::getContactType($params['contact_id']);
 254     }
 255
 256     if (!empty($params['check_permissions']) && isset($params['api_key'])
 257       && !CRM_Core_Permission::check([['edit api keys', 'administer CiviCRM']])
 258       && !($isEdit && CRM_Core_Permission::check('edit own api keys') && $params['contact_id'] == CRM_Core_Session::getLoggedInContactID())
 259     ) {
 260       throw new \Civi\API\Exception\UnauthorizedException('Permission denied to modify api key');
 261     }
 262
 263     if ($invokeHooks) {
 264       if (!empty($params['contact_id'])) {
 265         CRM_Utils_Hook::pre('edit', $params['contact_type'], $params['contact_id'], $params);
 266       }
 267       else {
 268         CRM_Utils_Hook::pre('create', $params['contact_type'], NULL, $params);
 269       }
 270     }
 271
 272     self::ensureGreetingParamsAreSet($params);
 273
 274     // CRM-6942: set preferred language to the current language if it’s unset (and we’re creating a contact).
 275     if (empty($params['contact_id'])) {
 276       // A case could be made for checking isset rather than empty but this is more consistent with previous behaviour.
 277       if (empty($params['preferred_language']) && ($language = CRM_Core_I18n::getContactDefaultLanguage()) != FALSE) {
 278         $params['preferred_language'] = $language;
 279       }
 280
 281       // CRM-21041: set default 'Communication Style' if unset when creating a contact.
 282       if (empty($params['communication_style_id'])) {
 283         $defaultCommunicationStyleId = CRM_Core_OptionGroup::values('communication_style', TRUE, NULL, NULL, 'AND is_default = 1');
 284         $params['communication_style_id'] = array_pop($defaultCommunicationStyleId);
 285       }
 286     }
 287
 288     $transaction = new CRM_Core_Transaction();
 289
 290     $contact = self::add($params);
 291
 292     $params['contact_id'] = $contact->id;
 293
 294     if (Civi::settings()->get('is_enabled')) {
 295       // Enabling multisite causes the contact to be added to the domain group.
 296       $domainGroupID = CRM_Core_BAO_Domain::getGroupId();
 297       if (!empty($domainGroupID)) {
 298         if (!empty($params['group']) && is_array($params['group'])) {
 299           $params['group'][$domainGroupID] = 1;
 300         }
 301         else {
 302           $params['group'] = [$domainGroupID => 1];
 303         }
 304       }
 305     }
 306
 307     if (!empty($params['group'])) {
 308       $contactIds = [$params['contact_id']];
 309       foreach ($params['group'] as $groupId => $flag) {
 310         if ($flag == 1) {
 311           CRM_Contact_BAO_GroupContact::addContactsToGroup($contactIds, $groupId);
 312         }
 313         elseif ($flag == -1) {
 314           CRM_Contact_BAO_GroupContact::removeContactsFromGroup($contactIds, $groupId);
 315         }
 316       }
 317     }
 318
 319     // Add location Block data.
 320     $blocks = CRM_Core_BAO_Location::create($params, $fixAddress);
 321     foreach ($blocks as $name => $value) {
 322       $contact->$name = $value;
 323     }
 324     if (!empty($params['updateBlankLocInfo'])) {
 325       $skipDelete = TRUE;
 326     }
 327
 328     if (isset($params['website'])) {
 329       CRM_Core_BAO_Website::process($params['website'], $contact->id, $skipDelete);
 330     }
 331
 332     $userID = CRM_Core_Session::singleton()->get('userID');
 333     // add notes
 334     if (!empty($params['note'])) {
 335       if (is_array($params['note'])) {
 336         foreach ($params['note'] as $note) {
 337           $contactId = $contact->id;
 338           if (isset($note['contact_id'])) {
 339             $contactId = $note['contact_id'];
 340           }
 341           //if logged in user, overwrite contactId
 342           if ($userID) {
 343             $contactId = $userID;
 344           }
 345
 346           $noteParams = [
 347             'entity_id' => $contact->id,
 348             'entity_table' => 'civicrm_contact',
 349             'note' => $note['note'],
 350             'subject' => $note['subject'] ?? NULL,
 351             'contact_id' => $contactId,
 352           ];
 353           CRM_Core_BAO_Note::add($noteParams);
 354         }
 355       }
 356       else {
 357         $contactId = $contact->id;
 358         //if logged in user, overwrite contactId
 359         if ($userID) {
 360           $contactId = $userID;
 361         }
 362
 363         $noteParams = [
 364           'entity_id' => $contact->id,
 365           'entity_table' => 'civicrm_contact',
 366           'note' => $params['note'],
 367           'subject' => $params['subject'] ?? NULL,
 368           'contact_id' => $contactId,
 369         ];
 370         CRM_Core_BAO_Note::add($noteParams);
 371       }
 372     }
 373
 374     // update the UF user_unique_id if that has changed
 375     CRM_Core_BAO_UFMatch::updateUFName($contact->id);
 376
 377     if (!empty($params['custom']) &&
 378       is_array($params['custom'])
 379     ) {
 380       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_contact', $contact->id);
 381     }
 382
 383     $transaction->commit();
 384
 385     // CRM-6367: fetch the right label for contact type’s display
 386     $contact->contact_type_display = CRM_Core_DAO::getFieldValue(
 387       'CRM_Contact_DAO_ContactType',
 388       $contact->contact_type,
 389       'label',
 390       'name'
 391     );
 392
 393     CRM_Contact_BAO_Contact_Utils::clearContactCaches();
 394
 395     if ($invokeHooks) {
 396       if ($isEdit) {
 397         CRM_Utils_Hook::post('edit', $params['contact_type'], $contact->id, $contact);
 398       }
 399       else {
 400         CRM_Utils_Hook::post('create', $params['contact_type'], $contact->id, $contact);
 401       }
 402     }
 403
 404     // In order to prevent a series of expensive queries in intensive batch processing
 405     // api calls may pass in skip_greeting_processing, probably doing it later via the
 406     // scheduled job. CRM-21551
 407     if (empty($params['skip_greeting_processing'])) {
 408       self::processGreetings($contact);
 409     }
 410
 411     if (!empty($params['check_permissions'])) {
 412       $contacts = [&$contact];
 413       self::unsetProtectedFields($contacts);
 414     }
 415
 416     if (!empty($params['is_deceased'])) {
 417       // Edit Membership Status
 418       $deceasedParams = [
 419         'contact_id' => $contact->id,
 420         'is_deceased' => $params['is_deceased'],
 421         'deceased_date' => $params['deceased_date'] ?? NULL,
 422       ];
 423       CRM_Member_BAO_Membership::updateMembershipStatus($deceasedParams, $params['contact_type']);
 424     }
 425
 426     return $contact;
 427   }
 428
 429   /**
 430    * Format the output of the create contact function
 431    *
 432    * @param CRM_Contact_DAO_Contact[]|array[] $contacts
 433    */
 434   public static function unsetProtectedFields(&$contacts) {
 435     if (!CRM_Core_Permission::check([['edit api keys', 'administer CiviCRM']])) {
 436       $currentUser = CRM_Core_Session::getLoggedInContactID();
 437       $editOwn = $currentUser && CRM_Core_Permission::check('edit own api keys');
 438       foreach ($contacts as &$contact) {
 439         $cid = is_object($contact) ? $contact->id : $contact['id'] ?? NULL;
 440         if (!($editOwn && $cid == $currentUser)) {
 441           if (is_object($contact)) {
 442             unset($contact->api_key);
 443           }
 444           else {
 445             unset($contact['api_key']);
 446           }
 447         }
 448       }
 449     }
 450   }
 451
 452   /**
 453    * Ensure greeting parameters are set.
 454    *
 455    * By always populating greetings here we can be sure they are set if required & avoid a call later.
 456    * (ie. knowing we have definitely tried disambiguates between NULL & not loaded.)
 457    *
 458    * @param array $params
 459    *
 460    * @throws \CiviCRM_API3_Exception
 461    */
 462   public static function ensureGreetingParamsAreSet(&$params) {
 463     $allGreetingParams = ['addressee' => 'addressee_id', 'postal_greeting' => 'postal_greeting_id', 'email_greeting' => 'email_greeting_id'];
 464     $missingGreetingParams = [];
 465
 466     foreach ($allGreetingParams as $greetingIndex => $greetingParam) {
 467       if (empty($params[$greetingParam])) {
 468         $missingGreetingParams[$greetingIndex] = $greetingParam;
 469       }
 470     }
 471
 472     if (!empty($params['contact_id']) && !empty($missingGreetingParams)) {
 473       $savedGreetings = civicrm_api3('Contact', 'getsingle', [
 474         'id' => $params['contact_id'],
 475         'return' => array_keys($missingGreetingParams),
 476       ]);
 477
 478       foreach (array_keys($missingGreetingParams) as $missingGreetingParam) {
 479         if (!empty($savedGreetings[$missingGreetingParam . '_custom'])) {
 480           $missingGreetingParams[$missingGreetingParam . '_custom'] = $missingGreetingParam . '_custom';
 481         }
 482       }
 483       // Filter out other fields.
 484       $savedGreetings = array_intersect_key($savedGreetings, array_flip($missingGreetingParams));
 485       $params = array_merge($params, $savedGreetings);
 486     }
 487     else {
 488       foreach ($missingGreetingParams as $greetingName => $greeting) {
 489         $params[$greeting] = CRM_Contact_BAO_Contact_Utils::defaultGreeting($params['contact_type'], $greetingName);
 490       }
 491     }
 492
 493     foreach ($allGreetingParams as $greetingIndex => $greetingParam) {
 494       if ($params[$greetingParam] === 'null') {
 495         //  If we are setting it to null then null out the display field.
 496         $params[$greetingIndex . '_display'] = 'null';
 497       }
 498     }
 499   }
 500
 501   /**
 502    * Get the display name and image of a contact.
 503    *
 504    * @param int $id
 505    *   The contactId.
 506    *
 507    * @param bool $includeTypeInReturnParameters
 508    *   Should type be part of the returned array?
 509    *
 510    * @return array
 511    *   the displayName and contactImage for this contact
 512    */
 513   public static function getDisplayAndImage($id, $includeTypeInReturnParameters = FALSE) {
 514     //CRM-14276 added the * on the civicrm_contact table so that we have all the contact info available
 515     $sql = "
 516 SELECT    civicrm_contact.*,
 517           civicrm_email.email          as email
 518 FROM      civicrm_contact
 519 LEFT JOIN civicrm_email ON civicrm_email.contact_id = civicrm_contact.id
 520      AND  civicrm_email.is_primary = 1
 521 WHERE     civicrm_contact.id = " . CRM_Utils_Type::escape($id, 'Integer');
 522     $dao = new CRM_Core_DAO();
 523     $dao->query($sql);
 524     if ($dao->fetch()) {
 525       $image = CRM_Contact_BAO_Contact_Utils::getImage($dao->contact_sub_type ?
 526         $dao->contact_sub_type : $dao->contact_type, FALSE, $id
 527       );
 528       $imageUrl = CRM_Contact_BAO_Contact_Utils::getImage($dao->contact_sub_type ?
 529         $dao->contact_sub_type : $dao->contact_type, TRUE, $id
 530       );
 531
 532       // use email if display_name is empty
 533       if (empty($dao->display_name)) {
 534         $displayName = $dao->email;
 535       }
 536       else {
 537         $displayName = $dao->display_name;
 538       }
 539
 540       CRM_Utils_Hook::alterDisplayName($displayName, $id, $dao);
 541
 542       return $includeTypeInReturnParameters ? [
 543         $displayName,
 544         $image,
 545         $dao->contact_type,
 546         $dao->contact_sub_type,
 547         $imageUrl,
 548       ] : [$displayName, $image, $imageUrl];
 549     }
 550     return NULL;
 551   }
 552
 553   /**
 554    * Add billing fields to the params if appropriate.
 555    *
 556    * If we have ANY name fields then we want to ignore all the billing name fields. However, if we
 557    * don't then we should set the name fields to the billing fields AND add the preserveDBName
 558    * parameter (which will tell the BAO only to set those fields if none already exist.
 559    *
 560    * We specifically don't want to set first name from billing and last name form an on-page field. Mixing &
 561    * matching is best done by hipsters.
 562    *
 563    * @param array $params
 564    *
 565    * @fixme How does this relate to almost the same thing being done in CRM_Core_Form::formatParamsForPaymentProcessor()
 566    */
 567   public static function addBillingNameFieldsIfOtherwiseNotSet(&$params) {
 568     $nameFields = ['first_name', 'middle_name', 'last_name', 'nick_name', 'prefix_id', 'suffix_id'];
 569     foreach ($nameFields as $field) {
 570       if (!empty($params[$field])) {
 571         return;
 572       }
 573     }
 574     // There are only 3 - we can iterate through them twice :-)
 575     foreach ($nameFields as $field) {
 576       if (!empty($params['billing_' . $field])) {
 577         $params[$field] = $params['billing_' . $field];
 578       }
 579       $params['preserveDBName'] = TRUE;
 580     }
 581
 582   }
 583
 584   /**
 585    * Resolve a state province string (UT or Utah) to an ID.
 586    *
 587    * If country has been passed in we should select a state belonging to that country.
 588    *
 589    * Alternatively we should choose from enabled countries, prioritising the default country.
 590    *
 591    * @param array $values
 592    * @param int|null $countryID
 593    *
 594    * @return int|null
 595    *
 596    * @throws \CRM_Core_Exception
 597    */
 598   protected static function resolveStateProvinceID($values, $countryID) {
 599
 600     if ($countryID) {
 601       $stateProvinceList = CRM_Core_PseudoConstant::stateProvinceForCountry($countryID);
 602       if (CRM_Utils_Array::lookupValue($values,
 603         'state_province',
 604         $stateProvinceList,
 605         TRUE
 606       )) {
 607         return $values['state_province_id'];
 608       }
 609       $stateProvinceList = CRM_Core_PseudoConstant::stateProvinceForCountry($countryID, 'abbreviation');
 610       if (CRM_Utils_Array::lookupValue($values,
 611         'state_province',
 612         $stateProvinceList,
 613         TRUE
 614       )) {
 615         return $values['state_province_id'];
 616       }
 617       return NULL;
 618     }
 619     else {
 620       // The underlying lookupValue function needs some de-fanging. Until that has been unravelled we
 621       // continue to resolve stateprovince lists in descending order of preference & just 'keep trying'.
 622       // prefer matching country..
 623       $stateProvinceList = CRM_Core_BAO_Address::buildOptions('state_province_id', NULL, ['country_id' => Civi::settings()->get('defaultContactCountry')]);
 624       if (CRM_Utils_Array::lookupValue($values,
 625         'state_province',
 626         $stateProvinceList,
 627         TRUE
 628       )) {
 629         return $values['state_province_id'];
 630       }
 631
 632       $stateProvinceList = CRM_Core_PseudoConstant::stateProvince();
 633       if (CRM_Utils_Array::lookupValue($values,
 634         'state_province',
 635         $stateProvinceList,
 636         TRUE
 637       )) {
 638         return $values['state_province_id'];
 639       }
 640
 641       $stateProvinceList = CRM_Core_PseudoConstant::stateProvinceAbbreviationForDefaultCountry();
 642       if (CRM_Utils_Array::lookupValue($values,
 643         'state_province',
 644         $stateProvinceList,
 645         TRUE
 646       )) {
 647         return $values['state_province_id'];
 648       }
 649       $stateProvinceList = CRM_Core_PseudoConstant::stateProvinceAbbreviation();
 650       if (CRM_Utils_Array::lookupValue($values,
 651         'state_province',
 652         $stateProvinceList,
 653         TRUE
 654       )) {
 655         return $values['state_province_id'];
 656       }
 657     }
 658
 659     return NULL;
 660   }
 661
 662   /**
 663    * Get the relevant location entity for the array key.
 664    *
 665    * Based on the field name we determine which location entity
 666    * we are dealing with. Apart from a few specific ones they
 667    * are mostly 'address' (the default).
 668    *
 669    * @param string $fieldName
 670    *
 671    * @return string
 672    */
 673   protected static function getLocationEntityForKey($fieldName) {
 674     if (in_array($fieldName, ['email', 'phone', 'im', 'openid'])) {
 675       return $fieldName;
 676     }
 677     if ($fieldName === 'phone_ext') {
 678       return 'phone';
 679     }
 680     return 'address';
 681   }
 682
 683   /**
 684    * Soft delete a contact.
 685    *
 686    * Call this via the api, not directly.
 687    *
 688    * @param \CRM_Contact_BAO_Contact $contact
 689    *
 690    * @return bool
 691    * @throws \CRM_Core_Exception
 692    */
 693   protected static function contactTrash($contact): bool {
 694     $updateParams = [
 695       'id' => $contact->id,
 696       'is_deleted' => 1,
 697     ];
 698     CRM_Utils_Hook::pre('update', $contact->contact_type, $contact->id, $updateParams);
 699
 700     $params = [1 => [$contact->id, 'Integer']];
 701     $query = 'DELETE FROM civicrm_uf_match WHERE contact_id = %1';
 702     CRM_Core_DAO::executeQuery($query, $params);
 703
 704     $contact->copyValues($updateParams);
 705     $contact->save();
 706     CRM_Core_BAO_Log::register($contact->id, 'civicrm_contact', $contact->id);
 707
 708     CRM_Utils_Hook::post('update', $contact->contact_type, $contact->id, $contact);
 709
 710     return TRUE;
 711   }
 712
 713   /**
 714    * Create last viewed link to recently updated contact.
 715    *
 716    * @param array $crudLinkSpec
 717    *  - action: int, CRM_Core_Action::UPDATE or CRM_Core_Action::VIEW [default: VIEW]
 718    *  - entity_table: string, eg "civicrm_contact"
 719    *  - entity_id: int
 720    *
 721    * @return array|NULL
 722    *   NULL if unavailable, or
 723    *   [path: string, query: string, title: string]
 724    * @see CRM_Utils_System::createDefaultCrudLink
 725    */
 726   public function createDefaultCrudLink($crudLinkSpec) {
 727     switch ($crudLinkSpec['action']) {
 728       case CRM_Core_Action::VIEW:
 729         $result = [
 730           'title' => $this->display_name,
 731           'path' => 'civicrm/contact/view',
 732           'query' => [
 733             'reset' => 1,
 734             'cid' => $this->id,
 735           ],
 736         ];
 737         return $result;
 738
 739       case CRM_Core_Action::UPDATE:
 740         $result = [
 741           'title' => $this->display_name,
 742           'path' => 'civicrm/contact/add',
 743           'query' => [
 744             'reset' => 1,
 745             'action' => 'update',
 746             'cid' => $this->id,
 747           ],
 748         ];
 749         return $result;
 750     }
 751     return NULL;
 752   }
 753
 754   /**
 755    * Get the values for pseudoconstants for name->value and reverse.
 756    *
 757    * @param array $defaults
 758    *   (reference) the default values, some of which need to be resolved.
 759    * @param bool $reverse
 760    *   Always true as this function is only called from one place..
 761    *
 762    * @deprecated
 763    *
 764    * This is called specifically from the contact import parser & should be moved there
 765    * as it is not truly a generic function.
 766    *
 767    */
 768   public static function resolveDefaults(&$defaults, $reverse = FALSE) {
 769     // Hack for birth_date.
 770     if (!empty($defaults['birth_date'])) {
 771       if (is_array($defaults['birth_date'])) {
 772         $defaults['birth_date'] = CRM_Utils_Date::format($defaults['birth_date'], '-');
 773       }
 774     }
 775
 776     CRM_Utils_Array::lookupValue($defaults, 'prefix', CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'prefix_id'), $reverse);
 777     CRM_Utils_Array::lookupValue($defaults, 'suffix', CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'suffix_id'), $reverse);
 778     CRM_Utils_Array::lookupValue($defaults, 'gender', CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'gender_id'), $reverse);
 779     CRM_Utils_Array::lookupValue($defaults, 'communication_style', CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'communication_style_id'), $reverse);
 780
 781     //lookup value of email/postal greeting, addressee, CRM-4575
 782     foreach (self::$_greetingTypes as $greeting) {
 783       $filterCondition = [
 784         'contact_type' => $defaults['contact_type'] ?? NULL,
 785         'greeting_type' => $greeting,
 786       ];
 787       CRM_Utils_Array::lookupValue($defaults, $greeting,
 788         CRM_Core_PseudoConstant::greeting($filterCondition), $reverse
 789       );
 790     }
 791
 792     $blocks = ['address', 'im', 'phone'];
 793     foreach ($blocks as $name) {
 794       if (!array_key_exists($name, $defaults) || !is_array($defaults[$name])) {
 795         continue;
 796       }
 797       foreach ($defaults[$name] as $count => & $values) {
 798
 799         //get location type id.
 800         CRM_Utils_Array::lookupValue($values, 'location_type', CRM_Core_PseudoConstant::get('CRM_Core_DAO_Address', 'location_type_id'), $reverse);
 801
 802         if ($name == 'address') {
 803           // FIXME: lookupValue doesn't work for vcard_name
 804           if (!empty($values['location_type_id'])) {
 805             $vcardNames = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Address', 'location_type_id', ['labelColumn' => 'vcard_name']);
 806             $values['vcard_name'] = $vcardNames[$values['location_type_id']];
 807           }
 808
 809           if (!CRM_Utils_Array::lookupValue($values,
 810               'country',
 811               CRM_Core_PseudoConstant::country(),
 812               $reverse
 813             ) &&
 814             $reverse
 815           ) {
 816             CRM_Utils_Array::lookupValue($values,
 817               'country',
 818               CRM_Core_PseudoConstant::countryIsoCode(),
 819               $reverse
 820             );
 821           }
 822           $stateProvinceID = self::resolveStateProvinceID($values, $values['country_id'] ?? NULL);
 823           if ($stateProvinceID) {
 824             $values['state_province_id'] = $stateProvinceID;
 825           }
 826
 827           if (!empty($values['state_province_id'])) {
 828             $countyList = CRM_Core_PseudoConstant::countyForState($values['state_province_id']);
 829           }
 830           else {
 831             $countyList = CRM_Core_PseudoConstant::county();
 832           }
 833           CRM_Utils_Array::lookupValue($values,
 834             'county',
 835             $countyList,
 836             $reverse
 837           );
 838         }
 839
 840         if ($name == 'im') {
 841           CRM_Utils_Array::lookupValue($values,
 842             'provider',
 843             CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id'),
 844             $reverse
 845           );
 846         }
 847
 848         if ($name == 'phone') {
 849           CRM_Utils_Array::lookupValue($values,
 850             'phone_type',
 851             CRM_Core_PseudoConstant::get('CRM_Core_DAO_Phone', 'phone_type_id'),
 852             $reverse
 853           );
 854         }
 855
 856         // Kill the reference.
 857         unset($values);
 858       }
 859     }
 860   }
 861
 862   /**
 863    * Fetch object based on array of properties.
 864    *
 865    * @param array $params
 866    *   (reference ) an assoc array of name/value pairs.
 867    * @param array $defaults
 868    *   (reference ) an assoc array to hold the name / value pairs.
 869    *                        in a hierarchical manner
 870    * @param bool $microformat
 871    *   For location in microformat.
 872    *
 873    * @return CRM_Contact_BAO_Contact
 874    */
 875   public static function &retrieve(&$params, &$defaults, $microformat = FALSE) {
 876     if (array_key_exists('contact_id', $params)) {
 877       $params['id'] = $params['contact_id'];
 878     }
 879     elseif (array_key_exists('id', $params)) {
 880       $params['contact_id'] = $params['id'];
 881     }
 882
 883     $contact = self::getValues($params, $defaults);
 884
 885     unset($params['id']);
 886
 887     //get the block information for this contact
 888     $entityBlock = ['contact_id' => $params['contact_id']];
 889     $blocks = CRM_Core_BAO_Location::getValues($entityBlock, $microformat);
 890     $defaults = array_merge($defaults, $blocks);
 891     foreach ($blocks as $block => $value) {
 892       $contact->$block = $value;
 893     }
 894
 895     if (!isset($params['noNotes'])) {
 896       $contact->notes = CRM_Core_BAO_Note::getValues($params, $defaults);
 897     }
 898
 899     if (!isset($params['noRelationships'])) {
 900       $contact->relationship = CRM_Contact_BAO_Relationship::getValues($params, $defaults);
 901     }
 902
 903     if (!isset($params['noGroups'])) {
 904       $contact->groupContact = CRM_Contact_BAO_GroupContact::getValues($params, $defaults);
 905     }
 906
 907     if (!isset($params['noWebsite'])) {
 908       $contact->website = CRM_Core_BAO_Website::getValues($params, $defaults);
 909     }
 910
 911     return $contact;
 912   }
 913
 914   /**
 915    * Get the display name of a contact.
 916    *
 917    * @param int $id
 918    *   Id of the contact.
 919    *
 920    * @return null|string
 921    *   display name of the contact if found
 922    */
 923   public static function displayName($id) {
 924     $displayName = NULL;
 925     if ($id) {
 926       $displayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $id, 'display_name');
 927     }
 928
 929     return $displayName;
 930   }
 931
 932   /**
 933    * Delete a contact and all its associated records.
 934    *
 935    * @param int $id
 936    *   Id of the contact to delete.
 937    * @param bool $restore
 938    *   Whether to actually restore, not delete.
 939    * @param bool $skipUndelete
 940    *   Whether to force contact delete or not.
 941    * @param bool $checkPermissions
 942    *
 943    * @return bool
 944    *   Was contact deleted?
 945    *
 946    * @throws \CRM_Core_Exception
 947    * @throws \CiviCRM_API3_Exception
 948    */
 949   public static function deleteContact($id, $restore = FALSE, $skipUndelete = FALSE, $checkPermissions = TRUE) {
 950
 951     if (!$id || !is_numeric($id)) {
 952       CRM_Core_Error::deprecatedFunctionWarning('calling delete contact without a valid contact ID is deprecated.');
 953       return FALSE;
 954     }
 955     // If trash is disabled in system settings then we always skip
 956     if (!Civi::settings()->get('contact_undelete')) {
 957       $skipUndelete = TRUE;
 958     }
 959
 960     // make sure we have edit permission for this contact
 961     // before we delete
 962     if ($checkPermissions && (($skipUndelete && !CRM_Core_Permission::check('delete contacts')) ||
 963         ($restore && !CRM_Core_Permission::check('access deleted contacts')))
 964     ) {
 965       return FALSE;
 966     }
 967
 968     // CRM-12929
 969     // Restrict contact to be delete if contact has financial trxns
 970     $error = NULL;
 971     if ($skipUndelete && CRM_Financial_BAO_FinancialItem::checkContactPresent([$id], $error)) {
 972       return FALSE;
 973     }
 974
 975     // make sure this contact_id does not have any membership types
 976     $membershipTypeID = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipType',
 977       $id,
 978       'id',
 979       'member_of_contact_id'
 980     );
 981     if ($membershipTypeID) {
 982       return FALSE;
 983     }
 984
 985     $contact = new CRM_Contact_DAO_Contact();
 986     $contact->id = $id;
 987     if (!$contact->find(TRUE)) {
 988       return FALSE;
 989     }
 990
 991     $contactType = $contact->contact_type;
 992     if ($restore) {
 993       // @todo deprecate calling contactDelete with the intention to restore.
 994       $updateParams = [
 995         'id' => $contact->id,
 996         'is_deleted' => FALSE,
 997       ];
 998       self::create($updateParams);
 999       return TRUE;
1000     }
1001
1002     // start a new transaction
1003     $transaction = new CRM_Core_Transaction();
1004
1005     if ($skipUndelete) {
1006       $hookParams = ['check_permissions' => $checkPermissions];
1007       CRM_Utils_Hook::pre('delete', $contactType, $id, $hookParams);
1008
1009       //delete billing address if exists.
1010       CRM_Contribute_BAO_Contribution::deleteAddress(NULL, $id);
1011
1012       // delete the log entries since we dont have triggers enabled as yet
1013       $logDAO = new CRM_Core_DAO_Log();
1014       $logDAO->entity_table = 'civicrm_contact';
1015       $logDAO->entity_id = $id;
1016       $logDAO->delete();
1017
1018       // delete contact participants CRM-12155
1019       CRM_Event_BAO_Participant::deleteContactParticipant($id);
1020
1021       // delete contact contributions CRM-12155
1022       CRM_Contribute_BAO_Contribution::deleteContactContribution($id);
1023
1024       // do activity cleanup, CRM-5604
1025       CRM_Activity_BAO_Activity::cleanupActivity($id);
1026
1027       // delete all notes related to contact
1028       CRM_Core_BAO_Note::cleanContactNotes($id);
1029
1030       // delete cases related to contact
1031       $contactCases = CRM_Case_BAO_Case::retrieveCaseIdsByContactId($id);
1032       if (!empty($contactCases)) {
1033         foreach ($contactCases as $caseId) {
1034           //check if case is associate with other contact or not.
1035           $caseContactId = CRM_Case_BAO_Case::getCaseClients($caseId);
1036           if (count($caseContactId) <= 1) {
1037             CRM_Case_BAO_Case::deleteCase($caseId);
1038           }
1039         }
1040       }
1041
1042       $contact->delete();
1043     }
1044     else {
1045       self::contactTrash($contact);
1046     }
1047     // currently we only clear employer cache.
1048     // we are now deleting inherited membership if any.
1049     if ($contact->contact_type == 'Organization') {
1050       $action = $restore ? CRM_Core_Action::ENABLE : CRM_Core_Action::DISABLE;
1051       $relationshipDtls = CRM_Contact_BAO_Relationship::getRelationship($id);
1052       if (!empty($relationshipDtls)) {
1053         foreach ($relationshipDtls as $rId => $details) {
1054           CRM_Contact_BAO_Relationship::disableEnableRelationship($rId, $action);
1055         }
1056       }
1057       CRM_Contact_BAO_Contact_Utils::clearAllEmployee($id);
1058     }
1059
1060     //delete the contact id from recently view
1061     CRM_Utils_Recent::delContact($id);
1062     self::updateContactCache($id, empty($restore));
1063
1064     // delete any prevnext/dupe cache entry
1065     // These two calls are redundant in default deployments, but they're
1066     // meaningful if "prevnext" is memory-backed.
1067     Civi::service('prevnext')->deleteItem($id);
1068     CRM_Core_BAO_PrevNextCache::deleteItem($id);
1069
1070     $transaction->commit();
1071
1072     if ($skipUndelete) {
1073       CRM_Utils_Hook::post('delete', $contactType, $contact->id, $contact);
1074     }
1075
1076     return TRUE;
1077   }
1078
1079   /**
1080    * Action to update any caches relating to a recently update contact.
1081    *
1082    * I was going to call this from delete as well as from create to ensure the delete is being
1083    * done whenever a contact is set to is_deleted=1 BUT I found create is already over-aggressive in
1084    * that regard so adding it to delete seems to be enough to remove it from CRM_Contact_BAO_Contact_Permission
1085    * where the call involved a subquery that was locking the table.
1086    *
1087    * @param int $contactID
1088    * @param bool $isTrashed
1089    */
1090   public static function updateContactCache($contactID, $isTrashed = FALSE) {
1091
1092     if ($isTrashed) {
1093       CRM_Contact_BAO_GroupContactCache::removeContact($contactID);
1094       // This has been moved to here from CRM_Contact_BAO_Contact_Permission as that was causing
1095       // a table-locking query. It still seems a bit inadequate as it assumes the acl users can't see deleted
1096       // but this should not cause any change as long as contacts are not being trashed outside the
1097       // main functions for that.
1098       CRM_Core_DAO::executeQuery('DELETE FROM civicrm_acl_contact_cache WHERE contact_id = %1', [1 => [$contactID, 'Integer']]);
1099     }
1100     else {
1101       CRM_Contact_BAO_GroupContactCache::opportunisticCacheFlush();
1102     }
1103   }
1104
1105   /**
1106    * Delete the image of a contact.
1107    *
1108    * @param int $id
1109    *   Id of the contact.
1110    *
1111    * @return bool
1112    *   Was contact image deleted?
1113    */
1114   public static function deleteContactImage($id) {
1115     if (!$id) {
1116       return FALSE;
1117     }
1118
1119     $contact = new self();
1120     $contact->id = $id;
1121     $contact->image_URL = 'null';
1122     $contact->save();
1123
1124     return TRUE;
1125   }
1126
1127   /**
1128    * Return proportional height and width of the image.
1129    *
1130    * @param int $imageWidth
1131    *   Width of image.
1132    *
1133    * @param int $imageHeight
1134    *   Height of image.
1135    *
1136    * @return array
1137    *   Thumb dimension of image
1138    */
1139   public static function getThumbSize($imageWidth, $imageHeight) {
1140     $thumbWidth = 100;
1141     if ($imageWidth && $imageHeight) {
1142       $imageRatio = $imageWidth / $imageHeight;
1143     }
1144     else {
1145       $imageRatio = 1;
1146     }
1147     if ($imageRatio > 1) {
1148       $imageThumbWidth = $thumbWidth;
1149       $imageThumbHeight = round($thumbWidth / $imageRatio);
1150     }
1151     else {
1152       $imageThumbHeight = $thumbWidth;
1153       $imageThumbWidth = round($thumbWidth * $imageRatio);
1154     }
1155
1156     return [$imageThumbWidth, $imageThumbHeight];
1157   }
1158
1159   /**
1160    * Validate type of contact image.
1161    *
1162    * @param array $params
1163    * @param string $imageIndex
1164    *   Index of image field.
1165    * @param string $statusMsg
1166    *   Status message to be set after operation.
1167    * @param string $opType
1168    *   Type of operation like fatal, bounce etc.
1169    *
1170    * @return bool
1171    *   true if valid image extension
1172    */
1173   public static function processImageParams(
1174     &$params,
1175     $imageIndex = 'image_URL',
1176     $statusMsg = NULL,
1177     $opType = 'status'
1178   ) {
1179     $mimeType = [
1180       'image/jpeg',
1181       'image/jpg',
1182       'image/png',
1183       'image/bmp',
1184       'image/p-jpeg',
1185       'image/gif',
1186       'image/x-png',
1187     ];
1188
1189     if (in_array($params[$imageIndex]['type'], $mimeType)) {
1190       $photo = basename($params[$imageIndex]['name']);
1191       $params[$imageIndex] = CRM_Utils_System::url('civicrm/contact/imagefile', 'photo=' . $photo, TRUE, NULL, TRUE, TRUE);
1192       return TRUE;
1193     }
1194     else {
1195       unset($params[$imageIndex]);
1196       if (!$statusMsg) {
1197         $statusMsg = ts('Image could not be uploaded due to invalid type extension.');
1198       }
1199       if ($opType == 'status') {
1200         CRM_Core_Session::setStatus($statusMsg, ts('Error'), 'error');
1201       }
1202       // FIXME: additional support for fatal, bounce etc could be added.
1203       return FALSE;
1204     }
1205   }
1206
1207   /**
1208    * Extract contact id from url for deleting contact image.
1209    */
1210   public static function processImage() {
1211
1212     $action = CRM_Utils_Request::retrieve('action', 'String');
1213     $cid = CRM_Utils_Request::retrieve('cid', 'Positive');
1214     // retrieve contact id in case of Profile context
1215     $id = CRM_Utils_Request::retrieve('id', 'Positive');
1216     $cid = $cid ? $cid : $id;
1217     if ($action & CRM_Core_Action::DELETE) {
1218       if (CRM_Utils_Request::retrieve('confirmed', 'Boolean')) {
1219         CRM_Contact_BAO_Contact::deleteContactImage($cid);
1220         CRM_Core_Session::setStatus(ts('Contact image deleted successfully'), ts('Image Deleted'), 'success');
1221         $session = CRM_Core_Session::singleton();
1222         $toUrl = $session->popUserContext();
1223         CRM_Utils_System::redirect($toUrl);
1224       }
1225     }
1226   }
1227
1228   /**
1229    * Function to set is_delete true or restore deleted contact.
1230    *
1231    * @param CRM_Contact_DAO_Contact $contact
1232    *   Contact DAO object.
1233    * @param bool $restore
1234    *   True to set the is_delete = 1 else false to restore deleted contact,
1235    *   i.e. is_delete = 0
1236    *
1237    * @deprecated
1238    *
1239    * @return bool
1240    * @throws \CRM_Core_Exception
1241    */
1242   public static function contactTrashRestore($contact, $restore = FALSE) {
1243     CRM_Core_Error::deprecatedFunctionWarning('Use the api');
1244
1245     if ($restore) {
1246       CRM_Core_Error::deprecatedFunctionWarning('Use contact.create to restore - this does nothing much');
1247       // @todo deprecate calling contactDelete with the intention to restore.
1248       $updateParams = [
1249         'id' => $contact->id,
1250         'is_deleted' => FALSE,
1251       ];
1252       self::create($updateParams);
1253       return TRUE;
1254     }
1255     return self::contactTrash($contact);
1256   }
1257
1258   /**
1259    * Get contact type for a contact.
1260    *
1261    * @param int $id
1262    *   Id of the contact whose contact type is needed.
1263    *
1264    * @return string
1265    *   contact_type if $id found else null ""
1266    */
1267   public static function getContactType($id) {
1268     return CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $id, 'contact_type');
1269   }
1270
1271   /**
1272    * Get contact sub type for a contact.
1273    *
1274    * @param int $id
1275    *   Id of the contact whose contact sub type is needed.
1276    *
1277    * @param string $implodeDelimiter
1278    *
1279    * @return string
1280    *   contact_sub_type if $id found else null ""
1281    */
1282   public static function getContactSubType($id, $implodeDelimiter = NULL) {
1283     $subtype = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $id, 'contact_sub_type');
1284     if (!$subtype) {
1285       return $implodeDelimiter ? NULL : [];
1286     }
1287
1288     $subtype = CRM_Utils_Array::explodePadded($subtype);
1289
1290     if ($implodeDelimiter) {
1291       $subtype = implode($implodeDelimiter, $subtype);
1292     }
1293     return $subtype;
1294   }
1295
1296   /**
1297    * Get pair of contact-type and sub-type for a contact.
1298    *
1299    * @param int $id
1300    *   Id of the contact whose contact sub/contact type is needed.
1301    *
1302    * @return array
1303    */
1304   public static function getContactTypes($id) {
1305     $params = ['id' => $id];
1306     $details = [];
1307     $contact = CRM_Core_DAO::commonRetrieve('CRM_Contact_DAO_Contact',
1308       $params,
1309       $details,
1310       ['contact_type', 'contact_sub_type']
1311     );
1312
1313     if ($contact) {
1314       $contactTypes = [];
1315       if ($contact->contact_sub_type) {
1316         $contactTypes = CRM_Utils_Array::explodePadded($contact->contact_sub_type);
1317       }
1318       array_unshift($contactTypes, $contact->contact_type);
1319
1320       return $contactTypes;
1321     }
1322     else {
1323       throw new CRM_Core_Exception();
1324     }
1325   }
1326
1327   /**
1328    * Combine all the importable fields from the lower levels object.
1329    *
1330    * The ordering is important, since currently we do not have a weight
1331    * scheme. Adding weight is super important
1332    *
1333    * @param int|string $contactType contact Type
1334    * @param bool $status
1335    *   Status is used to manipulate first title.
1336    * @param bool $showAll
1337    *   If true returns all fields (includes disabled fields).
1338    * @param bool $isProfile
1339    *   If its profile mode.
1340    * @param bool $checkPermission
1341    *   If false, do not include permissioning clause (for custom data).
1342    *
1343    * @param bool $withMultiCustomFields
1344    *
1345    * @return array
1346    *   array of importable Fields
1347    */
1348   public static function importableFields(
1349     $contactType = 'Individual',
1350     $status = FALSE,
1351     $showAll = FALSE,
1352     $isProfile = FALSE,
1353     $checkPermission = TRUE,
1354     $withMultiCustomFields = FALSE
1355   ) {
1356     if (empty($contactType)) {
1357       $contactType = 'All';
1358     }
1359
1360     $cacheKeyString = "importableFields $contactType";
1361     $cacheKeyString .= $status ? '_1' : '_0';
1362     $cacheKeyString .= $showAll ? '_1' : '_0';
1363     $cacheKeyString .= $isProfile ? '_1' : '_0';
1364     $cacheKeyString .= $checkPermission ? '_1' : '_0';
1365     $cacheKeyString .= '_' . CRM_Core_Config::domainID() . '_';
1366
1367     $fields = self::$_importableFields[$cacheKeyString] ?? Civi::cache('fields')->get($cacheKeyString);
1368
1369     if (!$fields) {
1370       $fields = CRM_Contact_DAO_Contact::import();
1371
1372       // get the fields thar are meant for contact types
1373       if (in_array($contactType, [
1374         'Individual',
1375         'Household',
1376         'Organization',
1377         'All',
1378       ])) {
1379         $fields = array_merge($fields, CRM_Core_OptionValue::getFields('', $contactType));
1380       }
1381
1382       $locationFields = array_merge(CRM_Core_DAO_Address::import(),
1383         CRM_Core_DAO_Phone::import(),
1384         CRM_Core_DAO_Email::import(),
1385         CRM_Core_DAO_IM::import(TRUE),
1386         CRM_Core_DAO_OpenID::import()
1387       );
1388
1389       $locationFields = array_merge($locationFields,
1390         CRM_Core_BAO_CustomField::getFieldsForImport('Address',
1391           FALSE,
1392           FALSE,
1393           FALSE,
1394           FALSE
1395         )
1396       );
1397
1398       foreach ($locationFields as $key => $field) {
1399         $locationFields[$key]['hasLocationType'] = TRUE;
1400       }
1401
1402       $fields = array_merge($fields, $locationFields);
1403
1404       $fields = array_merge($fields, CRM_Contact_DAO_Contact::import());
1405       $fields = array_merge($fields, CRM_Core_DAO_Note::import());
1406
1407       //website fields
1408       $fields = array_merge($fields, CRM_Core_DAO_Website::import());
1409       $fields['url']['hasWebsiteType'] = TRUE;
1410
1411       if ($contactType != 'All') {
1412         $fields = array_merge($fields,
1413           CRM_Core_BAO_CustomField::getFieldsForImport($contactType,
1414             $showAll,
1415             TRUE,
1416             FALSE,
1417             FALSE,
1418             $withMultiCustomFields
1419           )
1420         );
1421         // Unset the fields which are not related to their contact type.
1422         foreach (CRM_Contact_DAO_Contact::import() as $name => $value) {
1423           if (!empty($value['contactType']) && $value['contactType'] !== $contactType) {
1424             unset($fields[$name]);
1425           }
1426         }
1427       }
1428       else {
1429         foreach (CRM_Contact_BAO_ContactType::basicTypes() as $type) {
1430           $fields = array_merge($fields,
1431             CRM_Core_BAO_CustomField::getFieldsForImport($type,
1432               $showAll,
1433               FALSE,
1434               FALSE,
1435               FALSE,
1436               $withMultiCustomFields
1437             )
1438           );
1439         }
1440       }
1441
1442       if ($isProfile) {
1443         $fields = array_merge($fields, [
1444           'group' => [
1445             'title' => ts('Group(s)'),
1446             'name' => 'group',
1447           ],
1448           'tag' => [
1449             'title' => ts('Tag(s)'),
1450             'name' => 'tag',
1451           ],
1452           'note' => [
1453             'title' => ts('Note'),
1454             'name' => 'note',
1455           ],
1456           'communication_style_id' => [
1457             'title' => ts('Communication Style'),
1458             'name' => 'communication_style_id',
1459           ],
1460         ]);
1461       }
1462
1463       //Sorting fields in alphabetical order(CRM-1507)
1464       $fields = CRM_Utils_Array::crmArraySortByField($fields, 'title');
1465
1466       Civi::cache('fields')->set($cacheKeyString, $fields);
1467     }
1468
1469     self::$_importableFields[$cacheKeyString] = $fields;
1470
1471     if (!$isProfile) {
1472       if (!$status) {
1473         $fields = array_merge(['do_not_import' => ['title' => ts('- do not import -')]],
1474           self::$_importableFields[$cacheKeyString]
1475         );
1476       }
1477       else {
1478         $fields = array_merge(['' => ['title' => ts('- Contact Fields -')]],
1479           self::$_importableFields[$cacheKeyString]
1480         );
1481       }
1482     }
1483     return $fields;
1484   }
1485
1486   /**
1487    * Combine all the exportable fields from the lower levels object.
1488    *
1489    * Currently we are using importable fields as exportable fields
1490    *
1491    * @param int|string $contactType contact Type
1492    * @param bool $status
1493    *   True while exporting primary contacts.
1494    * @param bool $export
1495    *   True when used during export.
1496    * @param bool $search
1497    *   True when used during search, might conflict with export param?.
1498    *
1499    * @param bool $withMultiRecord
1500    * @param bool $checkPermissions
1501    *
1502    * @return array
1503    *   array of exportable Fields
1504    */
1505   public static function &exportableFields($contactType = 'Individual', $status = FALSE, $export = FALSE, $search = FALSE, $withMultiRecord = FALSE, $checkPermissions = TRUE) {
1506     if (empty($contactType)) {
1507       $contactType = 'All';
1508     }
1509
1510     $cacheKeyString = "exportableFields $contactType";
1511     $cacheKeyString .= $export ? '_1' : '_0';
1512     $cacheKeyString .= $status ? '_1' : '_0';
1513     $cacheKeyString .= $search ? '_1' : '_0';
1514     $cacheKeyString .= '_' . (bool) $checkPermissions;
1515     //CRM-14501 it turns out that the impact of permissioning here is sometimes inconsistent. The field that
1516     //calculates custom fields takes into account the logged in user & caches that for all users
1517     //as an interim fix we will cache the fields by contact
1518     $cacheKeyString .= '_' . CRM_Core_Session::getLoggedInContactID();
1519
1520     if (!self::$_exportableFields || empty(self::$_exportableFields[$cacheKeyString])) {
1521       if (!self::$_exportableFields) {
1522         self::$_exportableFields = [];
1523       }
1524
1525       // check if we can retrieve from database cache
1526       $fields = Civi::cache('fields')->get($cacheKeyString);
1527
1528       if (!$fields) {
1529         $fields = CRM_Contact_DAO_Contact::export();
1530
1531         // The fields are meant for contact types.
1532         if (in_array($contactType, [
1533           'Individual',
1534           'Household',
1535           'Organization',
1536           'All',
1537         ])) {
1538           $fields = array_merge($fields, CRM_Core_OptionValue::getFields('', $contactType));
1539         }
1540         // add current employer for individuals
1541         $fields = array_merge($fields, [
1542           'current_employer' =>
1543             [
1544               'name' => 'organization_name',
1545               'title' => ts('Current Employer'),
1546               'type' => CRM_Utils_Type::T_STRING,
1547             ],
1548         ]);
1549
1550         // This probably would be added anyway by appendPseudoConstantsToFields.
1551         $locationType = [
1552           'location_type' => [
1553             'name' => 'location_type',
1554             'where' => 'civicrm_location_type.name',
1555             'title' => ts('Location Type'),
1556             'type' => CRM_Utils_Type::T_STRING,
1557           ],
1558         ];
1559
1560         $IMProvider = [
1561           'im_provider' => [
1562             'name' => 'im_provider',
1563             'where' => 'civicrm_im.provider_id',
1564             'title' => ts('IM Provider'),
1565             'type' => CRM_Utils_Type::T_STRING,
1566           ],
1567         ];
1568
1569         $phoneFields = CRM_Core_DAO_Phone::export();
1570         // This adds phone_type to the exportable fields and make it available for export.
1571         // with testing the same can be done to the other entities.
1572         CRM_Core_DAO::appendPseudoConstantsToFields($phoneFields);
1573         $locationFields = array_merge($locationType,
1574           CRM_Core_DAO_Address::export(),
1575           $phoneFields,
1576           CRM_Core_DAO_Email::export(),
1577           $IMProvider,
1578           CRM_Core_DAO_IM::export(TRUE),
1579           CRM_Core_DAO_OpenID::export()
1580         );
1581
1582         $locationFields = array_merge($locationFields,
1583           CRM_Core_BAO_CustomField::getFieldsForImport('Address')
1584         );
1585
1586         foreach ($locationFields as $key => $field) {
1587           $locationFields[$key]['hasLocationType'] = TRUE;
1588         }
1589
1590         $fields = array_merge($fields, $locationFields);
1591
1592         //add world region
1593         $fields = array_merge($fields,
1594           CRM_Core_DAO_Worldregion::export()
1595         );
1596
1597         $fields = array_merge($fields,
1598           CRM_Contact_DAO_Contact::export()
1599         );
1600
1601         //website fields
1602         $fields = array_merge($fields, CRM_Core_DAO_Website::export());
1603
1604         if ($contactType != 'All') {
1605           $fields = array_merge($fields,
1606             CRM_Core_BAO_CustomField::getFieldsForImport($contactType, $status, FALSE, $search, $checkPermissions, $withMultiRecord)
1607           );
1608         }
1609         else {
1610           foreach (CRM_Contact_BAO_ContactType::basicTypes() as $type) {
1611             $fields = array_merge($fields,
1612               CRM_Core_BAO_CustomField::getFieldsForImport($type, FALSE, FALSE, $search, $checkPermissions, $withMultiRecord)
1613             );
1614           }
1615         }
1616         //fix for CRM-791
1617         if ($export) {
1618           $fields = array_merge($fields, [
1619             'groups' => [
1620               'title' => ts('Group(s)'),
1621               'name' => 'groups',
1622             ],
1623             'tags' => [
1624               'title' => ts('Tag(s)'),
1625               'name' => 'tags',
1626             ],
1627             'notes' => [
1628               'title' => ts('Note(s)'),
1629               'name' => 'notes',
1630             ],
1631           ]);
1632         }
1633         else {
1634           $fields = array_merge($fields, [
1635             'group' => [
1636               'title' => ts('Group(s)'),
1637               'name' => 'group',
1638             ],
1639             'tag' => [
1640               'title' => ts('Tag(s)'),
1641               'name' => 'tag',
1642             ],
1643             'note' => [
1644               'title' => ts('Note(s)'),
1645               'name' => 'note',
1646             ],
1647           ]);
1648         }
1649
1650         //Sorting fields in alphabetical order(CRM-1507)
1651         foreach ($fields as $k => $v) {
1652           $sortArray[$k] = $v['title'] ?? NULL;
1653         }
1654
1655         $fields = array_merge($sortArray, $fields);
1656         //unset the field which are not related to their contact type.
1657         if ($contactType != 'All') {
1658           $commonValues = [
1659             'Individual' => [
1660               'household_name',
1661               'legal_name',
1662               'sic_code',
1663               'organization_name',
1664               'email_greeting_custom',
1665               'postal_greeting_custom',
1666               'addressee_custom',
1667             ],
1668             'Household' => [
1669               'first_name',
1670               'middle_name',
1671               'last_name',
1672               'formal_title',
1673               'job_title',
1674               'gender_id',
1675               'prefix_id',
1676               'suffix_id',
1677               'birth_date',
1678               'organization_name',
1679               'legal_name',
1680               'legal_identifier',
1681               'sic_code',
1682               'home_URL',
1683               'is_deceased',
1684               'deceased_date',
1685               'current_employer',
1686               'email_greeting_custom',
1687               'postal_greeting_custom',
1688               'addressee_custom',
1689               'prefix_id',
1690               'suffix_id',
1691             ],
1692             'Organization' => [
1693               'first_name',
1694               'middle_name',
1695               'last_name',
1696               'formal_title',
1697               'job_title',
1698               'gender_id',
1699               'prefix_id',
1700               'suffix_id',
1701               'birth_date',
1702               'household_name',
1703               'email_greeting_custom',
1704               'postal_greeting_custom',
1705               'prefix_id',
1706               'suffix_id',
1707               'gender_id',
1708               'addressee_custom',
1709               'is_deceased',
1710               'deceased_date',
1711               'current_employer',
1712             ],
1713           ];
1714           foreach ($commonValues[$contactType] as $value) {
1715             unset($fields[$value]);
1716           }
1717         }
1718
1719         Civi::cache('fields')->set($cacheKeyString, $fields);
1720       }
1721       self::$_exportableFields[$cacheKeyString] = $fields;
1722     }
1723
1724     if (!$status) {
1725       $fields = self::$_exportableFields[$cacheKeyString];
1726     }
1727     else {
1728       $fields = array_merge(['' => ['title' => ts('- Contact Fields -')]],
1729         self::$_exportableFields[$cacheKeyString]
1730       );
1731     }
1732
1733     return $fields;
1734   }
1735
1736   /**
1737    * Get the all contact details (Hierarchical).
1738    *
1739    * @param int $contactId
1740    *   Contact id.
1741    * @param array $fields
1742    *   Fields array.
1743    *
1744    * @return array
1745    *   Contact details
1746    */
1747   public static function getHierContactDetails($contactId, $fields) {
1748     $params = [['contact_id', '=', $contactId, 0, 0]];
1749
1750     $returnProperties = self::makeHierReturnProperties($fields, $contactId);
1751
1752     // We don't know the contents of return properties, but we need the lower
1753     // level ids of the contact so add a few fields.
1754     $returnProperties['first_name'] = 1;
1755     $returnProperties['organization_name'] = 1;
1756     $returnProperties['household_name'] = 1;
1757     $returnProperties['contact_type'] = 1;
1758     $returnProperties['contact_sub_type'] = 1;
1759     list($query) = CRM_Contact_BAO_Query::apiQuery($params, $returnProperties);
1760     return $query;
1761   }
1762
1763   /**
1764    * Given a set of flat profile style field names, create a hierarchy.
1765    *
1766    * This is for the query to use, create the right sql.
1767    *
1768    * @param $fields
1769    * @param int $contactId
1770    *   Contact id.
1771    *
1772    * @return array
1773    *   A hierarchical property tree if appropriate
1774    */
1775   public static function &makeHierReturnProperties($fields, $contactId = NULL) {
1776     $locationTypes = CRM_Core_BAO_Address::buildOptions('location_type_id', 'validate');
1777
1778     $returnProperties = [];
1779
1780     $multipleFields = ['website' => 'url'];
1781     foreach ($fields as $name => $dontCare) {
1782       if (strpos($name, '-') !== FALSE) {
1783         list($fieldName, $id, $type) = CRM_Utils_System::explode('-', $name, 3);
1784
1785         if (!in_array($fieldName, $multipleFields)) {
1786           if ($id == 'Primary') {
1787             $locationTypeName = 1;
1788           }
1789           else {
1790             $locationTypeName = $locationTypes[$id] ?? NULL;
1791             if (!$locationTypeName) {
1792               continue;
1793             }
1794           }
1795
1796           if (empty($returnProperties['location'])) {
1797             $returnProperties['location'] = [];
1798           }
1799           if (empty($returnProperties['location'][$locationTypeName])) {
1800             $returnProperties['location'][$locationTypeName] = [];
1801             $returnProperties['location'][$locationTypeName]['location_type'] = $id;
1802           }
1803           if (in_array($fieldName, [
1804             'phone',
1805             'im',
1806             'email',
1807             'openid',
1808             'phone_ext',
1809           ])) {
1810             if ($type) {
1811               $returnProperties['location'][$locationTypeName][$fieldName . '-' . $type] = 1;
1812             }
1813             else {
1814               $returnProperties['location'][$locationTypeName][$fieldName] = 1;
1815             }
1816           }
1817           elseif (substr($fieldName, 0, 14) === 'address_custom') {
1818             $returnProperties['location'][$locationTypeName][substr($fieldName, 8)] = 1;
1819           }
1820           else {
1821             $returnProperties['location'][$locationTypeName][$fieldName] = 1;
1822           }
1823         }
1824         else {
1825           $returnProperties['website'][$id][$fieldName] = 1;
1826         }
1827       }
1828       else {
1829         $returnProperties[$name] = 1;
1830       }
1831     }
1832
1833     return $returnProperties;
1834   }
1835
1836   /**
1837    * Return the primary location type of a contact.
1838    *
1839    * $params int     $contactId contact_id
1840    * $params boolean $isPrimaryExist if true, return primary contact location type otherwise null
1841    * $params boolean $skipDefaultPriamry if true, return primary contact location type otherwise null
1842    *
1843    * @param int $contactId
1844    * @param bool $skipDefaultPriamry
1845    * @param null $block
1846    *
1847    * @return int
1848    *   $locationType location_type_id
1849    */
1850   public static function getPrimaryLocationType($contactId, $skipDefaultPriamry = FALSE, $block = NULL) {
1851     if ($block) {
1852       $entityBlock = ['contact_id' => $contactId];
1853       $blocks = CRM_Core_BAO_Location::getValues($entityBlock);
1854       foreach ($blocks[$block] as $key => $value) {
1855         if (!empty($value['is_primary'])) {
1856           $locationType = $value['location_type_id'] ?? NULL;
1857         }
1858       }
1859     }
1860     else {
1861       $query = "
1862 SELECT
1863  IF ( civicrm_email.location_type_id IS NULL,
1864     IF ( civicrm_address.location_type_id IS NULL,
1865         IF ( civicrm_phone.location_type_id IS NULL,
1866            IF ( civicrm_im.location_type_id IS NULL,
1867                IF ( civicrm_openid.location_type_id IS NULL, null, civicrm_openid.location_type_id)
1868            ,civicrm_im.location_type_id)
1869         ,civicrm_phone.location_type_id)
1870      ,civicrm_address.location_type_id)
1871   ,civicrm_email.location_type_id)  as locationType
1872 FROM civicrm_contact
1873      LEFT JOIN civicrm_email   ON ( civicrm_email.is_primary   = 1 AND civicrm_email.contact_id = civicrm_contact.id )
1874      LEFT JOIN civicrm_address ON ( civicrm_address.is_primary = 1 AND civicrm_address.contact_id = civicrm_contact.id)
1875      LEFT JOIN civicrm_phone   ON ( civicrm_phone.is_primary   = 1 AND civicrm_phone.contact_id = civicrm_contact.id)
1876      LEFT JOIN civicrm_im      ON ( civicrm_im.is_primary      = 1 AND civicrm_im.contact_id = civicrm_contact.id)
1877      LEFT JOIN civicrm_openid  ON ( civicrm_openid.is_primary  = 1 AND civicrm_openid.contact_id = civicrm_contact.id)
1878 WHERE  civicrm_contact.id = %1 ";
1879
1880       $params = [1 => [$contactId, 'Integer']];
1881
1882       $dao = CRM_Core_DAO::executeQuery($query, $params);
1883
1884       $locationType = NULL;
1885       if ($dao->fetch()) {
1886         $locationType = $dao->locationType;
1887       }
1888     }
1889     if (isset($locationType)) {
1890       return $locationType;
1891     }
1892     elseif ($skipDefaultPriamry) {
1893       // if there is no primary contact location then return null
1894       return NULL;
1895     }
1896     else {
1897       // if there is no primart contact location, then return default
1898       // location type of the system
1899       $defaultLocationType = CRM_Core_BAO_LocationType::getDefault();
1900       return $defaultLocationType->id;
1901     }
1902   }
1903
1904   /**
1905    * Get the display name, primary email and location type of a contact.
1906    *
1907    * @param int $id
1908    *   Id of the contact.
1909    *
1910    * @return array
1911    *   Array of display_name, email if found, do_not_email or (null,null,null)
1912    */
1913   public static function getContactDetails($id) {
1914     // check if the contact type
1915     $contactType = self::getContactType($id);
1916
1917     $nameFields = ($contactType == 'Individual') ? "civicrm_contact.first_name, civicrm_contact.last_name, civicrm_contact.display_name" : "civicrm_contact.display_name";
1918
1919     $sql = "
1920 SELECT $nameFields, civicrm_email.email, civicrm_contact.do_not_email, civicrm_email.on_hold, civicrm_contact.is_deceased
1921 FROM   civicrm_contact LEFT JOIN civicrm_email ON (civicrm_contact.id = civicrm_email.contact_id)
1922 WHERE  civicrm_contact.id = %1
1923 ORDER BY civicrm_email.is_primary DESC";
1924     $params = [1 => [$id, 'Integer']];
1925     $dao = CRM_Core_DAO::executeQuery($sql, $params);
1926
1927     if ($dao->fetch()) {
1928       if ($contactType == 'Individual') {
1929         if ($dao->first_name || $dao->last_name) {
1930           $name = "{$dao->first_name} {$dao->last_name}";
1931         }
1932         else {
1933           $name = $dao->display_name;
1934         }
1935       }
1936       else {
1937         $name = $dao->display_name;
1938       }
1939       $email = $dao->email;
1940       $doNotEmail = (bool) $dao->do_not_email;
1941       $onHold = (bool) $dao->on_hold;
1942       $isDeceased = (bool) $dao->is_deceased;
1943       return [$name, $email, $doNotEmail, $onHold, $isDeceased];
1944     }
1945     return [NULL, NULL, NULL, NULL, NULL];
1946   }
1947
1948   /**
1949    * Add/edit/register contacts through profile.
1950    *
1951    * @param array $params
1952    *   Array of profile fields to be edited/added.
1953    * @param array $fields
1954    *   Array of fields from UFGroup.
1955    * @param int $contactID
1956    *   Id of the contact to be edited/added.
1957    * @param int $addToGroupID
1958    *   Specifies the default group to which contact is added.
1959    * @param int $ufGroupId
1960    *   Uf group id (profile id).
1961    * @param string $ctype
1962    * @param bool $visibility
1963    *   Basically lets us know where this request is coming from.
1964    *                                if via a profile from web, we restrict what groups are changed
1965    *
1966    * @return int
1967    *   contact id created/edited
1968    *
1969    * @throws \CRM_Core_Exception
1970    * @throws \CiviCRM_API3_Exception
1971    * @throws \Civi\API\Exception\UnauthorizedException
1972    */
1973   public static function createProfileContact(
1974     &$params,
1975     $fields = [],
1976     $contactID = NULL,
1977     $addToGroupID = NULL,
1978     $ufGroupId = NULL,
1979     $ctype = NULL,
1980     $visibility = FALSE
1981   ) {
1982     // add ufGroupID to params array ( CRM-2012 )
1983     if ($ufGroupId) {
1984       $params['uf_group_id'] = $ufGroupId;
1985     }
1986     self::addBillingNameFieldsIfOtherwiseNotSet($params);
1987
1988     // If a user has logged in, or accessed via a checksum
1989     // Then deliberately 'blanking' a value in the profile should remove it from their record
1990     $session = CRM_Core_Session::singleton();
1991     $params['updateBlankLocInfo'] = TRUE;
1992     if (($session->get('authSrc') & (CRM_Core_Permission::AUTH_SRC_CHECKSUM + CRM_Core_Permission::AUTH_SRC_LOGIN)) == 0) {
1993       $params['updateBlankLocInfo'] = FALSE;
1994     }
1995
1996     if ($contactID) {
1997       $editHook = TRUE;
1998       CRM_Utils_Hook::pre('edit', 'Profile', $contactID, $params);
1999     }
2000     else {
2001       $editHook = FALSE;
2002       CRM_Utils_Hook::pre('create', 'Profile', NULL, $params);
2003     }
2004
2005     list($data, $contactDetails) = self::formatProfileContactParams($params, $fields, $contactID, $ufGroupId, $ctype);
2006
2007     // manage is_opt_out
2008     if (array_key_exists('is_opt_out', $fields) && array_key_exists('is_opt_out', $params)) {
2009       $wasOptOut = $contactDetails['is_opt_out'] ?? FALSE;
2010       $isOptOut = $params['is_opt_out'];
2011       $data['is_opt_out'] = $isOptOut;
2012       // on change, create new civicrm_subscription_history entry
2013       if (($wasOptOut != $isOptOut) && !empty($contactDetails['contact_id'])) {
2014         $shParams = [
2015           'contact_id' => $contactDetails['contact_id'],
2016           'status' => $isOptOut ? 'Removed' : 'Added',
2017           'method' => 'Web',
2018         ];
2019         CRM_Contact_BAO_SubscriptionHistory::create($shParams);
2020       }
2021     }
2022
2023     $contact = self::create($data);
2024
2025     // contact is null if the profile does not have any contact fields
2026     if ($contact) {
2027       $contactID = $contact->id;
2028     }
2029
2030     if (empty($contactID)) {
2031       throw new CRM_Core_Exception('Cannot proceed without a valid contact id');
2032     }
2033
2034     // Process group and tag
2035     if (isset($params['group'])) {
2036       $method = 'Admin';
2037       // this for sure means we are coming in via profile since i added it to fix
2038       // removing contacts from user groups -- lobo
2039       if ($visibility) {
2040         $method = 'Web';
2041       }
2042       CRM_Contact_BAO_GroupContact::create($params['group'], $contactID, $visibility, $method);
2043     }
2044
2045     if (!empty($fields['tag']) && array_key_exists('tag', $params)) {
2046       // Convert comma separated form values from select2 v3
2047       $tags = is_array($params['tag']) ? $params['tag'] : array_fill_keys(array_filter(explode(',', $params['tag'])), 1);
2048       CRM_Core_BAO_EntityTag::create($tags, 'civicrm_contact', $contactID);
2049     }
2050
2051     //to add profile in default group
2052     if (is_array($addToGroupID)) {
2053       $contactIds = [$contactID];
2054       foreach ($addToGroupID as $groupId) {
2055         CRM_Contact_BAO_GroupContact::addContactsToGroup($contactIds, $groupId);
2056       }
2057     }
2058     elseif ($addToGroupID) {
2059       $contactIds = [$contactID];
2060       CRM_Contact_BAO_GroupContact::addContactsToGroup($contactIds, $addToGroupID);
2061     }
2062
2063     if ($editHook) {
2064       CRM_Utils_Hook::post('edit', 'Profile', $contactID, $params);
2065     }
2066     else {
2067       CRM_Utils_Hook::post('create', 'Profile', $contactID, $params);
2068     }
2069     return $contactID;
2070   }
2071
2072   /**
2073    * Format profile contact parameters.
2074    *
2075    * @param array $params
2076    * @param $fields
2077    * @param int $contactID
2078    * @param int $ufGroupId
2079    * @param null $ctype
2080    * @param bool $skipCustom
2081    *
2082    * @return array
2083    */
2084   public static function formatProfileContactParams(
2085     &$params,
2086     $fields,
2087     $contactID = NULL,
2088     $ufGroupId = NULL,
2089     $ctype = NULL,
2090     $skipCustom = FALSE
2091   ) {
2092
2093     $data = $contactDetails = [];
2094
2095     // get the contact details (hier)
2096     if ($contactID) {
2097       $details = self::getHierContactDetails($contactID, $fields);
2098
2099       $contactDetails = $details[$contactID];
2100       $data['contact_type'] = $contactDetails['contact_type'] ?? NULL;
2101       $data['contact_sub_type'] = $contactDetails['contact_sub_type'] ?? NULL;
2102     }
2103     else {
2104       //we should get contact type only if contact
2105       if ($ufGroupId) {
2106         $data['contact_type'] = CRM_Core_BAO_UFField::getProfileType($ufGroupId);
2107
2108         //special case to handle profile with only contact fields
2109         if ($data['contact_type'] == 'Contact') {
2110           $data['contact_type'] = 'Individual';
2111         }
2112         elseif (CRM_Contact_BAO_ContactType::isaSubType($data['contact_type'])) {
2113           $data['contact_type'] = CRM_Contact_BAO_ContactType::getBasicType($data['contact_type']);
2114         }
2115       }
2116       elseif ($ctype) {
2117         $data['contact_type'] = $ctype;
2118       }
2119       else {
2120         $data['contact_type'] = 'Individual';
2121       }
2122     }
2123
2124     //fix contact sub type CRM-5125
2125     if (array_key_exists('contact_sub_type', $params) &&
2126       !empty($params['contact_sub_type'])
2127     ) {
2128       $data['contact_sub_type'] = CRM_Utils_Array::implodePadded($params['contact_sub_type']);
2129     }
2130     elseif (array_key_exists('contact_sub_type_hidden', $params) &&
2131       !empty($params['contact_sub_type_hidden'])
2132     ) {
2133       // if profile was used, and had any subtype, we obtain it from there
2134       //CRM-13596 - add to existing contact types, rather than overwriting
2135       if (empty($data['contact_sub_type'])) {
2136         // If we don't have a contact ID the $data['contact_sub_type'] will not be defined...
2137         $data['contact_sub_type'] = CRM_Utils_Array::implodePadded($params['contact_sub_type_hidden']);
2138       }
2139       else {
2140         $data_contact_sub_type_arr = CRM_Utils_Array::explodePadded($data['contact_sub_type']);
2141         if (!in_array($params['contact_sub_type_hidden'], $data_contact_sub_type_arr)) {
2142           //CRM-20517 - make sure contact_sub_type gets the correct delimiters
2143           $data['contact_sub_type'] = trim($data['contact_sub_type'], CRM_Core_DAO::VALUE_SEPARATOR);
2144           $data['contact_sub_type'] = CRM_Core_DAO::VALUE_SEPARATOR . $data['contact_sub_type'] . CRM_Utils_Array::implodePadded($params['contact_sub_type_hidden']);
2145         }
2146       }
2147     }
2148
2149     if ($ctype == 'Organization') {
2150       $data['organization_name'] = $contactDetails['organization_name'] ?? NULL;
2151     }
2152     elseif ($ctype == 'Household') {
2153       $data['household_name'] = $contactDetails['household_name'] ?? NULL;
2154     }
2155
2156     $locationType = [];
2157     $count = 1;
2158
2159     if ($contactID) {
2160       //add contact id
2161       $data['contact_id'] = $contactID;
2162       $primaryLocationType = self::getPrimaryLocationType($contactID);
2163     }
2164     else {
2165       $defaultLocation = CRM_Core_BAO_LocationType::getDefault();
2166       $defaultLocationId = $defaultLocation->id;
2167     }
2168
2169     $billingLocationTypeId = CRM_Core_BAO_LocationType::getBilling();
2170
2171     $blocks = ['email', 'phone', 'im', 'openid'];
2172
2173     $multiplFields = ['url'];
2174     // prevent overwritten of formatted array, reset all block from
2175     // params if it is not in valid format (since import pass valid format)
2176     foreach ($blocks as $blk) {
2177       if (array_key_exists($blk, $params) &&
2178         !is_array($params[$blk])
2179       ) {
2180         unset($params[$blk]);
2181       }
2182     }
2183
2184     $primaryPhoneLoc = NULL;
2185     $session = CRM_Core_Session::singleton();
2186     foreach ($params as $key => $value) {
2187       list($fieldName, $locTypeId, $typeId) = CRM_Utils_System::explode('-', $key, 3);
2188
2189       if ($locTypeId == 'Primary') {
2190         if ($contactID) {
2191           if (in_array($fieldName, $blocks)) {
2192             $locTypeId = self::getPrimaryLocationType($contactID, FALSE, $fieldName);
2193           }
2194           else {
2195             $locTypeId = self::getPrimaryLocationType($contactID, FALSE, 'address');
2196           }
2197           $primaryLocationType = $locTypeId;
2198         }
2199         else {
2200           $locTypeId = $defaultLocationId;
2201         }
2202       }
2203
2204       if (is_numeric($locTypeId) &&
2205         !in_array($fieldName, $multiplFields) &&
2206         substr($fieldName, 0, 7) != 'custom_'
2207       ) {
2208         $index = $locTypeId;
2209
2210         if (is_numeric($typeId)) {
2211           $index .= '-' . $typeId;
2212         }
2213         if (!in_array($index, $locationType)) {
2214           $locationType[$count] = $index;
2215           $count++;
2216         }
2217
2218         $loc = CRM_Utils_Array::key($index, $locationType);
2219
2220         $blockName = self::getLocationEntityForKey($fieldName);
2221
2222         $data[$blockName][$loc]['location_type_id'] = $locTypeId;
2223
2224         //set is_billing true, for location type "Billing"
2225         if ($locTypeId == $billingLocationTypeId) {
2226           $data[$blockName][$loc]['is_billing'] = 1;
2227         }
2228
2229         if ($contactID) {
2230           //get the primary location type
2231           if ($locTypeId == $primaryLocationType) {
2232             $data[$blockName][$loc]['is_primary'] = 1;
2233           }
2234         }
2235         elseif ($locTypeId == $defaultLocationId) {
2236           $data[$blockName][$loc]['is_primary'] = 1;
2237         }
2238
2239         if (in_array($fieldName, ['phone'])) {
2240           if ($typeId) {
2241             $data['phone'][$loc]['phone_type_id'] = $typeId;
2242           }
2243           else {
2244             $data['phone'][$loc]['phone_type_id'] = '';
2245           }
2246           $data['phone'][$loc]['phone'] = $value;
2247
2248           //special case to handle primary phone with different phone types
2249           // in this case we make first phone type as primary
2250           if (isset($data['phone'][$loc]['is_primary']) && !$primaryPhoneLoc) {
2251             $primaryPhoneLoc = $loc;
2252           }
2253
2254           if ($loc != $primaryPhoneLoc) {
2255             unset($data['phone'][$loc]['is_primary']);
2256           }
2257         }
2258         elseif ($fieldName == 'email') {
2259           $data['email'][$loc]['email'] = $value;
2260           if (empty($contactID)) {
2261             $data['email'][$loc]['is_primary'] = 1;
2262           }
2263         }
2264         elseif ($fieldName == 'im') {
2265           if (isset($params[$key . '-provider_id'])) {
2266             $data['im'][$loc]['provider_id'] = $params[$key . '-provider_id'];
2267           }
2268           if (strpos($key, '-provider_id') !== FALSE) {
2269             $data['im'][$loc]['provider_id'] = $params[$key];
2270           }
2271           else {
2272             $data['im'][$loc]['name'] = $value;
2273           }
2274         }
2275         elseif ($fieldName == 'openid') {
2276           $data['openid'][$loc]['openid'] = $value;
2277         }
2278         else {
2279           if ($fieldName === 'state_province') {
2280             // CRM-3393
2281             if (is_numeric($value) && ((int ) $value) >= 1000) {
2282               $data['address'][$loc]['state_province_id'] = $value;
2283             }
2284             elseif (empty($value)) {
2285               $data['address'][$loc]['state_province_id'] = '';
2286             }
2287             else {
2288               $data['address'][$loc]['state_province'] = $value;
2289             }
2290           }
2291           elseif ($fieldName === 'country') {
2292             // CRM-3393
2293             if (is_numeric($value) && ((int ) $value) >= 1000
2294             ) {
2295               $data['address'][$loc]['country_id'] = $value;
2296             }
2297             elseif (empty($value)) {
2298               $data['address'][$loc]['country_id'] = '';
2299             }
2300             else {
2301               $data['address'][$loc]['country'] = $value;
2302             }
2303           }
2304           elseif ($fieldName === 'county') {
2305             $data['address'][$loc]['county_id'] = $value;
2306           }
2307           elseif ($fieldName == 'address_name') {
2308             $data['address'][$loc]['name'] = $value;
2309           }
2310           elseif (substr($fieldName, 0, 14) === 'address_custom') {
2311             $data['address'][$loc][substr($fieldName, 8)] = $value;
2312           }
2313           else {
2314             $data[$blockName][$loc][$fieldName] = $value;
2315           }
2316         }
2317       }
2318       else {
2319         if (substr($key, 0, 4) === 'url-') {
2320           $websiteField = explode('-', $key);
2321           $data['website'][$websiteField[1]]['website_type_id'] = $websiteField[1];
2322           $data['website'][$websiteField[1]]['url'] = $value;
2323         }
2324         elseif (in_array($key, self::$_greetingTypes, TRUE)) {
2325           //save email/postal greeting and addressee values if any, CRM-4575
2326           $data[$key . '_id'] = $value;
2327         }
2328         elseif (!$skipCustom && ($customFieldId = CRM_Core_BAO_CustomField::getKeyID($key))) {
2329           // for autocomplete transfer hidden value instead of label
2330           if ($params[$key] && isset($params[$key . '_id'])) {
2331             $value = $params[$key . '_id'];
2332           }
2333
2334           // we need to append time with date
2335           if ($params[$key] && isset($params[$key . '_time'])) {
2336             $value .= ' ' . $params[$key . '_time'];
2337           }
2338
2339           // if auth source is not checksum / login && $value is blank, do not proceed - CRM-10128
2340           if (($session->get('authSrc') & (CRM_Core_Permission::AUTH_SRC_CHECKSUM + CRM_Core_Permission::AUTH_SRC_LOGIN)) == 0 &&
2341             ($value == '' || !isset($value))
2342           ) {
2343             continue;
2344           }
2345
2346           $valueId = NULL;
2347           if (!empty($params['customRecordValues'])) {
2348             if (is_array($params['customRecordValues']) && !empty($params['customRecordValues'])) {
2349               foreach ($params['customRecordValues'] as $recId => $customFields) {
2350                 if (is_array($customFields) && !empty($customFields)) {
2351                   foreach ($customFields as $customFieldName) {
2352                     if ($customFieldName == $key) {
2353                       $valueId = $recId;
2354                       break;
2355                     }
2356                   }
2357                 }
2358               }
2359             }
2360           }
2361
2362           //CRM-13596 - check for contact_sub_type_hidden first
2363           if (array_key_exists('contact_sub_type_hidden', $params)) {
2364             $type = $params['contact_sub_type_hidden'];
2365           }
2366           else {
2367             $type = $data['contact_type'];
2368             if (!empty($data['contact_sub_type'])) {
2369               $type = CRM_Utils_Array::explodePadded($data['contact_sub_type']);
2370             }
2371           }
2372
2373           CRM_Core_BAO_CustomField::formatCustomField($customFieldId,
2374             $data['custom'],
2375             $value,
2376             $type,
2377             $valueId,
2378             $contactID,
2379             FALSE,
2380             FALSE
2381           );
2382         }
2383         elseif ($key === 'edit') {
2384           continue;
2385         }
2386         else {
2387           if ($key === 'location') {
2388             foreach ($value as $locationTypeId => $field) {
2389               foreach ($field as $block => $val) {
2390                 if ($block === 'address' && array_key_exists('address_name', $val)) {
2391                   $value[$locationTypeId][$block]['name'] = $value[$locationTypeId][$block]['address_name'];
2392                 }
2393               }
2394             }
2395           }
2396           if ($key === 'phone' && isset($params['phone_ext'])) {
2397             $data[$key] = $value;
2398             foreach ($value as $cnt => $phoneBlock) {
2399               if ($params[$key][$cnt]['location_type_id'] == $params['phone_ext'][$cnt]['location_type_id']) {
2400                 $data[$key][$cnt]['phone_ext'] = CRM_Utils_Array::retrieveValueRecursive($params['phone_ext'][$cnt], 'phone_ext');
2401               }
2402             }
2403           }
2404           elseif (in_array($key, ['nick_name', 'job_title', 'middle_name', 'birth_date', 'gender_id', 'current_employer', 'prefix_id', 'suffix_id'])
2405             && ($value == '' || !isset($value)) &&
2406             ($session->get('authSrc') & (CRM_Core_Permission::AUTH_SRC_CHECKSUM + CRM_Core_Permission::AUTH_SRC_LOGIN)) == 0 ||
2407             ($key === 'current_employer' && empty($params['current_employer']))) {
2408             // CRM-10128: if auth source is not checksum / login && $value is blank, do not fill $data with empty value
2409             // to avoid update with empty values
2410             continue;
2411           }
2412           else {
2413             $data[$key] = $value;
2414           }
2415         }
2416       }
2417     }
2418
2419     if (!isset($data['contact_type'])) {
2420       $data['contact_type'] = 'Individual';
2421     }
2422
2423     //set the values for checkboxes (do_not_email, do_not_mail, do_not_trade, do_not_phone)
2424     $privacy = CRM_Core_SelectValues::privacy();
2425     foreach ($privacy as $key => $value) {
2426       if (array_key_exists($key, $fields)) {
2427         // do not reset values for existing contacts, if fields are added to a profile
2428         if (array_key_exists($key, $params)) {
2429           $data[$key] = $params[$key];
2430           if (empty($params[$key])) {
2431             $data[$key] = 0;
2432           }
2433         }
2434         elseif (!$contactID) {
2435           $data[$key] = 0;
2436         }
2437       }
2438     }
2439
2440     return [$data, $contactDetails];
2441   }
2442
2443   /**
2444    * Find the get contact details.
2445    *
2446    * This function does not respect ACLs for now, which might need to be rectified at some
2447    * stage based on how its used.
2448    *
2449    * @param string $mail
2450    *   Primary email address of the contact.
2451    * @param string $ctype
2452    *   Contact type.
2453    *
2454    * @return object|null
2455    *   $dao contact details
2456    */
2457   public static function matchContactOnEmail($mail, $ctype = NULL) {
2458     $strtolower = function_exists('mb_strtolower') ? 'mb_strtolower' : 'strtolower';
2459     $mail = $strtolower(trim($mail));
2460     $query = "
2461 SELECT     civicrm_contact.id as contact_id,
2462            civicrm_contact.hash as hash,
2463            civicrm_contact.contact_type as contact_type,
2464            civicrm_contact.contact_sub_type as contact_sub_type
2465 FROM       civicrm_contact
2466 INNER JOIN civicrm_email    ON ( civicrm_contact.id = civicrm_email.contact_id )";
2467
2468     if (Civi::settings()->get('uniq_email_per_site')) {
2469       // try to find a match within a site (multisite).
2470       $groups = CRM_Core_BAO_Domain::getChildGroupIds();
2471       if (!empty($groups)) {
2472         $query .= "
2473 INNER JOIN civicrm_group_contact gc ON
2474 (civicrm_contact.id = gc.contact_id AND gc.status = 'Added' AND gc.group_id IN (" . implode(',', $groups) . "))";
2475       }
2476     }
2477
2478     $query .= "
2479 WHERE      civicrm_email.email = %1 AND civicrm_contact.is_deleted=0";
2480     $p = [1 => [$mail, 'String']];
2481
2482     if ($ctype) {
2483       $query .= " AND civicrm_contact.contact_type = %3";
2484       $p[3] = [$ctype, 'String'];
2485     }
2486
2487     $query .= " ORDER BY civicrm_email.is_primary DESC";
2488
2489     $dao = CRM_Core_DAO::executeQuery($query, $p);
2490
2491     if ($dao->fetch()) {
2492       return $dao;
2493     }
2494     return NULL;
2495   }
2496
2497   /**
2498    * Find the contact details associated with an OpenID.
2499    *
2500    * @param string $openId
2501    *   OpenId of the contact.
2502    * @param string $ctype
2503    *   Contact type.
2504    *
2505    * @return object|null
2506    *   $dao contact details
2507    */
2508   public static function matchContactOnOpenId($openId, $ctype = NULL) {
2509     $strtolower = function_exists('mb_strtolower') ? 'mb_strtolower' : 'strtolower';
2510     $openId = $strtolower(trim($openId));
2511     $query = "
2512 SELECT     civicrm_contact.id as contact_id,
2513            civicrm_contact.hash as hash,
2514            civicrm_contact.contact_type as contact_type,
2515            civicrm_contact.contact_sub_type as contact_sub_type
2516 FROM       civicrm_contact
2517 INNER JOIN civicrm_openid    ON ( civicrm_contact.id = civicrm_openid.contact_id )
2518 WHERE      civicrm_openid.openid = %1";
2519     $p = [1 => [$openId, 'String']];
2520
2521     if ($ctype) {
2522       $query .= " AND civicrm_contact.contact_type = %3";
2523       $p[3] = [$ctype, 'String'];
2524     }
2525
2526     $query .= " ORDER BY civicrm_openid.is_primary DESC";
2527
2528     $dao = CRM_Core_DAO::executeQuery($query, $p);
2529
2530     if ($dao->fetch()) {
2531       return $dao;
2532     }
2533     return NULL;
2534   }
2535
2536   /**
2537    * Get primary email of the contact.
2538    *
2539    * @param int $contactID
2540    *   Contact id.
2541    * @param bool $polite
2542    *   Whether to only pull an email if it's okay to send to it--that is, if it
2543    *   is not on_hold and the contact is not do_not_email.
2544    *
2545    * @return string
2546    *   Email address if present else null
2547    */
2548   public static function getPrimaryEmail($contactID, $polite = FALSE) {
2549     // fetch the primary email
2550     $query = "
2551    SELECT civicrm_email.email as email
2552      FROM civicrm_contact
2553 LEFT JOIN civicrm_email    ON ( civicrm_contact.id = civicrm_email.contact_id )
2554     WHERE civicrm_email.is_primary = 1
2555       AND civicrm_contact.id = %1";
2556     if ($polite) {
2557       $query .= '
2558       AND civicrm_contact.do_not_email = 0
2559       AND civicrm_email.on_hold = 0';
2560     }
2561     $p = [1 => [$contactID, 'Integer']];
2562     $dao = CRM_Core_DAO::executeQuery($query, $p);
2563
2564     $email = NULL;
2565     if ($dao->fetch()) {
2566       $email = $dao->email;
2567     }
2568     return $email;
2569   }
2570
2571   /**
2572    * Function to get primary OpenID of the contact.
2573    *
2574    * @param int $contactID
2575    *   Contact id.
2576    *
2577    * @return string
2578    *   >openid   OpenID if present else null
2579    */
2580   public static function getPrimaryOpenId($contactID) {
2581     // fetch the primary OpenID
2582     $query = "
2583 SELECT    civicrm_openid.openid as openid
2584 FROM      civicrm_contact
2585 LEFT JOIN civicrm_openid ON ( civicrm_contact.id = civicrm_openid.contact_id )
2586 WHERE     civicrm_contact.id = %1
2587 AND       civicrm_openid.is_primary = 1";
2588     $p = [1 => [$contactID, 'Integer']];
2589     $dao = CRM_Core_DAO::executeQuery($query, $p);
2590
2591     $openId = NULL;
2592     if ($dao->fetch()) {
2593       $openId = $dao->openid;
2594     }
2595     return $openId;
2596   }
2597
2598   /**
2599    * Fetch the object and store the values in the values array.
2600    *
2601    * @param array $params
2602    *   Input parameters to find object.
2603    * @param array $values
2604    *   Output values of the object.
2605    *
2606    * @return CRM_Contact_BAO_Contact|null
2607    *   The found object or null
2608    */
2609   public static function getValues(&$params, &$values) {
2610     $contact = new CRM_Contact_BAO_Contact();
2611
2612     $contact->copyValues($params);
2613
2614     if ($contact->find(TRUE)) {
2615
2616       CRM_Core_DAO::storeValues($contact, $values);
2617
2618       $privacy = [];
2619       foreach (self::$_commPrefs as $name) {
2620         if (isset($contact->$name)) {
2621           $privacy[$name] = $contact->$name;
2622         }
2623       }
2624
2625       if (!empty($privacy)) {
2626         $values['privacy'] = $privacy;
2627       }
2628
2629       // communication Prefferance
2630       $preffComm = $comm = [];
2631       $comm = explode(CRM_Core_DAO::VALUE_SEPARATOR,
2632         $contact->preferred_communication_method
2633       );
2634       foreach ($comm as $value) {
2635         $preffComm[$value] = 1;
2636       }
2637       $temp = ['preferred_communication_method' => $contact->preferred_communication_method];
2638
2639       $names = [
2640         'preferred_communication_method' => [
2641           'newName' => 'preferred_communication_method_display',
2642           'groupName' => 'preferred_communication_method',
2643         ],
2644       ];
2645
2646       // @todo This can be figured out from metadata & we can avoid the uncached query.
2647       CRM_Core_OptionGroup::lookupValues($temp, $names, FALSE);
2648
2649       $values['preferred_communication_method'] = $preffComm;
2650       $values['preferred_communication_method_display'] = $temp['preferred_communication_method_display'] ?? NULL;
2651
2652       if ($contact->preferred_mail_format) {
2653         $preferredMailingFormat = CRM_Core_SelectValues::pmf();
2654         $values['preferred_mail_format'] = $preferredMailingFormat[$contact->preferred_mail_format];
2655       }
2656
2657       // get preferred languages
2658       if (!empty($contact->preferred_language)) {
2659         $values['preferred_language'] = CRM_Core_PseudoConstant::getLabel('CRM_Contact_DAO_Contact', 'preferred_language', $contact->preferred_language);
2660       }
2661
2662       // Calculating Year difference
2663       if ($contact->birth_date) {
2664         $birthDate = CRM_Utils_Date::customFormat($contact->birth_date, '%Y%m%d');
2665         if ($birthDate < date('Ymd')) {
2666           $age = CRM_Utils_Date::calculateAge($birthDate);
2667           $values['age']['y'] = $age['years'] ?? NULL;
2668           $values['age']['m'] = $age['months'] ?? NULL;
2669         }
2670       }
2671
2672       $contact->contact_id = $contact->id;
2673
2674       return $contact;
2675     }
2676     return NULL;
2677   }
2678
2679   /**
2680    * Given the component name and returns the count of participation of contact.
2681    *
2682    * @param string $component
2683    *   Input component name.
2684    * @param int $contactId
2685    *   Input contact id.
2686    * @param string $tableName
2687    *   Optional tableName if component is custom group.
2688    *
2689    * @return int
2690    *   total number in database
2691    */
2692   public static function getCountComponent($component, $contactId, $tableName = NULL) {
2693     $object = NULL;
2694     switch ($component) {
2695       case 'tag':
2696         return CRM_Core_BAO_EntityTag::getContactTags($contactId, TRUE);
2697
2698       case 'rel':
2699         $result = CRM_Contact_BAO_Relationship::getRelationship($contactId,
2700           CRM_Contact_BAO_Relationship::CURRENT,
2701           0, 1, 0,
2702           NULL, NULL,
2703           TRUE
2704         );
2705         return $result;
2706
2707       case 'group':
2708
2709         return CRM_Contact_BAO_GroupContact::getContactGroup($contactId, "Added", NULL, TRUE, FALSE, FALSE, TRUE, NULL, TRUE);
2710
2711       case 'log':
2712         if (CRM_Core_BAO_Log::useLoggingReport()) {
2713           return FALSE;
2714         }
2715         return CRM_Core_BAO_Log::getContactLogCount($contactId);
2716
2717       case 'note':
2718         return CRM_Core_BAO_Note::getContactNoteCount($contactId);
2719
2720       case 'contribution':
2721         return CRM_Contribute_BAO_Contribution::contributionCount($contactId);
2722
2723       case 'membership':
2724         return CRM_Member_BAO_Membership::getContactMembershipCount($contactId, TRUE);
2725
2726       case 'participant':
2727         return CRM_Event_BAO_Participant::getContactParticipantCount($contactId);
2728
2729       case 'pledge':
2730         return CRM_Pledge_BAO_Pledge::getContactPledgeCount($contactId);
2731
2732       case 'case':
2733         return CRM_Case_BAO_Case::caseCount($contactId);
2734
2735       case 'grant':
2736         return CRM_Grant_BAO_Grant::getContactGrantCount($contactId);
2737
2738       case 'activity':
2739         $input = [
2740           'contact_id' => $contactId,
2741           'admin' => FALSE,
2742           'caseId' => NULL,
2743           'context' => 'activity',
2744         ];
2745         return CRM_Activity_BAO_Activity::getActivitiesCount($input);
2746
2747       case 'mailing':
2748         $params = ['contact_id' => $contactId];
2749         return CRM_Mailing_BAO_Mailing::getContactMailingsCount($params);
2750
2751       default:
2752         $custom = explode('_', $component);
2753         if ($custom['0'] = 'custom') {
2754           if (!$tableName) {
2755             $tableName = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomGroup', $custom['1'], 'table_name');
2756           }
2757           $queryString = "SELECT count(id) FROM {$tableName} WHERE entity_id = {$contactId}";
2758           return CRM_Core_DAO::singleValueQuery($queryString);
2759         }
2760     }
2761   }
2762
2763   /**
2764    * Update contact greetings if an update has resulted in a custom field change.
2765    *
2766    * @param array $updatedFields
2767    *   Array of fields that have been updated e.g array('first_name', 'prefix_id', 'custom_2');
2768    * @param array $contactParams
2769    *   Parameters known about the contact. At minimum array('contact_id' => x).
2770    *   Fields in this array will take precedence over DB fields (so far only
2771    *   in the case of greeting id fields).
2772    */
2773   public static function updateGreetingsOnTokenFieldChange($updatedFields, $contactParams) {
2774     $contactID = $contactParams['contact_id'];
2775     CRM_Contact_BAO_Contact::ensureGreetingParamsAreSet($contactParams);
2776     $tokens = CRM_Contact_BAO_Contact_Utils::getTokensRequiredForContactGreetings($contactParams);
2777     if (!empty($tokens['all']['contact'])) {
2778       $affectedTokens = array_intersect_key($updatedFields[$contactID], array_flip($tokens['all']['contact']));
2779       if (!empty($affectedTokens)) {
2780         // @todo this is still reloading the whole contact -fix to be more selective & use pre-loaded.
2781         $contact = new CRM_Contact_BAO_Contact();
2782         $contact->id = $contactID;
2783         CRM_Contact_BAO_Contact::processGreetings($contact);
2784       }
2785     }
2786   }
2787
2788   /**
2789    * Process greetings and cache.
2790    *
2791    * @param object $contact
2792    *   Contact object after save.
2793    */
2794   public static function processGreetings(&$contact) {
2795
2796     //@todo this function does a lot of unnecessary loading.
2797     // ensureGreetingParamsAreSet now makes sure that the contact is
2798     // loaded and using updateGreetingsOnTokenFieldChange
2799     // allows us the possibility of only doing an update if required.
2800
2801     // The contact object has not always required the
2802     // fields that are required to calculate greetings
2803     // so we need to retrieve it again.
2804     if ($contact->_query !== FALSE) {
2805       $contact->find(TRUE);
2806     }
2807
2808     // store object values to an array
2809     $contactDetails = [];
2810     CRM_Core_DAO::storeValues($contact, $contactDetails);
2811     $contactDetails = [[$contact->id => $contactDetails]];
2812
2813     $emailGreetingString = $postalGreetingString = $addresseeString = NULL;
2814     $updateQueryString = [];
2815
2816     //cache email and postal greeting to greeting display
2817     if ($contact->email_greeting_custom != 'null' && $contact->email_greeting_custom) {
2818       $emailGreetingString = $contact->email_greeting_custom;
2819     }
2820     elseif ($contact->email_greeting_id != 'null' && $contact->email_greeting_id) {
2821       // the filter value for Individual contact type is set to 1
2822       $filter = [
2823         'contact_type' => $contact->contact_type,
2824         'greeting_type' => 'email_greeting',
2825       ];
2826
2827       $emailGreeting = CRM_Core_PseudoConstant::greeting($filter);
2828       $emailGreetingString = $emailGreeting[$contact->email_greeting_id];
2829       $updateQueryString[] = " email_greeting_custom = NULL ";
2830     }
2831     else {
2832       if ($contact->email_greeting_custom) {
2833         $updateQueryString[] = " email_greeting_display = NULL ";
2834       }
2835     }
2836
2837     if ($emailGreetingString) {
2838       CRM_Contact_BAO_Contact_Utils::processGreetingTemplate($emailGreetingString,
2839         $contactDetails,
2840         $contact->id,
2841         'CRM_Contact_BAO_Contact'
2842       );
2843       $emailGreetingString = CRM_Core_DAO::escapeString(CRM_Utils_String::stripSpaces($emailGreetingString));
2844       $updateQueryString[] = " email_greeting_display = '{$emailGreetingString}'";
2845     }
2846
2847     //postal greetings
2848     if ($contact->postal_greeting_custom !== 'null' && $contact->postal_greeting_custom) {
2849       $postalGreetingString = $contact->postal_greeting_custom;
2850     }
2851     elseif ($contact->postal_greeting_id !== 'null' && $contact->postal_greeting_id) {
2852       $filter = [
2853         'contact_type' => $contact->contact_type,
2854         'greeting_type' => 'postal_greeting',
2855       ];
2856       $postalGreeting = CRM_Core_PseudoConstant::greeting($filter);
2857       $postalGreetingString = $postalGreeting[$contact->postal_greeting_id];
2858       $updateQueryString[] = " postal_greeting_custom = NULL ";
2859     }
2860     else {
2861       if ($contact->postal_greeting_custom) {
2862         $updateQueryString[] = " postal_greeting_display = NULL ";
2863       }
2864     }
2865
2866     if ($postalGreetingString) {
2867       CRM_Contact_BAO_Contact_Utils::processGreetingTemplate($postalGreetingString,
2868         $contactDetails,
2869         $contact->id,
2870         'CRM_Contact_BAO_Contact'
2871       );
2872       $postalGreetingString = CRM_Core_DAO::escapeString(CRM_Utils_String::stripSpaces($postalGreetingString));
2873       $updateQueryString[] = " postal_greeting_display = '{$postalGreetingString}'";
2874     }
2875
2876     // addressee
2877     if ($contact->addressee_custom !== 'null' && $contact->addressee_custom) {
2878       $addresseeString = $contact->addressee_custom;
2879     }
2880     elseif ($contact->addressee_id !== 'null' && $contact->addressee_id) {
2881       $filter = [
2882         'contact_type' => $contact->contact_type,
2883         'greeting_type' => 'addressee',
2884       ];
2885
2886       $addressee = CRM_Core_PseudoConstant::greeting($filter);
2887       $addresseeString = $addressee[$contact->addressee_id];
2888       $updateQueryString[] = " addressee_custom = NULL ";
2889     }
2890     else {
2891       if ($contact->addressee_custom) {
2892         $updateQueryString[] = " addressee_display = NULL ";
2893       }
2894     }
2895
2896     if ($addresseeString) {
2897       CRM_Contact_BAO_Contact_Utils::processGreetingTemplate($addresseeString,
2898         $contactDetails,
2899         $contact->id,
2900         'CRM_Contact_BAO_Contact'
2901       );
2902       $addresseeString = CRM_Core_DAO::escapeString(CRM_Utils_String::stripSpaces($addresseeString));
2903       $updateQueryString[] = " addressee_display = '{$addresseeString}'";
2904     }
2905
2906     if (!empty($updateQueryString)) {
2907       $updateQueryString = implode(',', $updateQueryString);
2908       $queryString = "UPDATE civicrm_contact SET {$updateQueryString} WHERE id = {$contact->id}";
2909       CRM_Core_DAO::executeQuery($queryString);
2910     }
2911   }
2912
2913   /**
2914    * Retrieve loc block ids w/ given condition.
2915    *
2916    * @param int $contactId
2917    *   Contact id.
2918    * @param array $criteria
2919    *   Key => value pair which should be.
2920    *                              fulfill by return record ids.
2921    * @param string $condOperator
2922    *   Operator use for grouping multiple conditions.
2923    *
2924    * @return array
2925    *   loc block ids which fulfill condition.
2926    */
2927   public static function getLocBlockIds($contactId, $criteria = [], $condOperator = 'AND') {
2928     $locBlockIds = [];
2929     if (!$contactId) {
2930       return $locBlockIds;
2931     }
2932
2933     foreach (['Email', 'OpenID', 'Phone', 'Address', 'IM'] as $block) {
2934       $name = strtolower($block);
2935       $className = "CRM_Core_DAO_$block";
2936       $blockDAO = new $className();
2937
2938       // build the condition.
2939       if (is_array($criteria)) {
2940         $fields = $blockDAO->fields();
2941         $conditions = [];
2942         foreach ($criteria as $field => $value) {
2943           if (array_key_exists($field, $fields)) {
2944             $cond = "( $field = $value )";
2945             // value might be zero or null.
2946             if (!$value || strtolower($value) === 'null') {
2947               $cond = "( $field = 0 OR $field IS NULL )";
2948             }
2949             $conditions[] = $cond;
2950           }
2951         }
2952         if (!empty($conditions)) {
2953           $blockDAO->whereAdd(implode(" $condOperator ", $conditions));
2954         }
2955       }
2956
2957       $blockDAO->contact_id = $contactId;
2958       $blockDAO->find();
2959       while ($blockDAO->fetch()) {
2960         $locBlockIds[$name][] = $blockDAO->id;
2961       }
2962     }
2963
2964     return $locBlockIds;
2965   }
2966
2967   /**
2968    * Build context menu items.
2969    *
2970    * @param int $contactId
2971    *
2972    * @return array
2973    *   Array of context menu for logged in user.
2974    */
2975   public static function contextMenu($contactId = NULL) {
2976     $menu = [
2977       'view' => [
2978         'title' => ts('View Contact'),
2979         'weight' => 0,
2980         'ref' => 'view-contact',
2981         'class' => 'no-popup',
2982         'key' => 'view',
2983         'permissions' => ['view all contacts'],
2984       ],
2985       'add' => [
2986         'title' => ts('Edit Contact'),
2987         'weight' => 0,
2988         'ref' => 'edit-contact',
2989         'class' => 'no-popup',
2990         'key' => 'add',
2991         'permissions' => ['edit all contacts'],
2992       ],
2993       'delete' => [
2994         'title' => ts('Delete Contact'),
2995         'weight' => 0,
2996         'ref' => 'delete-contact',
2997         'key' => 'delete',
2998         'permissions' => ['access deleted contacts', 'delete contacts'],
2999       ],
3000       'contribution' => [
3001         'title' => ts('Add Contribution'),
3002         'weight' => 5,
3003         'ref' => 'new-contribution',
3004         'key' => 'contribution',
3005         'tab' => 'contribute',
3006         'component' => 'CiviContribute',
3007         'href' => CRM_Utils_System::url('civicrm/contact/view/contribution',
3008           'reset=1&action=add&context=contribution'
3009         ),
3010         'permissions' => [
3011           'access CiviContribute',
3012           'edit contributions',
3013         ],
3014       ],
3015       'participant' => [
3016         'title' => ts('Register for Event'),
3017         'weight' => 10,
3018         'ref' => 'new-participant',
3019         'key' => 'participant',
3020         'tab' => 'participant',
3021         'component' => 'CiviEvent',
3022         'href' => CRM_Utils_System::url('civicrm/contact/view/participant', 'reset=1&action=add&context=participant'),
3023         'permissions' => [
3024           'access CiviEvent',
3025           'edit event participants',
3026         ],
3027       ],
3028       'activity' => [
3029         'title' => ts('Record Activity'),
3030         'weight' => 35,
3031         'ref' => 'new-activity',
3032         'key' => 'activity',
3033         'permissions' => ['edit all contacts'],
3034       ],
3035       'pledge' => [
3036         'title' => ts('Add Pledge'),
3037         'weight' => 15,
3038         'ref' => 'new-pledge',
3039         'key' => 'pledge',
3040         'tab' => 'pledge',
3041         'href' => CRM_Utils_System::url('civicrm/contact/view/pledge',
3042           'reset=1&action=add&context=pledge'
3043         ),
3044         'component' => 'CiviPledge',
3045         'permissions' => [
3046           'access CiviPledge',
3047           'edit pledges',
3048         ],
3049       ],
3050       'membership' => [
3051         'title' => ts('Add Membership'),
3052         'weight' => 20,
3053         'ref' => 'new-membership',
3054         'key' => 'membership',
3055         'tab' => 'member',
3056         'component' => 'CiviMember',
3057         'href' => CRM_Utils_System::url('civicrm/contact/view/membership',
3058           'reset=1&action=add&context=membership'
3059         ),
3060         'permissions' => [
3061           'access CiviMember',
3062           'edit memberships',
3063         ],
3064       ],
3065       'case' => [
3066         'title' => ts('Add Case'),
3067         'weight' => 25,
3068         'ref' => 'new-case',
3069         'key' => 'case',
3070         'tab' => 'case',
3071         'component' => 'CiviCase',
3072         'href' => CRM_Utils_System::url('civicrm/case/add', 'reset=1&action=add&context=case'),
3073         'permissions' => ['add cases'],
3074       ],
3075       'grant' => [
3076         'title' => ts('Add Grant'),
3077         'weight' => 26,
3078         'ref' => 'new-grant',
3079         'key' => 'grant',
3080         'tab' => 'grant',
3081         'component' => 'CiviGrant',
3082         'href' => CRM_Utils_System::url('civicrm/contact/view/grant',
3083           'reset=1&action=add&context=grant'
3084         ),
3085         'permissions' => ['edit grants'],
3086       ],
3087       'rel' => [
3088         'title' => ts('Add Relationship'),
3089         'weight' => 30,
3090         'ref' => 'new-relationship',
3091         'key' => 'rel',
3092         'tab' => 'rel',
3093         'href' => CRM_Utils_System::url('civicrm/contact/view/rel',
3094           'reset=1&action=add'
3095         ),
3096         'permissions' => ['edit all contacts'],
3097       ],
3098       'note' => [
3099         'title' => ts('Add Note'),
3100         'weight' => 40,
3101         'ref' => 'new-note',
3102         'key' => 'note',
3103         'tab' => 'note',
3104         'class' => 'medium-popup',
3105         'href' => CRM_Utils_System::url('civicrm/contact/view/note',
3106           'reset=1&action=add'
3107         ),
3108         'permissions' => ['edit all contacts'],
3109       ],
3110       'email' => [
3111         'title' => ts('Send an Email'),
3112         'weight' => 45,
3113         'ref' => 'new-email',
3114         'key' => 'email',
3115         'permissions' => ['view all contacts'],
3116       ],
3117       'group' => [
3118         'title' => ts('Add to Group'),
3119         'weight' => 50,
3120         'ref' => 'group-add-contact',
3121         'key' => 'group',
3122         'tab' => 'group',
3123         'permissions' => ['edit groups'],
3124       ],
3125       'tag' => [
3126         'title' => ts('Tag Contact'),
3127         'weight' => 55,
3128         'ref' => 'tag-contact',
3129         'key' => 'tag',
3130         'tab' => 'tag',
3131         'permissions' => ['edit all contacts'],
3132       ],
3133     ];
3134
3135     $menu['otherActions'] = [
3136       'print' => [
3137         'title' => ts('Print Summary'),
3138         'description' => ts('Printer-friendly view of this page.'),
3139         'weight' => 5,
3140         'ref' => 'crm-contact-print',
3141         'key' => 'print',
3142         'tab' => 'print',
3143         'href' => CRM_Utils_System::url('civicrm/contact/view/print',
3144           "reset=1&print=1"
3145         ),
3146         'class' => 'print',
3147         'icon' => 'crm-i fa-print',
3148       ],
3149       'vcard' => [
3150         'title' => ts('vCard'),
3151         'description' => ts('vCard record for this contact.'),
3152         'weight' => 10,
3153         'ref' => 'crm-contact-vcard',
3154         'key' => 'vcard',
3155         'tab' => 'vcard',
3156         'href' => CRM_Utils_System::url('civicrm/contact/view/vcard',
3157           "reset=1"
3158         ),
3159         'class' => 'vcard',
3160         'icon' => 'crm-i fa-list-alt',
3161       ],
3162     ];
3163
3164     if (CRM_Core_Permission::check('access Contact Dashboard')) {
3165       $menu['otherActions']['dashboard'] = [
3166         'title' => ts('Contact Dashboard'),
3167         'description' => ts('Contact Dashboard'),
3168         'weight' => 15,
3169         'ref' => 'crm-contact-dashboard',
3170         'key' => 'dashboard',
3171         'tab' => 'dashboard',
3172         'class' => 'dashboard',
3173         // NOTE: As an alternative you can also build url on CMS specific way
3174         //  as CRM_Core_Config::singleton()->userSystem->getUserRecordUrl($contactId)
3175         'href' => CRM_Utils_System::url('civicrm/user', "reset=1&id={$contactId}"),
3176         'icon' => 'crm-i fa-tachometer',
3177       ];
3178     }
3179
3180     $uid = CRM_Core_BAO_UFMatch::getUFId($contactId);
3181     if ($uid) {
3182       $menu['otherActions']['user-record'] = [
3183         'title' => ts('User Record'),
3184         'description' => ts('User Record'),
3185         'weight' => 20,
3186         'ref' => 'crm-contact-user-record',
3187         'key' => 'user-record',
3188         'tab' => 'user-record',
3189         'class' => 'user-record',
3190         'href' => CRM_Core_Config::singleton()->userSystem->getUserRecordUrl($contactId),
3191         'icon' => 'crm-i fa-user',
3192       ];
3193     }
3194     elseif (CRM_Core_Config::singleton()->userSystem->checkPermissionAddUser()) {
3195       $menu['otherActions']['user-add'] = [
3196         'title' => ts('Create User Record'),
3197         'description' => ts('Create User Record'),
3198         'weight' => 25,
3199         'ref' => 'crm-contact-user-add',
3200         'key' => 'user-add',
3201         'tab' => 'user-add',
3202         'class' => 'user-add',
3203         'href' => CRM_Utils_System::url('civicrm/contact/view/useradd', 'reset=1&action=add&cid=' . $contactId),
3204         'icon' => 'crm-i fa-user-plus',
3205       ];
3206     }
3207
3208     CRM_Utils_Hook::summaryActions($menu, $contactId);
3209     //1. check for component is active.
3210     //2. check for user permissions.
3211     //3. check for acls.
3212     //3. edit and view contact are directly accessible to user.
3213
3214     $aclPermissionedTasks = [
3215       'view-contact',
3216       'edit-contact',
3217       'new-activity',
3218       'new-email',
3219       'group-add-contact',
3220       'tag-contact',
3221       'delete-contact',
3222     ];
3223     $corePermission = CRM_Core_Permission::getPermission();
3224
3225     $contextMenu = [];
3226     foreach ($menu as $key => $values) {
3227       if ($key !== 'otherActions') {
3228
3229         // user does not have necessary permissions.
3230         if (!self::checkUserMenuPermissions($aclPermissionedTasks, $corePermission, $values)) {
3231           continue;
3232         }
3233         // build directly accessible action menu.
3234         if (in_array($values['ref'], [
3235           'view-contact',
3236           'edit-contact',
3237         ])) {
3238           $contextMenu['primaryActions'][$key] = [
3239             'title' => $values['title'],
3240             'ref' => $values['ref'],
3241             'class' => $values['class'] ?? NULL,
3242             'key' => $values['key'],
3243           ];
3244           continue;
3245         }
3246
3247         // finally get menu item for -more- action widget.
3248         $contextMenu['moreActions'][$values['weight']] = [
3249           'title' => $values['title'],
3250           'ref' => $values['ref'],
3251           'href' => $values['href'] ?? NULL,
3252           'tab' => $values['tab'] ?? NULL,
3253           'class' => $values['class'] ?? NULL,
3254           'key' => $values['key'],
3255         ];
3256       }
3257       else {
3258         foreach ($values as $value) {
3259           // user does not have necessary permissions.
3260           if (!self::checkUserMenuPermissions($aclPermissionedTasks, $corePermission, $value)) {
3261             continue;
3262           }
3263
3264           // finally get menu item for -more- action widget.
3265           $contextMenu['otherActions'][$value['weight']] = [
3266             'title' => $value['title'],
3267             'ref' => $value['ref'],
3268             'href' => $value['href'] ?? NULL,
3269             'tab' => $value['tab'] ?? NULL,
3270             'class' => $value['class'] ?? NULL,
3271             'icon' => $value['icon'] ?? NULL,
3272             'key' => $value['key'],
3273           ];
3274         }
3275       }
3276     }
3277
3278     ksort($contextMenu['moreActions']);
3279     ksort($contextMenu['otherActions']);
3280
3281     return $contextMenu;
3282   }
3283
3284   /**
3285    * Check if user has permissions to access items in action menu.
3286    *
3287    * @param array $aclPermissionedTasks
3288    *   Array containing ACL related tasks.
3289    * @param string $corePermission
3290    *   The permission of the user (edit or view or null).
3291    * @param array $menuOptions
3292    *   Array containing params of the menu (title, href, etc).
3293    *
3294    * @return bool
3295    *   TRUE if user has all permissions, FALSE if otherwise.
3296    */
3297   public static function checkUserMenuPermissions($aclPermissionedTasks, $corePermission, $menuOptions) {
3298     $componentName = $menuOptions['component'] ?? NULL;
3299
3300     // if component action - make sure component is enable.
3301     if ($componentName && !in_array($componentName, CRM_Core_Config::singleton()->enableComponents)) {
3302       return FALSE;
3303     }
3304
3305     // make sure user has all required permissions.
3306     $hasAllPermissions = FALSE;
3307
3308     $permissions = $menuOptions['permissions'] ?? NULL;
3309     if (!is_array($permissions) || empty($permissions)) {
3310       $hasAllPermissions = TRUE;
3311     }
3312
3313     // iterate for required permissions in given permissions array.
3314     if (!$hasAllPermissions) {
3315       $hasPermissions = 0;
3316       foreach ($permissions as $permission) {
3317         if (CRM_Core_Permission::check($permission)) {
3318           $hasPermissions++;
3319         }
3320       }
3321
3322       if (count($permissions) == $hasPermissions) {
3323         $hasAllPermissions = TRUE;
3324       }
3325
3326       // if still user does not have required permissions, check acl.
3327       if (!$hasAllPermissions && $menuOptions['ref'] !== 'delete-contact') {
3328         if (in_array($menuOptions['ref'], $aclPermissionedTasks) &&
3329           $corePermission == CRM_Core_Permission::EDIT
3330         ) {
3331           $hasAllPermissions = TRUE;
3332         }
3333         elseif (in_array($menuOptions['ref'], [
3334           'new-email',
3335         ])) {
3336           // grant permissions for these tasks.
3337           $hasAllPermissions = TRUE;
3338         }
3339       }
3340     }
3341
3342     return $hasAllPermissions;
3343   }
3344
3345   /**
3346    * Retrieve display name of contact that address is shared.
3347    *
3348    * This is based on $masterAddressId or $contactId .
3349    *
3350    * @param int $masterAddressId
3351    *   Master id.
3352    * @param int $contactId
3353    *   Contact id. (deprecated - do not use)
3354    *
3355    * @return string|null
3356    *   the found display name or null.
3357    */
3358   public static function getMasterDisplayName($masterAddressId = NULL, $contactId = NULL) {
3359     $masterDisplayName = NULL;
3360     if (!$masterAddressId) {
3361       return $masterDisplayName;
3362     }
3363
3364     $sql = "
3365    SELECT display_name from civicrm_contact
3366 LEFT JOIN civicrm_address ON ( civicrm_address.contact_id = civicrm_contact.id )
3367     WHERE civicrm_address.id = " . $masterAddressId;
3368
3369     $masterDisplayName = CRM_Core_DAO::singleValueQuery($sql);
3370     return $masterDisplayName;
3371   }
3372
3373   /**
3374    * Get the creation/modification times for a contact.
3375    *
3376    * @param int $contactId
3377    *
3378    * @return array
3379    *   Dates - ('created_date' => $, 'modified_date' => $)
3380    */
3381   public static function getTimestamps($contactId) {
3382     $timestamps = CRM_Core_DAO::executeQuery(
3383       'SELECT created_date, modified_date
3384       FROM civicrm_contact
3385       WHERE id = %1',
3386       [
3387         1 => [$contactId, 'Integer'],
3388       ]
3389     );
3390     if ($timestamps->fetch()) {
3391       return [
3392         'created_date' => $timestamps->created_date,
3393         'modified_date' => $timestamps->modified_date,
3394       ];
3395     }
3396     else {
3397       return NULL;
3398     }
3399   }
3400
3401   /**
3402    * Get a list of triggers for the contact table.
3403    *
3404    * @param $info
3405    * @param null $tableName
3406    *
3407    * @see http://issues.civicrm.org/jira/browse/CRM-10554
3408    *
3409    * @see hook_civicrm_triggerInfo
3410    * @see CRM_Core_DAO::triggerRebuild
3411    */
3412   public static function triggerInfo(&$info, $tableName = NULL) {
3413
3414     // Modifications to these records should update the contact timestamps.
3415     \Civi\Core\SqlTrigger\TimestampTriggers::create('civicrm_contact', 'Contact')
3416       ->setRelations([
3417         ['table' => 'civicrm_address', 'column' => 'contact_id'],
3418         ['table' => 'civicrm_email', 'column' => 'contact_id'],
3419         ['table' => 'civicrm_im', 'column' => 'contact_id'],
3420         ['table' => 'civicrm_phone', 'column' => 'contact_id'],
3421         ['table' => 'civicrm_website', 'column' => 'contact_id'],
3422       ])
3423       ->alterTriggerInfo($info, $tableName);
3424
3425     // Update phone table to populate phone_numeric field
3426     if (!$tableName || $tableName == 'civicrm_phone') {
3427       // Define stored sql function needed for phones
3428       $sqlTriggers = Civi::service('sql_triggers');
3429       $sqlTriggers->enqueueQuery(self::DROP_STRIP_FUNCTION_43);
3430       $sqlTriggers->enqueueQuery(self::CREATE_STRIP_FUNCTION_43);
3431       $info[] = [
3432         'table' => ['civicrm_phone'],
3433         'when' => 'BEFORE',
3434         'event' => ['INSERT', 'UPDATE'],
3435         'sql' => "\nSET NEW.phone_numeric = civicrm_strip_non_numeric(NEW.phone);\n",
3436       ];
3437     }
3438   }
3439
3440   /**
3441    * Check if contact is being used in civicrm_domain based on $contactId.
3442    *
3443    * @param int $contactId
3444    *   Contact id.
3445    *
3446    * @return bool
3447    *   true if present else false.
3448    */
3449   public static function checkDomainContact($contactId) {
3450     if (!$contactId) {
3451       return FALSE;
3452     }
3453     $domainId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_Domain', $contactId, 'id', 'contact_id');
3454
3455     if ($domainId) {
3456       return TRUE;
3457     }
3458     else {
3459       return FALSE;
3460     }
3461   }
3462
3463   /**
3464    * Get options for a given contact field.
3465    *
3466    * @param string $fieldName
3467    * @param string $context
3468    * @param array $props
3469    *   whatever is known about this dao object.
3470    *
3471    * @return array|bool
3472    * @see CRM_Core_DAO::buildOptions
3473    *
3474    * TODO: Should we always assume chainselect? What fn should be responsible for controlling that flow?
3475    * TODO: In context of chainselect, what to return if e.g. a country has no states?
3476    *
3477    * @see CRM_Core_DAO::buildOptionsContext
3478    */
3479   public static function buildOptions($fieldName, $context = NULL, $props = []) {
3480     $params = [];
3481     // Special logic for fields whose options depend on context or properties
3482     switch ($fieldName) {
3483       case 'contact_sub_type':
3484         if (!empty($props['contact_type'])) {
3485           $params['condition'] = "parent_id = (SELECT id FROM civicrm_contact_type WHERE name='{$props['contact_type']}')";
3486         }
3487         break;
3488
3489       case 'contact_type':
3490         if ($context == 'search') {
3491           // CRM-15495 - EntityRef filters and basic search forms expect this format
3492           // FIXME: Search builder does not
3493           return CRM_Contact_BAO_ContactType::getSelectElements();
3494         }
3495         break;
3496
3497       // The contact api supports some related entities so we'll honor that by fetching their options
3498       case 'group_id':
3499       case 'group':
3500         return CRM_Contact_BAO_GroupContact::buildOptions('group_id', $context, $props);
3501
3502       case 'tag_id':
3503       case 'tag':
3504         $props['entity_table'] = 'civicrm_contact';
3505         return CRM_Core_BAO_EntityTag::buildOptions('tag_id', $context, $props);
3506
3507       case 'state_province_id':
3508       case 'state_province':
3509       case 'state_province_name':
3510       case 'country_id':
3511       case 'country':
3512       case 'county_id':
3513       case 'worldregion':
3514       case 'worldregion_id':
3515         return CRM_Core_BAO_Address::buildOptions($fieldName, 'get', $props);
3516
3517     }
3518     return CRM_Core_PseudoConstant::get(__CLASS__, $fieldName, $params, $context);
3519   }
3520
3521   /**
3522    * Delete a contact-related object that has an 'is_primary' field.
3523    *
3524    * Ensures that is_primary gets assigned to another object if available
3525    * Also calls pre/post hooks
3526    *
3527    * @param string $type
3528    * @param int $id
3529    *
3530    * @return bool
3531    */
3532   public static function deleteObjectWithPrimary($type, $id) {
3533     if (!$id || !is_numeric($id)) {
3534       return FALSE;
3535     }
3536     $daoName = "CRM_Core_DAO_$type";
3537     $obj = new $daoName();
3538     $obj->id = $id;
3539     $obj->find();
3540     $hookParams = [];
3541     if ($obj->fetch()) {
3542       CRM_Utils_Hook::pre('delete', $type, $id, $hookParams);
3543       $contactId = $obj->contact_id;
3544       $obj->delete();
3545     }
3546     else {
3547       return FALSE;
3548     }
3549     // is_primary is only relavent if this field belongs to a contact
3550     if ($contactId) {
3551       $dao = new $daoName();
3552       $dao->contact_id = $contactId;
3553       $dao->is_primary = 1;
3554       // Pick another record to be primary (if one isn't already)
3555       if (!$dao->find(TRUE)) {
3556         $dao->is_primary = 0;
3557         $dao->find();
3558         if ($dao->fetch()) {
3559           $dao->is_primary = 1;
3560           $dao->save();
3561         }
3562       }
3563     }
3564     CRM_Utils_Hook::post('delete', $type, $id, $obj);
3565     return TRUE;
3566   }
3567
3568   /**
3569    * @inheritDoc
3570    */
3571   public function addSelectWhereClause() {
3572     // We always return an array with these keys, even if they are empty,
3573     // because this tells the query builder that we have considered these fields for acls
3574     $clauses = [
3575       'id' => (array) CRM_Contact_BAO_Contact_Permission::cacheSubquery(),
3576       'is_deleted' => CRM_Core_Permission::check('access deleted contacts') ? [] : ['!= 1'],
3577     ];
3578     CRM_Utils_Hook::selectWhereClause($this, $clauses);
3579     return $clauses;
3580   }
3581
3582   /**
3583    * Get any existing duplicate contacts based on the input parameters.
3584    *
3585    * @param array $input
3586    *   Input parameters to be matched.
3587    * @param string $contactType
3588    * @param string $rule
3589    *  - Supervised
3590    *  - Unsupervised
3591    * @param $excludedContactIDs
3592    *   An array of ids not to be included in the results.
3593    * @param bool $checkPermissions
3594    * @param int $ruleGroupID
3595    *   ID of the rule group to be used if an override is desirable.
3596    * @param array $contextParams
3597    *   The context if relevant, eg. ['event_id' => X]
3598    *
3599    * @return array
3600    */
3601   public static function getDuplicateContacts($input, $contactType, $rule = 'Unsupervised', $excludedContactIDs = [], $checkPermissions = TRUE, $ruleGroupID = NULL, $contextParams = []) {
3602     $dedupeParams = CRM_Dedupe_Finder::formatParams($input, $contactType);
3603     $dedupeParams['check_permission'] = $checkPermissions;
3604     $dedupeParams['contact_type'] = $contactType;
3605     $dedupeParams['rule'] = $rule;
3606     $dedupeParams['rule_group_id'] = $ruleGroupID;
3607     $dedupeParams['excluded_contact_ids'] = $excludedContactIDs;
3608     $dedupeResults['ids'] = [];
3609     $dedupeResults['handled'] = FALSE;
3610     CRM_Utils_Hook::findDuplicates($dedupeParams, $dedupeResults, $contextParams);
3611     if (!$dedupeResults['handled']) {
3612       $dedupeResults['ids'] = CRM_Dedupe_Finder::dupesByParams($dedupeParams, $contactType, $rule, $excludedContactIDs, $ruleGroupID);
3613     }
3614     return $dedupeResults['ids'];
3615   }
3616
3617   /**
3618    * Get the first duplicate contacts based on the input parameters.
3619    *
3620    * @param array $input
3621    *   Input parameters to be matched.
3622    * @param string $contactType
3623    * @param string $rule
3624    *  - Supervised
3625    *  - Unsupervised
3626    * @param $excludedContactIDs
3627    *   An array of ids not to be included in the results.
3628    * @param bool $checkPermissions
3629    * @param int $ruleGroupID
3630    *   ID of the rule group to be used if an override is desirable.
3631    * @param array $contextParams
3632    *   The context if relevant, eg. ['event_id' => X]
3633    *
3634    * @return int|null
3635    */
3636   public static function getFirstDuplicateContact($input, $contactType, $rule = 'Unsupervised', $excludedContactIDs = [], $checkPermissions = TRUE, $ruleGroupID = NULL, $contextParams = []) {
3637     $ids = self::getDuplicateContacts($input, $contactType, $rule, $excludedContactIDs, $checkPermissions, $ruleGroupID, $contextParams);
3638     if (empty($ids)) {
3639       return NULL;
3640     }
3641     return $ids[0];
3642   }
3643
3644   /**
3645    * Check if a field is associated with an entity that has a location type.
3646    *
3647    * (ie. is an address, phone, email etc field).
3648    *
3649    * @param string $fieldTitle
3650    *   Title of the field (not the name - create a new function for that if required).
3651    *
3652    * @return bool
3653    */
3654   public static function isFieldHasLocationType($fieldTitle) {
3655     foreach (CRM_Contact_BAO_Contact::importableFields() as $key => $field) {
3656       if ($field['title'] === $fieldTitle) {
3657         return $field['hasLocationType'] ?? NULL;
3658       }
3659     }
3660     return FALSE;
3661   }
3662
3663   /**
3664    * @param array $appendProfiles
3665    *   Name of profile(s) to append to each link.
3666    *
3667    * @return array
3668    */
3669   public static function getEntityRefCreateLinks($appendProfiles = []) {
3670     // You'd think that "create contacts" would be the permission to check,
3671     // But new contact popups are profile forms and those use their own permissions.
3672     if (!CRM_Core_Permission::check([['profile create', 'profile listings and forms']])) {
3673       return FALSE;
3674     }
3675     $profiles = [];
3676     foreach (CRM_Contact_BAO_ContactType::basicTypes() as $contactType) {
3677       $profiles[] = 'new_' . strtolower($contactType);
3678     }
3679     $retrieved = civicrm_api3('uf_group', 'get', [
3680       'name' => ['IN' => array_merge($profiles, (array) $appendProfiles)],
3681       'is_active' => 1,
3682     ]);
3683     $links = $append = [];
3684     if (!empty($retrieved['values'])) {
3685       $icons = [
3686         'individual' => 'fa-user',
3687         'organization' => 'fa-building',
3688         'household' => 'fa-home',
3689       ];
3690       foreach ($retrieved['values'] as $id => $profile) {
3691         if (in_array($profile['name'], $profiles)) {
3692           $links[] = [
3693             'label' => $profile['title'],
3694             'url' => CRM_Utils_System::url('civicrm/profile/create', "reset=1&context=dialog&gid=$id",
3695               NULL, NULL, FALSE, FALSE, TRUE),
3696             'type' => ucfirst(str_replace('new_', '', $profile['name'])),
3697             'icon' => $icons[str_replace('new_', '', $profile['name'])] ?? NULL,
3698           ];
3699         }
3700         else {
3701           $append[] = $id;
3702         }
3703       }
3704       foreach ($append as $id) {
3705         foreach ($links as &$link) {
3706           $link['url'] .= ",$id";
3707         }
3708       }
3709     }
3710     return $links;
3711   }
3712
3713   /**
3714    * @return array
3715    */
3716   public static function getEntityRefFilters() {
3717     return [
3718       ['key' => 'contact_type', 'value' => ts('Contact Type')],
3719       ['key' => 'group', 'value' => ts('Group'), 'entity' => 'GroupContact'],
3720       ['key' => 'tag', 'value' => ts('Tag'), 'entity' => 'EntityTag'],
3721       ['key' => 'city', 'value' => ts('City'), 'type' => 'text', 'entity' => 'Address'],
3722       ['key' => 'postal_code', 'value' => ts('Postal Code'), 'type' => 'text', 'entity' => 'Address'],
3723       ['key' => 'state_province', 'value' => ts('State/Province'), 'entity' => 'Address'],
3724       ['key' => 'country', 'value' => ts('Country'), 'entity' => 'Address'],
3725       ['key' => 'first_name', 'value' => ts('First Name'), 'type' => 'text', 'condition' => ['contact_type' => 'Individual']],
3726       ['key' => 'last_name', 'value' => ts('Last Name'), 'type' => 'text', 'condition' => ['contact_type' => 'Individual']],
3727       ['key' => 'nick_name', 'value' => ts('Nick Name'), 'type' => 'text', 'condition' => ['contact_type' => 'Individual']],
3728       ['key' => 'organization_name', 'value' => ts('Employer name'), 'type' => 'text', 'condition' => ['contact_type' => 'Individual']],
3729       ['key' => 'gender_id', 'value' => ts('Gender'), 'condition' => ['contact_type' => 'Individual']],
3730       ['key' => 'is_deceased', 'value' => ts('Deceased'), 'condition' => ['contact_type' => 'Individual']],
3731       ['key' => 'contact_id', 'value' => ts('Contact ID'), 'type' => 'text'],
3732       ['key' => 'external_identifier', 'value' => ts('External ID'), 'type' => 'text'],
3733       ['key' => 'source', 'value' => ts('Contact Source'), 'type' => 'text'],
3734     ];
3735   }
3736
3737 }