CRM/Contact/Selector.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 5                                                  |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2018                                |
   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-2018
  32  */
  33
  34 /**
  35  * Class is to retrieve and display a range of contacts that match the given criteria.
  36  *
  37  * It is specifically for results of advanced search options.
  38  */
  39 class CRM_Contact_Selector extends CRM_Core_Selector_Base implements CRM_Core_Selector_API {
  40
  41   const CACHE_SIZE = 500;
  42
  43   /**
  44    * This defines two actions- View and Edit.
  45    *
  46    * @var array
  47    */
  48   static $_links = NULL;
  49
  50   /**
  51    * We use desc to remind us what that column is, name is used in the tpl
  52    *
  53    * @var array
  54    */
  55   static $_columnHeaders;
  56
  57   /**
  58    * Properties of contact we're interested in displaying
  59    * @var array
  60    */
  61   static $_properties = array(
  62     'contact_id',
  63     'contact_type',
  64     'contact_sub_type',
  65     'sort_name',
  66     'street_address',
  67     'city',
  68     'state_province',
  69     'postal_code',
  70     'country',
  71     'geo_code_1',
  72     'geo_code_2',
  73     'is_deceased',
  74     'email',
  75     'on_hold',
  76     'phone',
  77     'status',
  78     'do_not_email',
  79     'do_not_phone',
  80     'do_not_mail',
  81   );
  82
  83   /**
  84    * FormValues is the array returned by exportValues called on
  85    * the HTML_QuickForm_Controller for that page.
  86    *
  87    * @var array
  88    */
  89   public $_formValues;
  90
  91   /**
  92    * The contextMenu
  93    *
  94    * @var array
  95    */
  96   protected $_contextMenu;
  97
  98   /**
  99    * Params is the array in a value used by the search query creator
 100    *
 101    * @var array
 102    */
 103   public $_params;
 104
 105   /**
 106    * The return properties used for search
 107    *
 108    * @var array
 109    */
 110   protected $_returnProperties;
 111
 112   /**
 113    * Represent the type of selector
 114    *
 115    * @var int
 116    */
 117   protected $_action;
 118
 119   protected $_searchContext;
 120
 121   /**
 122    * Query object for this selector.
 123    *
 124    * @var CRM_Contact_BAO_Query
 125    */
 126   protected $_query;
 127
 128   /**
 129    * Get the query object for this selector.
 130    *
 131    * @return CRM_Contact_BAO_Query
 132    */
 133   public function getQueryObject() {
 134     return $this->_query;
 135   }
 136
 137   /**
 138    * Group id
 139    *
 140    * @var int
 141    */
 142   protected $_ufGroupID;
 143
 144   /**
 145    * The public visible fields to be shown to the user
 146    *
 147    * @var array
 148    */
 149   protected $_fields;
 150
 151   /**
 152    * Class constructor.
 153    *
 154    * @param $customSearchClass
 155    * @param array $formValues
 156    *   Array of form values imported.
 157    * @param array $params
 158    *   Array of parameters for query.
 159    * @param null $returnProperties
 160    * @param \const|int $action - action of search basic or advanced.
 161    *
 162    * @param bool $includeContactIds
 163    * @param bool $searchDescendentGroups
 164    * @param string $searchContext
 165    * @param null $contextMenu
 166    *
 167    * @return CRM_Contact_Selector
 168    */
 169   public function __construct(
 170     $customSearchClass,
 171     $formValues = NULL,
 172     $params = NULL,
 173     $returnProperties = NULL,
 174     $action = CRM_Core_Action::NONE,
 175     $includeContactIds = FALSE,
 176     $searchDescendentGroups = TRUE,
 177     $searchContext = 'search',
 178     $contextMenu = NULL
 179   ) {
 180     //don't build query constructor, if form is not submitted
 181     $force = CRM_Utils_Request::retrieve('force', 'Boolean');
 182     if (empty($formValues) && !$force) {
 183       return;
 184     }
 185
 186     // submitted form values
 187     $this->_formValues = &$formValues;
 188     $this->_params = &$params;
 189     $this->_returnProperties = &$returnProperties;
 190     $this->_contextMenu = &$contextMenu;
 191     $this->_context = $searchContext;
 192
 193     // type of selector
 194     $this->_action = $action;
 195
 196     $this->_searchContext = $searchContext;
 197
 198     $this->_ufGroupID = CRM_Utils_Array::value('uf_group_id', $this->_formValues);
 199
 200     if ($this->_ufGroupID) {
 201       $this->_fields = CRM_Core_BAO_UFGroup::getListingFields(CRM_Core_Action::VIEW,
 202         CRM_Core_BAO_UFGroup::PUBLIC_VISIBILITY |
 203         CRM_Core_BAO_UFGroup::LISTINGS_VISIBILITY,
 204         FALSE, $this->_ufGroupID
 205       );
 206       self::$_columnHeaders = NULL;
 207
 208       $this->_customFields = CRM_Core_BAO_CustomField::getFieldsForImport('Individual');
 209
 210       $this->_returnProperties = CRM_Contact_BAO_Contact::makeHierReturnProperties($this->_fields);
 211       $this->_returnProperties['contact_type'] = 1;
 212       $this->_returnProperties['contact_sub_type'] = 1;
 213       $this->_returnProperties['sort_name'] = 1;
 214     }
 215
 216     $displayRelationshipType = CRM_Utils_Array::value('display_relationship_type', $this->_formValues);
 217     $operator = CRM_Utils_Array::value('operator', $this->_formValues, 'AND');
 218
 219     // rectify params to what proximity search expects if there is a value for prox_distance
 220     // CRM-7021
 221     if (!empty($this->_params)) {
 222       CRM_Contact_BAO_ProximityQuery::fixInputParams($this->_params);
 223     }
 224
 225     $this->_query = new CRM_Contact_BAO_Query(
 226       $this->_params,
 227       $this->_returnProperties,
 228       NULL,
 229       $includeContactIds,
 230       FALSE,
 231       CRM_Contact_BAO_Query::MODE_CONTACTS,
 232       FALSE,
 233       $searchDescendentGroups,
 234       FALSE,
 235       $displayRelationshipType,
 236       $operator
 237     );
 238
 239     $this->_options = &$this->_query->_options;
 240   }
 241
 242   /**
 243    * This method set cache key, later used in test environment
 244    *
 245    * @param string $key
 246    */
 247   public function setKey($key) {
 248     $this->_key = $key;
 249   }
 250
 251   /**
 252    * This method returns the links that are given for each search row.
 253    * currently the links added for each row are
 254    *
 255    * - View
 256    * - Edit
 257    *
 258    * @return array
 259    */
 260   public static function &links() {
 261     list($context, $contextMenu, $key) = func_get_args();
 262     $extraParams = ($key) ? "&key={$key}" : NULL;
 263     $searchContext = ($context) ? "&context=$context" : NULL;
 264
 265     if (!(self::$_links)) {
 266       self::$_links = array(
 267         CRM_Core_Action::VIEW => array(
 268           'name' => ts('View'),
 269           'url' => 'civicrm/contact/view',
 270           'class' => 'no-popup',
 271           'qs' => "reset=1&cid=%%id%%{$searchContext}{$extraParams}",
 272           'title' => ts('View Contact Details'),
 273           'ref' => 'view-contact',
 274         ),
 275         CRM_Core_Action::UPDATE => array(
 276           'name' => ts('Edit'),
 277           'url' => 'civicrm/contact/add',
 278           'class' => 'no-popup',
 279           'qs' => "reset=1&action=update&cid=%%id%%{$searchContext}{$extraParams}",
 280           'title' => ts('Edit Contact Details'),
 281           'ref' => 'edit-contact',
 282         ),
 283       );
 284
 285       $config = CRM_Core_Config::singleton();
 286       //CRM-16552: mapAPIKey is not mandatory as google no longer requires an API Key
 287       if ($config->mapProvider && ($config->mapAPIKey || $config->mapProvider == 'Google')) {
 288         self::$_links[CRM_Core_Action::MAP] = array(
 289           'name' => ts('Map'),
 290           'url' => 'civicrm/contact/map',
 291           'qs' => "reset=1&cid=%%id%%{$searchContext}{$extraParams}",
 292           'title' => ts('Map Contact'),
 293         );
 294       }
 295
 296       // Adding Context Menu Links in more action
 297       if ($contextMenu) {
 298         $counter = 7000;
 299         foreach ($contextMenu as $key => $value) {
 300           $contextVal = '&context=' . $value['key'];
 301           if ($value['key'] == 'delete') {
 302             $contextVal = $searchContext;
 303           }
 304           $url = "civicrm/contact/view/{$value['key']}";
 305           $qs = "reset=1&action=add&cid=%%id%%{$contextVal}{$extraParams}";
 306           if ($value['key'] == 'activity') {
 307             $qs = "action=browse&selectedChild=activity&reset=1&cid=%%id%%{$extraParams}";
 308           }
 309           elseif ($value['key'] == 'email') {
 310             $url = "civicrm/contact/view/activity";
 311             $qs = "atype=3&action=add&reset=1&cid=%%id%%{$extraParams}";
 312           }
 313
 314           self::$_links[$counter++] = array(
 315             'name' => $value['title'],
 316             'url' => $url,
 317             'qs' => $qs,
 318             'title' => $value['title'],
 319             'ref' => $value['ref'],
 320             'class' => CRM_Utils_Array::value('class', $value),
 321           );
 322         }
 323       }
 324     }
 325     return self::$_links;
 326   }
 327
 328   /**
 329    * Getter for array of the parameters required for creating pager.
 330    *
 331    * @param $action
 332    * @param array $params
 333    */
 334   public function getPagerParams($action, &$params) {
 335     $params['status'] = ts('Contact %%StatusMessage%%');
 336     $params['csvString'] = NULL;
 337     $params['rowCount'] = CRM_Utils_Pager::ROWCOUNT;
 338
 339     $params['buttonTop'] = 'PagerTopButton';
 340     $params['buttonBottom'] = 'PagerBottomButton';
 341   }
 342
 343   /**
 344    * @param null $action
 345    * @param null $output
 346    *
 347    * @return array
 348    */
 349   public function &getColHeads($action = NULL, $output = NULL) {
 350     $colHeads = self::_getColumnHeaders();
 351     $colHeads[] = array('desc' => ts('Actions'), 'name' => ts('Action'));
 352     return $colHeads;
 353   }
 354
 355   /**
 356    * Returns the column headers as an array of tuples:
 357    * (name, sortName (key to the sort array))
 358    *
 359    * @param string $action
 360    *   The action being performed.
 361    * @param string $output
 362    *   What should the result set include (web/email/csv).
 363    *
 364    * @return array
 365    *   the column headers that need to be displayed
 366    */
 367   public function &getColumnHeaders($action = NULL, $output = NULL) {
 368     $headers = NULL;
 369
 370     // unset return property elements that we don't care
 371     if (!empty($this->_returnProperties)) {
 372       $doNotCareElements = array(
 373         'contact_type',
 374         'contact_sub_type',
 375         'sort_name',
 376       );
 377       foreach ($doNotCareElements as $value) {
 378         unset($this->_returnProperties[$value]);
 379       }
 380     }
 381
 382     if ($output == CRM_Core_Selector_Controller::EXPORT) {
 383       $csvHeaders = array(ts('Contact ID'), ts('Contact Type'));
 384       foreach ($this->getColHeads($action, $output) as $column) {
 385         if (array_key_exists('name', $column)) {
 386           $csvHeaders[] = $column['name'];
 387         }
 388       }
 389       $headers = $csvHeaders;
 390     }
 391     elseif ($output == CRM_Core_Selector_Controller::SCREEN) {
 392       $csvHeaders = array(ts('Name'));
 393       foreach ($this->getColHeads($action, $output) as $key => $column) {
 394         if (array_key_exists('name', $column) &&
 395           $column['name'] &&
 396           $column['name'] != ts('Name')
 397         ) {
 398           $csvHeaders[$key] = $column['name'];
 399         }
 400       }
 401       $headers = $csvHeaders;
 402     }
 403     elseif ($this->_ufGroupID) {
 404       // we dont use the cached value of column headers
 405       // since it potentially changed because of the profile selected
 406       static $skipFields = array('group', 'tag');
 407       $direction = CRM_Utils_Sort::ASCENDING;
 408       $empty = TRUE;
 409       if (!self::$_columnHeaders) {
 410         self::$_columnHeaders = array(
 411           array('name' => ''),
 412           array(
 413             'name' => ts('Name'),
 414             'sort' => 'sort_name',
 415             'direction' => CRM_Utils_Sort::ASCENDING,
 416           ),
 417         );
 418
 419         $locationTypes = CRM_Core_DAO_Address::buildOptions('location_type_id', 'validate');
 420
 421         foreach ($this->_fields as $name => $field) {
 422           if (!empty($field['in_selector']) &&
 423             !in_array($name, $skipFields)
 424           ) {
 425             if (strpos($name, '-') !== FALSE) {
 426               list($fieldName, $lType, $type) = CRM_Utils_System::explode('-', $name, 3);
 427
 428               if ($lType == 'Primary') {
 429                 $locationTypeName = 1;
 430               }
 431               else {
 432                 $locationTypeName = $locationTypes[$lType];
 433               }
 434
 435               if (in_array($fieldName, array(
 436                 'phone',
 437                 'im',
 438                 'email',
 439               ))) {
 440                 if ($type) {
 441                   $name = "`$locationTypeName-$fieldName-$type`";
 442                 }
 443                 else {
 444                   $name = "`$locationTypeName-$fieldName`";
 445                 }
 446               }
 447               else {
 448                 $name = "`$locationTypeName-$fieldName`";
 449               }
 450             }
 451             //to handle sort key for Internal contactId.CRM-2289
 452             if ($name == 'id') {
 453               $name = 'contact_id';
 454             }
 455
 456             self::$_columnHeaders[] = array(
 457               'name' => $field['title'],
 458               'sort' => $name,
 459               'direction' => $direction,
 460             );
 461             $direction = CRM_Utils_Sort::DONTCARE;
 462             $empty = FALSE;
 463           }
 464         }
 465
 466         // if we dont have any valid columns, dont add the implicit ones
 467         // this allows the template to check on emptiness of column headers
 468         if ($empty) {
 469           self::$_columnHeaders = array();
 470         }
 471         else {
 472           self::$_columnHeaders[] = array('desc' => ts('Actions'), 'name' => ts('Action'));
 473         }
 474       }
 475       $headers = self::$_columnHeaders;
 476     }
 477     elseif (!empty($this->_returnProperties)) {
 478       self::$_columnHeaders = array(
 479         array('name' => ''),
 480         array(
 481           'name' => ts('Name'),
 482           'sort' => 'sort_name',
 483           'direction' => CRM_Utils_Sort::ASCENDING,
 484         ),
 485       );
 486       $properties = self::makeProperties($this->_returnProperties);
 487
 488       foreach ($properties as $prop) {
 489         if (strpos($prop, '-')) {
 490           list($loc, $fld, $phoneType) = CRM_Utils_System::explode('-', $prop, 3);
 491           $title = $this->_query->_fields[$fld]['title'];
 492           if (trim($phoneType) && !is_numeric($phoneType) && strtolower($phoneType) != $fld) {
 493             $title .= "-{$phoneType}";
 494           }
 495           // fetch Location type label from name as $loc, which will be later used in column header
 496           $title .= sprintf(" (%s)",
 497             CRM_Core_PseudoConstant::getLabel(
 498               'CRM_Core_DAO_Address',
 499               'location_type_id',
 500               CRM_Core_PseudoConstant::getKey('CRM_Core_DAO_Address', 'location_type_id', $loc)
 501             )
 502           );
 503           // use field name instead of table alias
 504           $prop = $fld;
 505         }
 506         elseif (isset($this->_query->_fields[$prop]) && isset($this->_query->_fields[$prop]['title'])) {
 507           $title = $this->_query->_fields[$prop]['title'];
 508         }
 509         elseif (isset($this->_query->_pseudoConstantsSelect[$prop]) && isset($this->_query->_pseudoConstantsSelect[$prop]['pseudoconstant']['optionGroupName'])) {
 510           $title = CRM_Core_BAO_OptionGroup::getTitleByName($this->_query->_pseudoConstantsSelect[$prop]['pseudoconstant']['optionGroupName']);
 511         }
 512         else {
 513           $title = '';
 514         }
 515
 516         self::$_columnHeaders[] = array('name' => $title, 'sort' => $prop);
 517       }
 518       self::$_columnHeaders[] = array('name' => ts('Actions'));
 519       $headers = self::$_columnHeaders;
 520     }
 521     else {
 522       $headers = $this->getColHeads($action, $output);
 523     }
 524
 525     return $headers;
 526   }
 527
 528   /**
 529    * Returns total number of rows for the query.
 530    *
 531    * @param int $action
 532    *
 533    * @return int
 534    *   Total number of rows
 535    */
 536   public function getTotalCount($action) {
 537     // Use count from cache during paging/sorting
 538     if (!empty($_GET['crmPID']) || !empty($_GET['crmSID'])) {
 539       $count = CRM_Core_BAO_Cache::getItem('Search Results Count', $this->_key);
 540     }
 541     if (empty($count)) {
 542       $count = $this->_query->searchQuery(0, 0, NULL, TRUE);
 543       CRM_Core_BAO_Cache::setItem($count, 'Search Results Count', $this->_key);
 544     }
 545     return $count;
 546   }
 547
 548   /**
 549    * Returns all the rows in the given offset and rowCount.
 550    *
 551    * @param string $action
 552    *   The action being performed.
 553    * @param int $offset
 554    *   The row number to start from.
 555    * @param int $rowCount
 556    *   The number of rows to return.
 557    * @param string $sort
 558    *   The sql string that describes the sort order.
 559    * @param string $output
 560    *   What should the result set include (web/email/csv).
 561    *
 562    * @return int
 563    *   the total number of rows for this action
 564    */
 565   public function &getRows($action, $offset, $rowCount, $sort, $output = NULL) {
 566     if (($output == CRM_Core_Selector_Controller::EXPORT ||
 567         $output == CRM_Core_Selector_Controller::SCREEN
 568       ) &&
 569       $this->_formValues['radio_ts'] == 'ts_sel'
 570     ) {
 571       $includeContactIds = TRUE;
 572     }
 573     else {
 574       $includeContactIds = FALSE;
 575     }
 576
 577     // note the formvalues were given by CRM_Contact_Form_Search to us
 578     // and contain the search criteria (parameters)
 579     // note that the default action is basic
 580     if ($rowCount) {
 581       $cacheKey = $this->buildPrevNextCache($sort);
 582       $resultSet = $this->_query->getCachedContacts($cacheKey, $offset, $rowCount, $includeContactIds)->fetchGenerator();
 583     }
 584     else {
 585       $resultSet = $this->_query->searchQuery($offset, $rowCount, $sort, FALSE, $includeContactIds)->fetchGenerator();
 586     }
 587
 588     // process the result of the query
 589     $rows = array();
 590     $permissions = array(CRM_Core_Permission::getPermission());
 591     if (CRM_Core_Permission::check('delete contacts')) {
 592       $permissions[] = CRM_Core_Permission::DELETE;
 593     }
 594     $mask = CRM_Core_Action::mask($permissions);
 595
 596     // mask value to hide map link if there are not lat/long
 597     $mapMask = $mask & 4095;
 598
 599     if ($this->_searchContext == 'smog') {
 600       $gc = CRM_Core_SelectValues::groupContactStatus();
 601     }
 602
 603     if ($this->_ufGroupID) {
 604       $locationTypes = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Address', 'location_type_id');
 605
 606       $names = array();
 607       static $skipFields = array('group', 'tag');
 608       foreach ($this->_fields as $key => $field) {
 609         if (!empty($field['in_selector']) &&
 610           !in_array($key, $skipFields)
 611         ) {
 612           if (strpos($key, '-') !== FALSE) {
 613             list($fieldName, $id, $type) = CRM_Utils_System::explode('-', $key, 3);
 614
 615             if ($id == 'Primary') {
 616               $locationTypeName = 1;
 617             }
 618             elseif ($fieldName == 'url') {
 619               $locationTypeName = "website-{$id}";
 620             }
 621             else {
 622               $locationTypeName = CRM_Utils_Array::value($id, $locationTypes);
 623               if (!$locationTypeName) {
 624                 continue;
 625               }
 626             }
 627
 628             $locationTypeName = str_replace(' ', '_', $locationTypeName);
 629             if (in_array($fieldName, array(
 630               'phone',
 631               'im',
 632               'email',
 633             ))) {
 634               if ($type) {
 635                 $names[] = "{$locationTypeName}-{$fieldName}-{$type}";
 636               }
 637               else {
 638                 $names[] = "{$locationTypeName}-{$fieldName}";
 639               }
 640             }
 641             else {
 642               $names[] = "{$locationTypeName}-{$fieldName}";
 643             }
 644           }
 645           else {
 646             $names[] = $field['name'];
 647           }
 648         }
 649       }
 650
 651       $names[] = "status";
 652     }
 653     elseif (!empty($this->_returnProperties)) {
 654       $names = self::makeProperties($this->_returnProperties);
 655     }
 656     else {
 657       $names = self::$_properties;
 658     }
 659
 660     $links = self::links($this->_context, $this->_contextMenu, $this->_key);
 661
 662     //check explicitly added contact to a Smart Group.
 663     $groupID = CRM_Utils_Array::value('group', $this->_formValues);
 664
 665     $pseudoconstants = array();
 666     // for CRM-3157 purposes
 667     if (in_array('world_region', $names)) {
 668       $pseudoconstants['world_region'] = array(
 669         'dbName' => 'worldregion_id',
 670         'values' => CRM_Core_PseudoConstant::worldRegion(),
 671       );
 672     }
 673
 674     foreach ($resultSet as $result) {
 675       $row = array();
 676       $this->_query->convertToPseudoNames($result);
 677       // the columns we are interested in
 678       foreach ($names as $property) {
 679         if ($property == 'status') {
 680           continue;
 681         }
 682         if ($cfID = CRM_Core_BAO_CustomField::getKeyID($property)) {
 683           $row[$property] = CRM_Core_BAO_CustomField::displayValue(
 684             $result->$property,
 685             $cfID,
 686             $result->contact_id
 687           );
 688         }
 689         elseif (strpos($property, '-im')) {
 690           $row[$property] = $result->$property;
 691           if (!empty($result->$property)) {
 692             $imProviders = CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id');
 693             $providerId = $property . "-provider_id";
 694             $providerName = $imProviders[$result->$providerId];
 695             $row[$property] = $result->$property . " ({$providerName})";
 696           }
 697         }
 698         elseif (in_array($property, array(
 699           'addressee',
 700           'email_greeting',
 701           'postal_greeting',
 702         ))) {
 703           $greeting = $property . '_display';
 704           $row[$property] = $result->$greeting;
 705         }
 706         elseif (isset($pseudoconstants[$property])) {
 707           $row[$property] = CRM_Utils_Array::value(
 708             $result->{$pseudoconstants[$property]['dbName']},
 709             $pseudoconstants[$property]['values']
 710           );
 711         }
 712         elseif (strpos($property, '-url') !== FALSE) {
 713           $websiteUrl = '';
 714           $websiteKey = str_replace('-url', '', $property);
 715           $propertyArray = explode('-', $property);
 716           $websiteFld = $websiteKey . '-' . array_pop($propertyArray);
 717           if (!empty($result->$websiteFld)) {
 718             $websiteTypes = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Website', 'website_type_id');
 719             $websiteType = $websiteTypes[$result->{"$websiteKey-website_type_id"}];
 720             $websiteValue = $result->$websiteFld;
 721             $websiteUrl = "<a href=\"{$websiteValue}\">{$websiteValue}  ({$websiteType})</a>";
 722           }
 723           $row[$property] = $websiteUrl;
 724         }
 725         else {
 726           $row[$property] = isset($result->$property) ? $result->$property : NULL;
 727         }
 728       }
 729
 730       if (!empty($result->postal_code_suffix)) {
 731         $row['postal_code'] .= "-" . $result->postal_code_suffix;
 732       }
 733
 734       if ($output != CRM_Core_Selector_Controller::EXPORT &&
 735         $this->_searchContext == 'smog'
 736       ) {
 737         if (empty($result->status) &&
 738           $groupID
 739         ) {
 740           $contactID = $result->contact_id;
 741           if ($contactID) {
 742             $gcParams = array(
 743               'contact_id' => $contactID,
 744               'group_id' => $groupID,
 745             );
 746
 747             $gcDefaults = array();
 748             CRM_Core_DAO::commonRetrieve('CRM_Contact_DAO_GroupContact', $gcParams, $gcDefaults);
 749
 750             if (empty($gcDefaults)) {
 751               $row['status'] = ts('Smart');
 752             }
 753             else {
 754               $row['status'] = $gc[$gcDefaults['status']];
 755             }
 756           }
 757           else {
 758             $row['status'] = NULL;
 759           }
 760         }
 761         else {
 762           $row['status'] = $gc[$result->status];
 763         }
 764       }
 765
 766       if ($output != CRM_Core_Selector_Controller::EXPORT) {
 767         $row['checkbox'] = CRM_Core_Form::CB_PREFIX . $result->contact_id;
 768
 769         if (!empty($this->_formValues['deleted_contacts']) && CRM_Core_Permission::check('access deleted contacts')
 770         ) {
 771           $links = array(
 772             array(
 773               'name' => ts('View'),
 774               'url' => 'civicrm/contact/view',
 775               'qs' => 'reset=1&cid=%%id%%',
 776               'class' => 'no-popup',
 777               'title' => ts('View Contact Details'),
 778             ),
 779             array(
 780               'name' => ts('Restore'),
 781               'url' => 'civicrm/contact/view/delete',
 782               'qs' => 'reset=1&cid=%%id%%&restore=1',
 783               'title' => ts('Restore Contact'),
 784             ),
 785           );
 786           if (CRM_Core_Permission::check('delete contacts')) {
 787             $links[] = array(
 788               'name' => ts('Delete Permanently'),
 789               'url' => 'civicrm/contact/view/delete',
 790               'qs' => 'reset=1&cid=%%id%%&skip_undelete=1',
 791               'title' => ts('Permanently Delete Contact'),
 792             );
 793           }
 794           $row['action'] = CRM_Core_Action::formLink(
 795             $links,
 796             NULL,
 797             array('id' => $result->contact_id),
 798             ts('more'),
 799             FALSE,
 800             'contact.selector.row',
 801             'Contact',
 802             $result->contact_id
 803           );
 804         }
 805         elseif ((is_numeric(CRM_Utils_Array::value('geo_code_1', $row))) ||
 806           (!empty($row['city']) &&
 807             CRM_Utils_Array::value('state_province', $row)
 808           )
 809         ) {
 810           $row['action'] = CRM_Core_Action::formLink(
 811             $links,
 812             $mask,
 813             array('id' => $result->contact_id),
 814             ts('more'),
 815             FALSE,
 816             'contact.selector.row',
 817             'Contact',
 818             $result->contact_id
 819           );
 820         }
 821         else {
 822           $row['action'] = CRM_Core_Action::formLink(
 823             $links,
 824             $mapMask,
 825             array('id' => $result->contact_id),
 826             ts('more'),
 827             FALSE,
 828             'contact.selector.row',
 829             'Contact',
 830             $result->contact_id
 831           );
 832         }
 833
 834         // allow components to add more actions
 835         CRM_Core_Component::searchAction($row, $result->contact_id);
 836
 837         $row['contact_type'] = CRM_Contact_BAO_Contact_Utils::getImage($result->contact_sub_type ? $result->contact_sub_type : $result->contact_type,
 838           FALSE,
 839           $result->contact_id
 840         );
 841
 842         $row['contact_type_orig'] = $result->contact_sub_type ? $result->contact_sub_type : $result->contact_type;
 843         $row['contact_sub_type'] = $result->contact_sub_type ? CRM_Contact_BAO_ContactType::contactTypePairs(FALSE, $result->contact_sub_type, ', ') : $result->contact_sub_type;
 844         $row['contact_id'] = $result->contact_id;
 845         $row['sort_name'] = $result->sort_name;
 846         // Surely this if should be if NOT - otherwise it's just wierd.
 847         if (array_key_exists('id', $row)) {
 848           $row['id'] = $result->contact_id;
 849         }
 850       }
 851
 852       $rows[$row['contact_id']] = $row;
 853     }
 854
 855     return $rows;
 856   }
 857
 858   /**
 859    * @param CRM_Utils_Sort $sort
 860    *
 861    * @return string
 862    */
 863   public function buildPrevNextCache($sort) {
 864     $cacheKey = 'civicrm search ' . $this->_key;
 865
 866     // We should clear the cache in following conditions:
 867     // 1. when starting from scratch, i.e new search
 868     // 2. if records are sorted
 869
 870     // get current page requested
 871     $pageNum = CRM_Utils_Request::retrieve('crmPID', 'Integer');
 872
 873     // get the current sort order
 874     $currentSortID = CRM_Utils_Request::retrieve('crmSID', 'String');
 875
 876     $session = CRM_Core_Session::singleton();
 877
 878     // get previous sort id
 879     $previousSortID = $session->get('previousSortID');
 880
 881     // check for current != previous to ensure cache is not reset if paging is done without changing
 882     // sort criteria
 883     if (!$pageNum || (!empty($currentSortID) && $currentSortID != $previousSortID)) {
 884       CRM_Core_BAO_PrevNextCache::deleteItem(NULL, $cacheKey, 'civicrm_contact');
 885       // this means it's fresh search, so set pageNum=1
 886       if (!$pageNum) {
 887         $pageNum = 1;
 888       }
 889     }
 890
 891     // set the current sort as previous sort
 892     if (!empty($currentSortID)) {
 893       $session->set('previousSortID', $currentSortID);
 894     }
 895
 896     $pageSize = CRM_Utils_Request::retrieve('crmRowCount', 'Integer', CRM_Core_DAO::$_nullObject, FALSE, 50);
 897     $firstRecord = ($pageNum - 1) * $pageSize;
 898
 899     //for alphabetic pagination selection save
 900     $sortByCharacter = CRM_Utils_Request::retrieve('sortByCharacter', 'String');
 901
 902     //for text field pagination selection save
 903     $countRow = CRM_Core_BAO_PrevNextCache::getCount($cacheKey, NULL, "entity_table = 'civicrm_contact'");
 904     // $sortByCharacter triggers a refresh in the prevNext cache
 905     if ($sortByCharacter && $sortByCharacter != 'all') {
 906       $cacheKey .= "_alphabet";
 907       $this->fillupPrevNextCache($sort, $cacheKey, 0, max(self::CACHE_SIZE, $pageSize));
 908     }
 909     elseif (($firstRecord + $pageSize) >= $countRow) {
 910       $this->fillupPrevNextCache($sort, $cacheKey, $countRow, max(self::CACHE_SIZE, $pageSize) + $firstRecord - $countRow);
 911     }
 912     return $cacheKey;
 913   }
 914
 915   /**
 916    * @param $rows
 917    */
 918   public function addActions(&$rows) {
 919
 920     $basicPermissions = CRM_Core_Permission::check('delete contacts') ? array(CRM_Core_Permission::DELETE) : array();
 921
 922     // get permissions on an individual level (CRM-12645)
 923     // @todo look at storing this to the session as this is called twice during search results render.
 924     $can_edit_list = CRM_Contact_BAO_Contact_Permission::allowList(array_keys($rows), CRM_Core_Permission::EDIT);
 925
 926     $links_template = self::links($this->_context, $this->_contextMenu, $this->_key);
 927
 928     foreach ($rows as $id => & $row) {
 929       $links = $links_template;
 930       if (in_array($id, $can_edit_list)) {
 931         $mask = CRM_Core_Action::mask(array_merge(array(CRM_Core_Permission::EDIT), $basicPermissions));
 932       }
 933       else {
 934         $mask = CRM_Core_Action::mask(array_merge(array(CRM_Core_Permission::VIEW), $basicPermissions));
 935       }
 936
 937       if ((!is_numeric(CRM_Utils_Array::value('geo_code_1', $row))) &&
 938         (empty($row['city']) ||
 939           !CRM_Utils_Array::value('state_province', $row)
 940         )
 941       ) {
 942         $mask = $mask & 4095;
 943       }
 944
 945       if (!empty($this->_formValues['deleted_contacts']) && CRM_Core_Permission::check('access deleted contacts')
 946       ) {
 947         $links = array(
 948           array(
 949             'name' => ts('View'),
 950             'url' => 'civicrm/contact/view',
 951             'qs' => 'reset=1&cid=%%id%%',
 952             'class' => 'no-popup',
 953             'title' => ts('View Contact Details'),
 954           ),
 955           array(
 956             'name' => ts('Restore'),
 957             'url' => 'civicrm/contact/view/delete',
 958             'qs' => 'reset=1&cid=%%id%%&restore=1',
 959             'title' => ts('Restore Contact'),
 960           ),
 961         );
 962         if (CRM_Core_Permission::check('delete contacts')) {
 963           $links[] = array(
 964             'name' => ts('Delete Permanently'),
 965             'url' => 'civicrm/contact/view/delete',
 966             'qs' => 'reset=1&cid=%%id%%&skip_undelete=1',
 967             'title' => ts('Permanently Delete Contact'),
 968           );
 969         }
 970         $row['action'] = CRM_Core_Action::formLink(
 971           $links,
 972           NULL,
 973           array('id' => $row['contact_id']),
 974           ts('more'),
 975           FALSE,
 976           'contact.selector.actions',
 977           'Contact',
 978           $row['contact_id']
 979         );
 980       }
 981       else {
 982         $row['action'] = CRM_Core_Action::formLink(
 983           $links,
 984           $mask,
 985           array('id' => $row['contact_id']),
 986           ts('more'),
 987           FALSE,
 988           'contact.selector.actions',
 989           'Contact',
 990           $row['contact_id']
 991         );
 992       }
 993
 994       // allow components to add more actions
 995       CRM_Core_Component::searchAction($row, $row['contact_id']);
 996
 997       if (!empty($row['contact_type_orig'])) {
 998         $row['contact_type'] = CRM_Contact_BAO_Contact_Utils::getImage($row['contact_type_orig'],
 999           FALSE, $row['contact_id']);
1000       }
1001     }
1002   }
1003
1004   /**
1005    * @param $rows
1006    */
1007   public function removeActions(&$rows) {
1008     foreach ($rows as $rid => & $rValue) {
1009       unset($rValue['contact_type']);
1010       unset($rValue['action']);
1011     }
1012   }
1013
1014   /**
1015    * @param CRM_Utils_Sort $sort
1016    * @param string $cacheKey
1017    * @param int $start
1018    * @param int $end
1019    */
1020   public function fillupPrevNextCache($sort, $cacheKey, $start = 0, $end = self::CACHE_SIZE) {
1021     $coreSearch = TRUE;
1022     // For custom searches, use the contactIDs method
1023     if (is_a($this, 'CRM_Contact_Selector_Custom')) {
1024       $sql = $this->_search->contactIDs($start, $end, $sort, TRUE);
1025       $coreSearch = FALSE;
1026     }
1027     // For core searches use the searchQuery method
1028     else {
1029       $sql = $this->_query->searchQuery($start, $end, $sort, FALSE, $this->_query->_includeContactIds,
1030         FALSE, TRUE, TRUE);
1031     }
1032
1033     // CRM-9096
1034     // due to limitations in our search query writer, the above query does not work
1035     // in cases where the query is being sorted on a non-contact table
1036     // this results in a fatal error :(
1037     // see below for the gross hack of trapping the error and not filling
1038     // the prev next cache in this situation
1039     // the other alternative of running the FULL query will just be incredibly inefficient
1040     // and slow things down way too much on large data sets / complex queries
1041
1042     $insertSQL = "
1043 INSERT INTO civicrm_prevnext_cache ( entity_table, entity_id1, entity_id2, cacheKey, data )
1044 SELECT DISTINCT 'civicrm_contact', contact_a.id, contact_a.id, '$cacheKey', contact_a.sort_name
1045 ";
1046
1047     $sql = str_replace(array("SELECT contact_a.id as contact_id", "SELECT contact_a.id as id"), $insertSQL, $sql);
1048     try {
1049       $result = CRM_Core_DAO::executeQuery($sql, [], FALSE, NULL, FALSE, TRUE, TRUE);
1050       if (is_a($result, 'DB_Error')) {
1051         throw new CRM_Core_Exception($result->message);
1052       }
1053     }
1054     catch (CRM_Core_Exception $e) {
1055       if ($coreSearch) {
1056         // in the case of error, try rebuilding cache using full sql which is used for search selector display
1057         // this fixes the bugs reported in CRM-13996 & CRM-14438
1058         $this->rebuildPreNextCache($start, $end, $sort, $cacheKey);
1059       }
1060       else {
1061         // This will always show for CiviRules :-( as a) it orders by 'rule_label'
1062         // which is not available in the query & b) it uses contact not contact_a
1063         // as an alias.
1064         // CRM_Core_Session::setStatus(ts('Query Failed'));
1065         return;
1066       }
1067     }
1068
1069     // also record an entry in the cache key table, so we can delete it periodically
1070     CRM_Core_BAO_Cache::setItem($cacheKey, 'CiviCRM Search PrevNextCache', $cacheKey);
1071   }
1072
1073   /**
1074    * called to rebuild prev next cache using full sql in case of core search ( excluding custom search)
1075    *
1076    * @param int $start
1077    *   Start for limit clause.
1078    * @param int $end
1079    *   End for limit clause.
1080    * @param CRM_Utils_Sort $sort
1081    * @param string $cacheKey
1082    *   Cache key.
1083    */
1084   public function rebuildPreNextCache($start, $end, $sort, $cacheKey) {
1085     // generate full SQL
1086     $sql = $this->_query->searchQuery($start, $end, $sort, FALSE, $this->_query->_includeContactIds,
1087       FALSE, FALSE, TRUE);
1088
1089     $dao = CRM_Core_DAO::executeQuery($sql);
1090
1091     // build insert query, note that currently we build cache for 500 (self::CACHE_SIZE) contact records at a time, hence below approach
1092     $insertValues = array();
1093     while ($dao->fetch()) {
1094       $insertValues[] = "('civicrm_contact', {$dao->contact_id}, {$dao->contact_id}, '{$cacheKey}', '" . CRM_Core_DAO::escapeString($dao->sort_name) . "')";
1095     }
1096
1097     //update pre/next cache using single insert query
1098     if (!empty($insertValues)) {
1099       $sql = 'INSERT INTO civicrm_prevnext_cache ( entity_table, entity_id1, entity_id2, cacheKey, data ) VALUES
1100 ' . implode(',', $insertValues);
1101
1102       $result = CRM_Core_DAO::executeQuery($sql);
1103     }
1104   }
1105
1106   /**
1107    * @inheritDoc
1108    */
1109   public function getQILL() {
1110     return $this->_query->qill();
1111   }
1112
1113   /**
1114    * Name of export file.
1115    *
1116    * @param string $output
1117    *   Type of output.
1118    *
1119    * @return string
1120    *   name of the file
1121    */
1122   public function getExportFileName($output = 'csv') {
1123     return ts('CiviCRM Contact Search');
1124   }
1125
1126   /**
1127    * Get colunmn headers for search selector.
1128    *
1129    * @return array
1130    */
1131   private static function &_getColumnHeaders() {
1132     if (!isset(self::$_columnHeaders)) {
1133       $addressOptions = CRM_Core_BAO_Setting::valueOptions(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME,
1134         'address_options', TRUE, NULL, TRUE
1135       );
1136
1137       self::$_columnHeaders = array(
1138         'contact_type' => array('desc' => ts('Contact Type')),
1139         'sort_name' => array(
1140           'name' => ts('Name'),
1141           'sort' => 'sort_name',
1142           'direction' => CRM_Utils_Sort::ASCENDING,
1143         ),
1144       );
1145
1146       $defaultAddress = array(
1147         'street_address' => array('name' => ts('Address')),
1148         'city' => array(
1149           'name' => ts('City'),
1150           'sort' => 'city',
1151           'direction' => CRM_Utils_Sort::DONTCARE,
1152         ),
1153         'state_province' => array(
1154           'name' => ts('State'),
1155           'sort' => 'state_province',
1156           'direction' => CRM_Utils_Sort::DONTCARE,
1157         ),
1158         'postal_code' => array(
1159           'name' => ts('Postal'),
1160           'sort' => 'postal_code',
1161           'direction' => CRM_Utils_Sort::DONTCARE,
1162         ),
1163         'country' => array(
1164           'name' => ts('Country'),
1165           'sort' => 'country',
1166           'direction' => CRM_Utils_Sort::DONTCARE,
1167         ),
1168       );
1169
1170       foreach ($defaultAddress as $columnName => $column) {
1171         if (!empty($addressOptions[$columnName])) {
1172           self::$_columnHeaders[$columnName] = $column;
1173         }
1174       }
1175
1176       self::$_columnHeaders['email'] = array(
1177         'name' => ts('Email'),
1178         'sort' => 'email',
1179         'direction' => CRM_Utils_Sort::DONTCARE,
1180       );
1181
1182       self::$_columnHeaders['phone'] = array('name' => ts('Phone'));
1183     }
1184     return self::$_columnHeaders;
1185   }
1186
1187   /**
1188    * @return CRM_Contact_BAO_Query
1189    */
1190   public function getQuery() {
1191     return $this->_query;
1192   }
1193
1194   /**
1195    * @return CRM_Contact_DAO_Contact
1196    */
1197   public function alphabetQuery() {
1198     return $this->_query->searchQuery(NULL, NULL, NULL, FALSE, FALSE, TRUE);
1199   }
1200
1201   /**
1202    * @param array $params
1203    * @param int $sortID
1204    * @param null $displayRelationshipType
1205    * @param string $queryOperator
1206    *
1207    * @return CRM_Contact_DAO_Contact
1208    */
1209   public function contactIDQuery($params, $sortID, $displayRelationshipType = NULL, $queryOperator = 'AND') {
1210     $sortOrder = &$this->getSortOrder($this->_action);
1211     $sort = new CRM_Utils_Sort($sortOrder, $sortID);
1212
1213     // rectify params to what proximity search expects if there is a value for prox_distance
1214     // CRM-7021 CRM-7905
1215     if (!empty($params)) {
1216       CRM_Contact_BAO_ProximityQuery::fixInputParams($params);
1217     }
1218
1219     if (!$displayRelationshipType) {
1220       $query = new CRM_Contact_BAO_Query($params,
1221         CRM_Contact_BAO_Query::NO_RETURN_PROPERTIES,
1222         NULL, FALSE, FALSE, 1,
1223         FALSE, TRUE, TRUE, NULL,
1224         $queryOperator
1225       );
1226     }
1227     else {
1228       $query = new CRM_Contact_BAO_Query($params,
1229         CRM_Contact_BAO_Query::NO_RETURN_PROPERTIES,
1230         NULL, FALSE, FALSE, 1,
1231         FALSE, TRUE, TRUE, $displayRelationshipType,
1232         $queryOperator
1233       );
1234     }
1235     $value = $query->searchQuery(0, 0, $sort,
1236       FALSE, FALSE, FALSE,
1237       FALSE, FALSE
1238     );
1239     return $value;
1240   }
1241
1242   /**
1243    * @param $returnProperties
1244    *
1245    * @return array
1246    */
1247   public function &makeProperties(&$returnProperties) {
1248     $properties = array();
1249     foreach ($returnProperties as $name => $value) {
1250       if ($name != 'location') {
1251         // special handling for group and tag
1252         if (in_array($name, array('group', 'tag'))) {
1253           $name = "{$name}s";
1254         }
1255
1256         // special handling for notes
1257         if (in_array($name, array('note', 'note_subject', 'note_body'))) {
1258           $name = "notes";
1259         }
1260
1261         $properties[] = $name;
1262       }
1263       else {
1264         // extract all the location stuff
1265         foreach ($value as $n => $v) {
1266           foreach ($v as $n1 => $v1) {
1267             if (!strpos('_id', $n1) && $n1 != 'location_type') {
1268               $n = str_replace(' ', '_', $n);
1269               $properties[] = "{$n}-{$n1}";
1270             }
1271           }
1272         }
1273       }
1274     }
1275     return $properties;
1276   }
1277
1278 }