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