CRM/Contact/BAO/Contact.php

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