CRM/Contact/Page/AJAX.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | Copyright CiviCRM LLC. All rights reserved.                        |
   5  |                                                                    |
   6  | This work is published under the GNU AGPLv3 license with some      |
   7  | permitted exceptions and without any warranty. For full license    |
   8  | and copyright information, see https://civicrm.org/licensing       |
   9  +--------------------------------------------------------------------+
  10  */
  11
  12 /**
  13  *
  14  * @package CRM
  15  * @copyright CiviCRM LLC https://civicrm.org/licensing
  16  */
  17
  18 /**
  19  * This class contains all contact related functions that are called using AJAX (jQuery)
  20  */
  21 class CRM_Contact_Page_AJAX {
  22   /**
  23    * When a user chooses a username, CHECK_USERNAME_TTL
  24    * is the time window in which they can check usernames
  25    * (without reloading the overall form).
  26    */
  27   // 3hr; 3*60*60
  28   const CHECK_USERNAME_TTL = 10800;
  29
  30   // 6hr; 6*60*60
  31   const AUTOCOMPLETE_TTL = 21600;
  32
  33   /**
  34    * Ajax callback for custom fields of type ContactReference
  35    *
  36    * Todo: Migrate contact reference fields to use EntityRef
  37    */
  38   public static function contactReference() {
  39     $name = $_GET['term'] ?? NULL;
  40     $name = CRM_Utils_Type::escape($name, 'String');
  41     $cfID = CRM_Utils_Type::escape($_GET['id'], 'Positive');
  42
  43     // check that this is a valid, active custom field of Contact Reference type
  44     $params = ['id' => $cfID];
  45     $returnProperties = ['filter', 'data_type', 'is_active'];
  46     $cf = [];
  47     CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_CustomField', $params, $cf, $returnProperties);
  48     if (!$cf['id'] || !$cf['is_active'] || $cf['data_type'] != 'ContactReference') {
  49       CRM_Utils_System::civiExit(1);
  50     }
  51
  52     if (!empty($cf['filter'])) {
  53       $filterParams = [];
  54       parse_str($cf['filter'], $filterParams);
  55
  56       $action = $filterParams['action'] ?? NULL;
  57       if (!empty($action) && !in_array($action, ['get', 'lookup'])) {
  58         CRM_Utils_System::civiExit(1);
  59       }
  60
  61       if (!empty($filterParams['group'])) {
  62         $filterParams['group'] = explode(',', $filterParams['group']);
  63       }
  64     }
  65
  66     $list = array_keys(CRM_Core_BAO_Setting::valueOptions(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME,
  67       'contact_reference_options'
  68     ), '1');
  69
  70     $return = array_unique(array_merge(['sort_name'], $list));
  71
  72     $limit = Civi::settings()->get('search_autocomplete_count');
  73
  74     $params = ['offset' => 0, 'rowCount' => $limit, 'version' => 3];
  75     foreach ($return as $fld) {
  76       $params["return.{$fld}"] = 1;
  77     }
  78
  79     if (!empty($action)) {
  80       $excludeGet = [
  81         'reset',
  82         'key',
  83         'className',
  84         'fnName',
  85         'json',
  86         'reset',
  87         'context',
  88         'timestamp',
  89         'limit',
  90         'id',
  91         's',
  92         'q',
  93         'action',
  94       ];
  95       foreach ($_GET as $param => $val) {
  96         if (empty($val) ||
  97           in_array($param, $excludeGet) ||
  98           strpos($param, 'return.') !== FALSE ||
  99           strpos($param, 'api.') !== FALSE
 100         ) {
 101           continue;
 102         }
 103         $params[$param] = $val;
 104       }
 105     }
 106
 107     if ($name) {
 108       $params['sort_name'] = $name;
 109     }
 110
 111     $params['sort'] = 'sort_name';
 112
 113     // tell api to skip permission chk. dgg
 114     $params['check_permissions'] = 0;
 115
 116     // add filter variable to params
 117     if (!empty($filterParams)) {
 118       $params = array_merge($params, $filterParams);
 119     }
 120
 121     $contact = civicrm_api('Contact', 'Get', $params);
 122
 123     if (!empty($contact['is_error'])) {
 124       CRM_Utils_System::civiExit(1);
 125     }
 126
 127     $contactList = [];
 128     foreach ($contact['values'] as $value) {
 129       $view = [];
 130       foreach ($return as $fld) {
 131         if (!empty($value[$fld])) {
 132           $view[] = $value[$fld];
 133         }
 134       }
 135       $contactList[] = ['id' => $value['id'], 'text' => implode(' :: ', $view)];
 136     }
 137
 138     if (!empty($_GET['is_unit_test'])) {
 139       return $contactList;
 140     }
 141     CRM_Utils_JSON::output($contactList);
 142   }
 143
 144   /**
 145    * Fetch PCP ID by PCP Supporter sort_name, also displays PCP title and associated Contribution Page title
 146    */
 147   public static function getPCPList() {
 148     $name = $_GET['term'] ?? NULL;
 149     $name = CRM_Utils_Type::escape($name, 'String');
 150     $limit = $max = Civi::settings()->get('search_autocomplete_count');
 151
 152     $where = ' AND pcp.page_id = cp.id AND pcp.contact_id = cc.id';
 153
 154     $config = CRM_Core_Config::singleton();
 155     if ($config->includeWildCardInName) {
 156       $strSearch = "%$name%";
 157     }
 158     else {
 159       $strSearch = "$name%";
 160     }
 161     $includeEmailFrom = $includeNickName = '';
 162     if ($config->includeNickNameInName) {
 163       $includeNickName = " OR nick_name LIKE '$strSearch'";
 164     }
 165     if ($config->includeEmailInName) {
 166       $includeEmailFrom = "LEFT JOIN civicrm_email eml ON ( cc.id = eml.contact_id AND eml.is_primary = 1 )";
 167       $whereClause = " WHERE ( email LIKE '$strSearch' OR sort_name LIKE '$strSearch' $includeNickName ) {$where} ";
 168     }
 169     else {
 170       $whereClause = " WHERE ( sort_name LIKE '$strSearch' $includeNickName ) {$where} ";
 171     }
 172
 173     $offset = $count = 0;
 174     if (!empty($_GET['page_num'])) {
 175       $page = (int) $_GET['page_num'];
 176       $offset = $limit * ($page - 1);
 177       $limit++;
 178     }
 179
 180     $select = 'cc.sort_name, pcp.title, cp.title';
 181     $query = "
 182         SELECT id, data
 183         FROM (
 184             SELECT pcp.id as id, CONCAT_WS( ' :: ', {$select} ) as data, sort_name
 185             FROM civicrm_pcp pcp, civicrm_contribution_page cp, civicrm_contact cc
 186             {$includeEmailFrom}
 187             {$whereClause} AND pcp.page_type = 'contribute'
 188             UNION ALL
 189             SELECT pcp.id as id, CONCAT_WS( ' :: ', {$select} ) as data, sort_name
 190             FROM civicrm_pcp pcp, civicrm_event cp, civicrm_contact cc
 191             {$includeEmailFrom}
 192             {$whereClause} AND pcp.page_type = 'event'
 193             ) t
 194         ORDER BY sort_name
 195         LIMIT $offset, $limit
 196         ";
 197
 198     $dao = CRM_Core_DAO::executeQuery($query);
 199     $output = ['results' => [], 'more' => FALSE];
 200     while ($dao->fetch()) {
 201       if (++$count > $max) {
 202         $output['more'] = TRUE;
 203       }
 204       else {
 205         $output['results'][] = ['id' => $dao->id, 'text' => $dao->data];
 206       }
 207     }
 208     CRM_Utils_JSON::output($output);
 209   }
 210
 211   public static function relationship() {
 212     $relType = CRM_Utils_Request::retrieve('rel_type', 'String', CRM_Core_DAO::$_nullObject, TRUE);
 213     $relContactID = CRM_Utils_Request::retrieve('rel_contact', 'Positive', CRM_Core_DAO::$_nullObject, TRUE);
 214     $originalCid = CRM_Utils_Request::retrieve('cid', 'Positive');
 215     $relationshipID = CRM_Utils_Request::retrieve('rel_id', 'Positive');
 216     $caseID = CRM_Utils_Request::retrieve('case_id', 'Positive', CRM_Core_DAO::$_nullObject, TRUE);
 217
 218     if (!CRM_Case_BAO_Case::accessCase($caseID)) {
 219       CRM_Utils_System::permissionDenied();
 220     }
 221
 222     $ret = ['is_error' => 0];
 223
 224     list($relTypeId, $b, $a) = explode('_', $relType);
 225
 226     if ($relationshipID && $originalCid) {
 227       CRM_Case_BAO_Case::endCaseRole($caseID, $a, $originalCid, $relTypeId);
 228     }
 229
 230     $clientList = CRM_Case_BAO_Case::getCaseClients($caseID);
 231
 232     // Loop through multiple case clients
 233     foreach ($clientList as $i => $sourceContactID) {
 234       try {
 235         $params = [
 236           'case_id' => $caseID,
 237           'relationship_type_id' => $relTypeId,
 238           "contact_id_$a" => $relContactID,
 239           "contact_id_$b" => $sourceContactID,
 240           'sequential' => TRUE,
 241         ];
 242         // first check if there is any existing relationship present with same parameters.
 243         // If yes then update the relationship by setting active and start date to current time
 244         $relationship = civicrm_api3('Relationship', 'get', $params)['values'];
 245         $params = array_merge(CRM_Utils_Array::value(0, $relationship, $params), [
 246           'start_date' => 'now',
 247           'is_active' => TRUE,
 248           'end_date' => '',
 249         ]);
 250         $result = civicrm_api3('relationship', 'create', $params);
 251       }
 252       catch (CiviCRM_API3_Exception $e) {
 253         $ret['is_error'] = 1;
 254         $ret['error_message'] = $e->getMessage();
 255       }
 256       // Save activity only for the primary (first) client
 257       if ($i == 0 && empty($result['is_error'])) {
 258         CRM_Case_BAO_Case::createCaseRoleActivity($caseID, $result['id'], $relContactID, $sourceContactID);
 259       }
 260     }
 261     if (!empty($_REQUEST['is_unit_test'])) {
 262       return $ret;
 263     }
 264
 265     CRM_Utils_JSON::output($ret);
 266   }
 267
 268   /**
 269    * Fetch the custom field help.
 270    */
 271   public static function customField() {
 272     $fieldId = CRM_Utils_Type::escape($_REQUEST['id'], 'Integer');
 273     $params = ['id' => $fieldId];
 274     $returnProperties = ['help_pre', 'help_post'];
 275     $values = [];
 276
 277     CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_CustomField', $params, $values, $returnProperties);
 278     CRM_Utils_JSON::output($values);
 279   }
 280
 281   public static function groupTree() {
 282     CRM_Utils_System::setHttpHeader('Content-Type', 'application/json');
 283     $gids = CRM_Utils_Type::escape($_GET['gids'], 'String');
 284     echo CRM_Contact_BAO_GroupNestingCache::json($gids);
 285     CRM_Utils_System::civiExit();
 286   }
 287
 288   /**
 289    * Delete custom value.
 290    */
 291   public static function deleteCustomValue() {
 292     CRM_Utils_System::setHttpHeader('Content-Type', 'text/plain');
 293     $customValueID = CRM_Utils_Type::escape($_REQUEST['valueID'], 'Positive');
 294     $customGroupID = CRM_Utils_Type::escape($_REQUEST['groupID'], 'Positive');
 295     $contactId = CRM_Utils_Request::retrieve('contactId', 'Positive');
 296     CRM_Core_BAO_CustomValue::deleteCustomValue($customValueID, $customGroupID);
 297     if ($contactId) {
 298       echo CRM_Contact_BAO_Contact::getCountComponent('custom_' . $customGroupID, $contactId);
 299     }
 300
 301     CRM_Contact_BAO_GroupContactCache::opportunisticCacheFlush();
 302     CRM_Utils_System::civiExit();
 303   }
 304
 305   /**
 306    *  check the CMS username.
 307    */
 308   public static function checkUserName() {
 309     $signer = new CRM_Utils_Signer(CRM_Core_Key::privateKey(), ['for', 'ts']);
 310     $sig = CRM_Utils_Request::retrieve('sig', 'String');
 311     $for = CRM_Utils_Request::retrieve('for', 'String');
 312     if (
 313       CRM_Utils_Time::getTimeRaw() > $_REQUEST['ts'] + self::CHECK_USERNAME_TTL
 314       || $for != 'civicrm/ajax/cmsuser'
 315       || !$signer->validate($sig, $_REQUEST)
 316     ) {
 317       $user = ['name' => 'error'];
 318       CRM_Utils_JSON::output($user);
 319     }
 320
 321     $config = CRM_Core_Config::singleton();
 322     $username = trim(CRM_Utils_Array::value('cms_name', $_REQUEST));
 323
 324     $params = ['name' => $username];
 325
 326     $errors = [];
 327     $config->userSystem->checkUserNameEmailExists($params, $errors);
 328
 329     if (isset($errors['cms_name']) || isset($errors['name'])) {
 330       //user name is not available
 331       $user = ['name' => 'no'];
 332       CRM_Utils_JSON::output($user);
 333     }
 334     else {
 335       //user name is available
 336       $user = ['name' => 'yes'];
 337       CRM_Utils_JSON::output($user);
 338     }
 339
 340     // Not reachable: JSON::output() above exits.
 341     CRM_Utils_System::civiExit();
 342   }
 343
 344   /**
 345    *  Function to get email address of a contact.
 346    */
 347   public static function getContactEmail() {
 348     $queryStrings = [];
 349     $name = $_GET['name'] ?? NULL;
 350     if ($name) {
 351       $name = CRM_Utils_Type::escape($name, 'String');
 352       $wildCard = Civi::settings()->get('includeWildCardInName') ? '%' : '';
 353       foreach (['cc.sort_name', 'ce.email'] as $column) {
 354         $queryStrings[] = "{$column} LIKE '{$wildCard}{$name}%'";
 355       }
 356       $result = [];
 357       $rowCount = Civi::settings()->get('search_autocomplete_count');
 358
 359       // add acl clause here
 360       list($aclFrom, $aclWhere) = CRM_Contact_BAO_Contact_Permission::cacheClause('cc');
 361       if ($aclWhere) {
 362         $aclWhere = "AND {$aclWhere}";
 363       }
 364       foreach ($queryStrings as &$queryString) {
 365         $queryString = "(
 366 SELECT sort_name name, ce.email, cc.id
 367 FROM   civicrm_email ce INNER JOIN civicrm_contact cc ON cc.id = ce.contact_id
 368        {$aclFrom}
 369 WHERE  ce.on_hold = 0 AND cc.is_deceased = 0 AND cc.do_not_email = 0 AND {$queryString}
 370        {$aclWhere}
 371 LIMIT {$rowCount}
 372 )";
 373       }
 374       $query = implode(' UNION ', $queryStrings) . " LIMIT {$rowCount}";
 375
 376       // send query to hook to be modified if needed
 377       CRM_Utils_Hook::contactListQuery($query,
 378         $name,
 379         CRM_Utils_Request::retrieve('context', 'Alphanumeric'),
 380         CRM_Utils_Request::retrieve('cid', 'Positive')
 381       );
 382
 383       $dao = CRM_Core_DAO::executeQuery($query);
 384
 385       while ($dao->fetch()) {
 386         //working here
 387         $result[] = [
 388           'text' => '"' . $dao->name . '" <' . $dao->email . '>',
 389           'id' => (CRM_Utils_Array::value('id', $_GET)) ? "{$dao->id}::{$dao->email}" : '"' . $dao->name . '" <' . $dao->email . '>',
 390         ];
 391       }
 392       CRM_Utils_JSON::output($result);
 393     }
 394     CRM_Utils_System::civiExit();
 395   }
 396
 397   public static function getContactPhone() {
 398
 399     $queryString = NULL;
 400     $sqlParmas = [];
 401     //check for mobile type
 402     $phoneTypes = CRM_Core_OptionGroup::values('phone_type', TRUE, FALSE, FALSE, NULL, 'name');
 403     $mobileType = $phoneTypes['Mobile'] ?? NULL;
 404
 405     $name = CRM_Utils_Request::retrieveValue('name', 'String', NULL, FALSE, 'GET');
 406     if ($name) {
 407       $key = (int) count(array_keys($sqlParmas)) + 1;
 408       $queryString = " ( cc.sort_name LIKE %{$key} OR cp.phone LIKE %{$key} ) ";
 409       $sqlParams[$key] = ['%' . $name . '%', 'String'];
 410     }
 411     else {
 412       $cid = CRM_Utils_Request::retrieveValue('cid', 'CommaSeparatedIntegers', NULL, FALSE, 'GET');
 413       if ($cid) {
 414         $queryString = " cc.id IN ( $cid )";
 415       }
 416     }
 417
 418     if ($queryString) {
 419       $result = [];
 420       $offset = (int) CRM_Utils_Request::retrieveValue('offset', 'Integer', 0, FALSE, 'GET');
 421       $rowCount = (int) CRM_Utils_Request::retrieveValue('rowcount', 'Integer', 20, FALSE, 'GET');
 422
 423       // add acl clause here
 424       list($aclFrom, $aclWhere) = CRM_Contact_BAO_Contact_Permission::cacheClause('cc');
 425       if ($aclWhere) {
 426         $aclWhere = " AND $aclWhere";
 427       }
 428
 429       $query = "
 430 SELECT sort_name name, cp.phone, cc.id
 431 FROM   civicrm_phone cp INNER JOIN civicrm_contact cc ON cc.id = cp.contact_id
 432        {$aclFrom}
 433 WHERE  cc.is_deceased = 0 AND cc.do_not_sms = 0 AND cp.phone_type_id = {$mobileType} AND {$queryString}
 434        {$aclWhere}
 435 LIMIT {$offset}, {$rowCount}
 436 ";
 437
 438       // send query to hook to be modified if needed
 439       CRM_Utils_Hook::contactListQuery($query,
 440         $name,
 441         CRM_Utils_Request::retrieve('context', 'Alphanumeric'),
 442         CRM_Utils_Request::retrieve('cid', 'Positive')
 443       );
 444
 445       $dao = CRM_Core_DAO::executeQuery($query, $sqlParams);
 446
 447       while ($dao->fetch()) {
 448         $result[] = [
 449           'text' => '"' . $dao->name . '" (' . $dao->phone . ')',
 450           'id' => (CRM_Utils_Array::value('id', $_GET)) ? "{$dao->id}::{$dao->phone}" : '"' . $dao->name . '" <' . $dao->phone . '>',
 451         ];
 452       }
 453       CRM_Utils_JSON::output($result);
 454     }
 455     CRM_Utils_System::civiExit();
 456   }
 457
 458   public static function buildSubTypes() {
 459     $parent = CRM_Utils_Request::retrieve('parentId', 'Positive');
 460
 461     switch ($parent) {
 462       case 1:
 463         $contactType = 'Individual';
 464         break;
 465
 466       case 2:
 467         $contactType = 'Household';
 468         break;
 469
 470       case 4:
 471         $contactType = 'Organization';
 472         break;
 473     }
 474
 475     $subTypes = CRM_Contact_BAO_ContactType::subTypePairs($contactType, FALSE, NULL);
 476     asort($subTypes);
 477     CRM_Utils_JSON::output($subTypes);
 478   }
 479
 480   public static function buildDedupeRules() {
 481     $parent = CRM_Utils_Request::retrieve('parentId', 'Positive');
 482
 483     switch ($parent) {
 484       case 1:
 485         $contactType = 'Individual';
 486         break;
 487
 488       case 2:
 489         $contactType = 'Household';
 490         break;
 491
 492       case 4:
 493         $contactType = 'Organization';
 494         break;
 495     }
 496
 497     $dedupeRules = CRM_Dedupe_BAO_RuleGroup::getByType($contactType);
 498
 499     CRM_Utils_JSON::output($dedupeRules);
 500   }
 501
 502   /**
 503    * Function used for CiviCRM dashboard operations.
 504    */
 505   public static function dashboard() {
 506     switch ($_REQUEST['op']) {
 507       case 'save_columns':
 508         CRM_Core_BAO_Dashboard::saveDashletChanges($_REQUEST['columns'] ?? NULL);
 509         break;
 510
 511       case 'delete_dashlet':
 512         $dashletID = CRM_Utils_Type::escape($_REQUEST['dashlet_id'], 'Positive');
 513         CRM_Core_DAO_Dashboard::deleteRecord(['id' => $dashletID]);
 514     }
 515
 516     CRM_Utils_System::civiExit();
 517   }
 518
 519   /**
 520    * Retrieve signature based on email id.
 521    */
 522   public static function getSignature() {
 523     $emailID = CRM_Utils_Type::escape($_REQUEST['emailID'], 'Positive');
 524     $query = "SELECT signature_text, signature_html FROM civicrm_email WHERE id = {$emailID}";
 525     $dao = CRM_Core_DAO::executeQuery($query);
 526
 527     $signatures = [];
 528     while ($dao->fetch()) {
 529       $signatures = [
 530         'signature_text' => $dao->signature_text,
 531         'signature_html' => $dao->signature_html,
 532       ];
 533     }
 534
 535     CRM_Utils_JSON::output($signatures);
 536   }
 537
 538   /**
 539    * Process dupes.
 540    */
 541   public static function processDupes() {
 542     $oper = CRM_Utils_Type::escape($_REQUEST['op'], 'String');
 543     $cid = CRM_Utils_Type::escape($_REQUEST['cid'], 'Positive');
 544     $oid = CRM_Utils_Type::escape($_REQUEST['oid'], 'Positive');
 545
 546     if (!$oper || !$cid || !$oid) {
 547       return;
 548     }
 549
 550     $status = self::markNonDuplicates($cid, $oid, $oper);
 551
 552     CRM_Utils_JSON::output(['status' => ($status) ? $oper : $status]);
 553   }
 554
 555   /**
 556    * Retrieve list of duplicate pairs from cache table.
 557    */
 558   public static function getDedupes() {
 559     $offset    = isset($_REQUEST['start']) ? CRM_Utils_Type::escape($_REQUEST['start'], 'Integer') : 0;
 560     $rowCount  = isset($_REQUEST['length']) ? CRM_Utils_Type::escape($_REQUEST['length'], 'Integer') : 25;
 561
 562     $gid = CRM_Utils_Request::retrieve('gid', 'Positive');
 563     $rgid = CRM_Utils_Request::retrieve('rgid', 'Positive');
 564     $limit = CRM_Utils_Request::retrieveValue('limit', 'Positive', 0);
 565     $null = NULL;
 566     $criteria = CRM_Utils_Request::retrieve('criteria', 'Json', $null, FALSE, '{}');
 567     $selected = CRM_Utils_Request::retrieveValue('selected', 'Boolean');
 568     if ($rowCount < 0) {
 569       $rowCount = 0;
 570     }
 571
 572     $whereClause = $orderByClause = '';
 573     $cacheKeyString   = CRM_Dedupe_Merger::getMergeCacheKeyString($rgid, $gid, json_decode($criteria, TRUE), TRUE, $limit);
 574
 575     $searchRows = [];
 576
 577     $searchParams = self::getSearchOptionsFromRequest();
 578     $queryParams = [];
 579
 580     $join  = '';
 581     $where = [];
 582
 583     $isOrQuery = self::isOrQuery();
 584
 585     $nextParamKey = 3;
 586     $mappings = [
 587       'dst' => 'cc1.display_name',
 588       'src' => 'cc2.display_name',
 589       'dst_email' => 'ce1.email',
 590       'src_email' => 'ce2.email',
 591       'dst_postcode' => 'ca1.postal_code',
 592       'src_postcode' => 'ca2.postal_code',
 593       'dst_street' => 'ca1.street',
 594       'src_street' => 'ca2.street',
 595     ];
 596
 597     foreach ($mappings as $key => $dbName) {
 598       if (!empty($searchParams[$key])) {
 599         // CRM-18694.
 600         $wildcard = strstr($key, 'postcode') ? '' : '%';
 601         $queryParams[$nextParamKey] = [$wildcard . $searchParams[$key] . '%', 'String'];
 602         $where[] = $dbName . " LIKE %{$nextParamKey} ";
 603         $nextParamKey++;
 604       }
 605     }
 606
 607     if ($isOrQuery) {
 608       $whereClause = ' ( ' . implode(' OR ', $where) . ' ) ';
 609     }
 610     else {
 611       if (!empty($where)) {
 612         $whereClause = implode(' AND ', $where);
 613       }
 614     }
 615     $whereClause .= $whereClause ? ' AND de.id IS NULL' : ' de.id IS NULL';
 616
 617     if ($selected) {
 618       $whereClause .= ' AND pn.is_selected = 1';
 619     }
 620     $join .= CRM_Dedupe_Merger::getJoinOnDedupeTable();
 621
 622     $select = [
 623       'cc1.contact_type'     => 'dst_contact_type',
 624       'cc1.display_name'     => 'dst_display_name',
 625       'cc1.contact_sub_type' => 'dst_contact_sub_type',
 626       'cc2.contact_type'     => 'src_contact_type',
 627       'cc2.display_name'     => 'src_display_name',
 628       'cc2.contact_sub_type' => 'src_contact_sub_type',
 629       'ce1.email'            => 'dst_email',
 630       'ce2.email'            => 'src_email',
 631       'ca1.postal_code'      => 'dst_postcode',
 632       'ca2.postal_code'      => 'src_postcode',
 633       'ca1.street_address'   => 'dst_street',
 634       'ca2.street_address'   => 'src_street',
 635     ];
 636
 637     if ($select) {
 638       $join .= " INNER JOIN civicrm_contact cc1 ON cc1.id = pn.entity_id1";
 639       $join .= " INNER JOIN civicrm_contact cc2 ON cc2.id = pn.entity_id2";
 640       $join .= " LEFT JOIN civicrm_email ce1 ON (ce1.contact_id = pn.entity_id1 AND ce1.is_primary = 1 )";
 641       $join .= " LEFT JOIN civicrm_email ce2 ON (ce2.contact_id = pn.entity_id2 AND ce2.is_primary = 1 )";
 642       $join .= " LEFT JOIN civicrm_address ca1 ON (ca1.contact_id = pn.entity_id1 AND ca1.is_primary = 1 )";
 643       $join .= " LEFT JOIN civicrm_address ca2 ON (ca2.contact_id = pn.entity_id2 AND ca2.is_primary = 1 )";
 644     }
 645     $iTotal = CRM_Core_BAO_PrevNextCache::getCount($cacheKeyString, $join, $whereClause, '=', $queryParams);
 646     if (!empty($_REQUEST['order'])) {
 647       foreach ($_REQUEST['order'] as $orderInfo) {
 648         if (!empty($orderInfo['column'])) {
 649           $orderColumnNumber = $orderInfo['column'];
 650           $dir = CRM_Utils_Type::escape($orderInfo['dir'], 'MysqlOrderByDirection', FALSE);
 651         }
 652       }
 653       $columnDetails = $_REQUEST['columns'][$orderColumnNumber] ?? NULL;
 654     }
 655     if (!empty($columnDetails)) {
 656       switch ($columnDetails['data']) {
 657         case 'src':
 658           $orderByClause = " ORDER BY cc2.display_name {$dir}";
 659           break;
 660
 661         case 'src_email':
 662           $orderByClause = " ORDER BY ce2.email {$dir}";
 663           break;
 664
 665         case 'src_street':
 666           $orderByClause = " ORDER BY ca2.street_address {$dir}";
 667           break;
 668
 669         case 'src_postcode':
 670           $orderByClause = " ORDER BY ca2.postal_code {$dir}";
 671           break;
 672
 673         case 'dst':
 674           $orderByClause = " ORDER BY cc1.display_name {$dir}";
 675           break;
 676
 677         case 'dst_email':
 678           $orderByClause = " ORDER BY ce1.email {$dir}";
 679           break;
 680
 681         case 'dst_street':
 682           $orderByClause = " ORDER BY ca1.street_address {$dir}";
 683           break;
 684
 685         case 'dst_postcode':
 686           $orderByClause = " ORDER BY ca1.postal_code {$dir}";
 687           break;
 688
 689         default:
 690           $orderByClause = " ORDER BY cc1.display_name ASC";
 691           break;
 692       }
 693     }
 694
 695     $dupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, $join, $whereClause, $offset, $rowCount, $select, $orderByClause, TRUE, $queryParams);
 696     $iFilteredTotal = CRM_Core_DAO::singleValueQuery("SELECT FOUND_ROWS()");
 697
 698     $count = 0;
 699     foreach ($dupePairs as $key => $pairInfo) {
 700       $pair = $pairInfo['data'];
 701       $srcContactSubType  = $pairInfo['src_contact_sub_type'] ?? NULL;
 702       $dstContactSubType  = $pairInfo['dst_contact_sub_type'] ?? NULL;
 703       $srcTypeImage = CRM_Contact_BAO_Contact_Utils::getImage($srcContactSubType ?
 704         $srcContactSubType : $pairInfo['src_contact_type'],
 705         FALSE,
 706         $pairInfo['entity_id2']
 707       );
 708       $dstTypeImage = CRM_Contact_BAO_Contact_Utils::getImage($dstContactSubType ?
 709         $dstContactSubType : $pairInfo['dst_contact_type'],
 710         FALSE,
 711         $pairInfo['entity_id1']
 712       );
 713
 714       $searchRows[$count]['is_selected'] = $pairInfo['is_selected'];
 715       $searchRows[$count]['is_selected_input'] = "<input type='checkbox' class='crm-dedupe-select' name='pnid_{$pairInfo['prevnext_id']}' value='{$pairInfo['is_selected']}' onclick='toggleDedupeSelect(this)'>";
 716       $searchRows[$count]['src_image'] = $srcTypeImage;
 717       $searchRows[$count]['src'] = CRM_Utils_System::href($pair['srcName'], 'civicrm/contact/view', "reset=1&cid={$pairInfo['entity_id2']}");
 718       $searchRows[$count]['src_email'] = $pairInfo['src_email'] ?? NULL;
 719       $searchRows[$count]['src_street'] = $pairInfo['src_street'] ?? NULL;
 720       $searchRows[$count]['src_postcode'] = $pairInfo['src_postcode'] ?? NULL;
 721       $searchRows[$count]['dst_image'] = $dstTypeImage;
 722       $searchRows[$count]['dst'] = CRM_Utils_System::href($pair['dstName'], 'civicrm/contact/view', "reset=1&cid={$pairInfo['entity_id1']}");
 723       $searchRows[$count]['dst_email'] = $pairInfo['dst_email'] ?? NULL;
 724       $searchRows[$count]['dst_street'] = $pairInfo['dst_street'] ?? NULL;
 725       $searchRows[$count]['dst_postcode'] = $pairInfo['dst_postcode'] ?? NULL;
 726       $searchRows[$count]['conflicts'] = str_replace("',", "',<br/>", CRM_Utils_Array::value('conflicts', $pair));
 727       $searchRows[$count]['weight'] = $pair['weight'] ?? NULL;
 728
 729       if (!empty($pairInfo['data']['canMerge'])) {
 730         $mergeParams = [
 731           'reset' => 1,
 732           'cid' => $pairInfo['entity_id1'],
 733           'oid' => $pairInfo['entity_id2'],
 734           'action' => 'update',
 735           'rgid' => $rgid,
 736           'criteria' => $criteria,
 737           'limit' => CRM_Utils_Request::retrieve('limit', 'Integer'),
 738         ];
 739         if ($gid) {
 740           $mergeParams['gid'] = $gid;
 741         }
 742
 743         $searchRows[$count]['actions']  = "<a class='crm-dedupe-flip' href='#' data-pnid={$pairInfo['prevnext_id']}>" . ts('flip') . "</a>&nbsp;|&nbsp;";
 744         $searchRows[$count]['actions'] .= CRM_Utils_System::href(ts('merge'), 'civicrm/contact/merge', $mergeParams);
 745         $searchRows[$count]['actions'] .= "&nbsp;|&nbsp;<a id='notDuplicate' href='#' onClick=\"processDupes( {$pairInfo['entity_id1']}, {$pairInfo['entity_id2']}, 'dupe-nondupe', 'dupe-listing'); return false;\">" . ts('not a duplicate') . "</a>";
 746       }
 747       else {
 748         $searchRows[$count]['actions'] = '<em>' . ts('Insufficient access rights - cannot merge') . '</em>';
 749       }
 750       $count++;
 751     }
 752
 753     $dupePairs = [
 754       'data'            => $searchRows,
 755       'recordsTotal'    => $iTotal,
 756       'recordsFiltered' => $iFilteredTotal,
 757     ];
 758     if (!empty($_REQUEST['is_unit_test'])) {
 759       return $dupePairs;
 760     }
 761     CRM_Utils_JSON::output($dupePairs);
 762   }
 763
 764   /**
 765    * Get the searchable options from the request.
 766    *
 767    * @return array
 768    */
 769   public static function getSearchOptionsFromRequest() {
 770     $searchParams = [];
 771     $searchData = $_REQUEST['search'] ?? NULL;
 772     $searchData['value'] = CRM_Utils_Type::escape($searchData['value'] ?? NULL, 'String');
 773     $selectorElements = [
 774       'is_selected',
 775       'is_selected_input',
 776       'src_image',
 777       'src',
 778       'src_email',
 779       'src_street',
 780       'src_postcode',
 781       'dst_image',
 782       'dst',
 783       'dst_email',
 784       'dst_street',
 785       'dst_postcode',
 786       'conflicts',
 787       'weight',
 788       'actions',
 789     ];
 790     $columns = $_REQUEST['columns'];
 791
 792     foreach ($columns as $column) {
 793       if (!empty($column['search']['value']) && in_array($column['data'], $selectorElements)) {
 794         $searchParams[$column['data']] = CRM_Utils_Type::escape($column['search']['value'], 'String');
 795       }
 796       elseif (!empty($searchData['value'])) {
 797         $searchParams[$column['data']] = $searchData['value'];
 798       }
 799     }
 800     return $searchParams;
 801   }
 802
 803   /**
 804    * Is the query an OR query.
 805    *
 806    * If a generic search value is passed in - ie. $_REQUEST['search']['value'] = 'abc'
 807    * then all fields are searched for this.
 808    *
 809    * It is unclear if there is any code that still passes this in or whether is is just legacy. It
 810    * could cause a server-killing query on a large site so it probably is NOT in use if we haven't
 811    * had complaints.
 812    *
 813    * @return bool
 814    */
 815   public static function isOrQuery() {
 816     $searchData = $_REQUEST['search'] ?? NULL;
 817     return !empty($searchData['value']);
 818   }
 819
 820   /**
 821    * Mark not duplicates.
 822    *
 823    * Note this function would sensibly be replaced by an api-call but extracting here to add a test first.
 824    *
 825    * I would have like to make it private but test class accesses it & it doesn't warrant being a BAO class
 826    * as it should feel very endangered.
 827    *
 828    * @param int $cid
 829    * @param int $oid
 830    * @param "dupe-nondupe|nondupe-dupe" $oper
 831    *
 832    * @return \CRM_Core_DAO|mixed|null
 833    */
 834   public static function markNonDuplicates($cid, $oid, $oper) {
 835     if ($oper == 'dupe-nondupe') {
 836       try {
 837         civicrm_api3('Exception', 'create', ['contact_id1' => $cid, 'contact_id2' => $oid]);
 838         return TRUE;
 839       }
 840       catch (CiviCRM_API3_Exception $e) {
 841         return FALSE;
 842       }
 843     }
 844
 845     $exception = new CRM_Dedupe_DAO_Exception();
 846     $exception->contact_id1 = $cid;
 847     $exception->contact_id2 = $oid;
 848     //make sure contact2 > contact1.
 849     if ($cid > $oid) {
 850       $exception->contact_id1 = $oid;
 851       $exception->contact_id2 = $cid;
 852     }
 853     $exception->find(TRUE);
 854     $status = NULL;
 855
 856     if ($oper == 'nondupe-dupe') {
 857       $status = $exception->delete();
 858     }
 859     return $status;
 860   }
 861
 862   /**
 863    * Retrieve a PDF Page Format for the PDF Letter form.
 864    */
 865   public function pdfFormat() {
 866     $formatId = CRM_Utils_Type::escape($_REQUEST['formatId'], 'Integer');
 867
 868     $pdfFormat = CRM_Core_BAO_PdfFormat::getById($formatId);
 869
 870     CRM_Utils_JSON::output($pdfFormat);
 871   }
 872
 873   /**
 874    * Retrieve Paper Size dimensions.
 875    */
 876   public static function paperSize() {
 877     $paperSizeName = CRM_Utils_Type::escape($_REQUEST['paperSizeName'], 'String');
 878
 879     $paperSize = CRM_Core_BAO_PaperSize::getByName($paperSizeName);
 880
 881     CRM_Utils_JSON::output($paperSize);
 882   }
 883
 884   /**
 885    * Swap contacts in a dupe pair i.e main with duplicate contact.
 886    *
 887    * @param int $prevNextId
 888    */
 889   public static function flipDupePairs($prevNextId = NULL) {
 890     if (!$prevNextId) {
 891       // @todo figure out if this is always POST & specify that rather than inexact GET
 892
 893       // We cannot use CRM_Utils_Request::retrieve() because it might be an array.
 894       // It later gets validated in escapeAll below.
 895       $prevNextId = $_REQUEST['pnid'];
 896     }
 897
 898     $onlySelected = FALSE;
 899     if (is_array($prevNextId) && !CRM_Utils_Array::crmIsEmptyArray($prevNextId)) {
 900       $onlySelected = TRUE;
 901     }
 902     $prevNextId = CRM_Utils_Type::escapeAll((array) $prevNextId, 'Positive');
 903     CRM_Core_BAO_PrevNextCache::flipPair($prevNextId, $onlySelected);
 904     CRM_Utils_System::civiExit();
 905   }
 906
 907   /**
 908    * Used to store selected contacts across multiple pages in advanced search.
 909    */
 910   public static function selectUnselectContacts() {
 911     $name = $_REQUEST['name'] ?? NULL;
 912     $cacheKey = $_REQUEST['qfKey'] ?? NULL;
 913     $state = CRM_Utils_Array::value('state', $_REQUEST, 'checked');
 914     $variableType = CRM_Utils_Array::value('variableType', $_REQUEST, 'single');
 915
 916     $actionToPerform = CRM_Utils_Array::value('action', $_REQUEST, 'select');
 917
 918     if ($variableType == 'multiple') {
 919       // action post value only works with multiple type variable
 920       if ($name) {
 921         //multiple names like mark_x_1-mark_x_2 where 1,2 are cids
 922         $elements = explode('-', $name);
 923         foreach ($elements as $key => $element) {
 924           $elements[$key] = self::_convertToId($element);
 925         }
 926         CRM_Utils_Type::escapeAll($elements, 'Integer');
 927         Civi::service('prevnext')->markSelection($cacheKey, $actionToPerform, $elements);
 928       }
 929       else {
 930         Civi::service('prevnext')->markSelection($cacheKey, $actionToPerform);
 931       }
 932     }
 933     elseif ($variableType == 'single') {
 934       $cId = self::_convertToId($name);
 935       CRM_Utils_Type::escape($cId, 'Integer');
 936       $action = ($state == 'checked') ? 'select' : 'unselect';
 937       Civi::service('prevnext')->markSelection($cacheKey, $action, $cId);
 938     }
 939     $contactIds = Civi::service('prevnext')->getSelection($cacheKey);
 940     $countSelectionCids = count($contactIds[$cacheKey]);
 941
 942     $arrRet = ['getCount' => $countSelectionCids];
 943     CRM_Utils_JSON::output($arrRet);
 944   }
 945
 946   /**
 947    * @param string $name
 948    *
 949    * @return string
 950    */
 951   public static function _convertToId($name) {
 952     if (substr($name, 0, CRM_Core_Form::CB_PREFIX_LEN) == CRM_Core_Form::CB_PREFIX) {
 953       $cId = substr($name, CRM_Core_Form::CB_PREFIX_LEN);
 954     }
 955     return $cId;
 956   }
 957
 958   public static function getAddressDisplay() {
 959     $contactId = CRM_Utils_Request::retrieve('contact_id', 'Positive');
 960     if (!$contactId) {
 961       $addressVal["error_message"] = "no contact id found";
 962     }
 963     else {
 964       $entityBlock = [
 965         'contact_id' => $contactId,
 966         'entity_id' => $contactId,
 967       ];
 968       $addressVal = CRM_Core_BAO_Address::getValues($entityBlock);
 969     }
 970
 971     CRM_Utils_JSON::output($addressVal);
 972   }
 973
 974   /**
 975    * Mark dupe pairs as selected from un-selected state or vice-versa, in dupe cache table.
 976    */
 977   public static function toggleDedupeSelect() {
 978     $pnid = $_REQUEST['pnid'];
 979     $isSelected = CRM_Utils_Type::escape($_REQUEST['is_selected'], 'Boolean');
 980     $cacheKeyString = CRM_Utils_Request::retrieve('cacheKey', 'Alphanumeric', $null, FALSE);
 981
 982     $params = [
 983       1 => [$isSelected, 'Boolean'],
 984       // using % to address rows with conflicts as well
 985       3 => ["$cacheKeyString%", 'String'],
 986     ];
 987
 988     //check pnid is_array or integer
 989     $whereClause = NULL;
 990     if (is_array($pnid) && !CRM_Utils_Array::crmIsEmptyArray($pnid)) {
 991       CRM_Utils_Type::escapeAll($pnid, 'Positive');
 992       $pnid = implode(', ', $pnid);
 993       $whereClause = " id IN ( {$pnid} ) ";
 994     }
 995     else {
 996       $pnid = CRM_Utils_Type::escape($pnid, 'Integer');
 997       $whereClause = " id = %2";
 998       $params[2]   = [$pnid, 'Integer'];
 999     }
1000
1001     $sql = "UPDATE civicrm_prevnext_cache SET is_selected = %1 WHERE {$whereClause} AND cachekey LIKE %3";
1002     CRM_Core_DAO::executeQuery($sql, $params);
1003
1004     CRM_Utils_System::civiExit();
1005   }
1006
1007   /**
1008    * Retrieve contact relationships.
1009    */
1010   public static function getContactRelationships() {
1011     $contactID = CRM_Utils_Type::escape($_GET['cid'], 'Integer');
1012     $context = CRM_Utils_Request::retrieve('context', 'Alphanumeric');
1013     $relationship_type_id = CRM_Utils_Type::escape(CRM_Utils_Array::value('relationship_type_id', $_GET), 'Integer', FALSE);
1014
1015     if (!CRM_Contact_BAO_Contact_Permission::allow($contactID)) {
1016       return CRM_Utils_System::permissionDenied();
1017     }
1018
1019     $params = CRM_Core_Page_AJAX::defaultSortAndPagerParams();
1020
1021     $params['contact_id'] = $contactID;
1022     $params['context'] = $context;
1023     if ($relationship_type_id) {
1024       $params['relationship_type_id'] = $relationship_type_id;
1025     }
1026
1027     // get the contact relationships
1028     $relationships = CRM_Contact_BAO_Relationship::getContactRelationshipSelector($params);
1029
1030     CRM_Utils_JSON::output($relationships);
1031   }
1032
1033 }