CRM/Contact/BAO/Group.php

   1 <?php
   2 /*
   3   +--------------------------------------------------------------------+
   4   | CiviCRM version 4.7                                                |
   5   +--------------------------------------------------------------------+
   6   | Copyright CiviCRM LLC (c) 2004-2016                                |
   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-2016
  32  */
  33 class CRM_Contact_BAO_Group extends CRM_Contact_DAO_Group {
  34
  35   /**
  36    * Class constructor.
  37    */
  38   public function __construct() {
  39     parent::__construct();
  40   }
  41
  42   /**
  43    * Retrieve DB object based on input parameters.
  44    *
  45    * It also stores all the retrieved values in the default array.
  46    *
  47    * @param array $params
  48    *   (reference ) an assoc array of name/value pairs.
  49    * @param array $defaults
  50    *   (reference ) an assoc array to hold the flattened values.
  51    *
  52    * @return CRM_Contact_BAO_Group
  53    */
  54   public static function retrieve(&$params, &$defaults) {
  55     $group = new CRM_Contact_DAO_Group();
  56     $group->copyValues($params);
  57     if ($group->find(TRUE)) {
  58       CRM_Core_DAO::storeValues($group, $defaults);
  59       return $group;
  60     }
  61   }
  62
  63   /**
  64    * Delete the group and all the object that connect to this group.
  65    *
  66    * Incredibly destructive.
  67    *
  68    * @param int $id Group id.
  69    */
  70   public static function discard($id) {
  71     CRM_Utils_Hook::pre('delete', 'Group', $id, CRM_Core_DAO::$_nullArray);
  72
  73     $transaction = new CRM_Core_Transaction();
  74
  75     // added for CRM-1631 and CRM-1794
  76     // delete all subscribed mails with the selected group id
  77     $subscribe = new CRM_Mailing_Event_DAO_Subscribe();
  78     $subscribe->group_id = $id;
  79     $subscribe->delete();
  80
  81     // delete all Subscription  records with the selected group id
  82     $subHistory = new CRM_Contact_DAO_SubscriptionHistory();
  83     $subHistory->group_id = $id;
  84     $subHistory->delete();
  85
  86     // delete all crm_group_contact records with the selected group id
  87     $groupContact = new CRM_Contact_DAO_GroupContact();
  88     $groupContact->group_id = $id;
  89     $groupContact->delete();
  90
  91     // make all the 'add_to_group_id' field of 'civicrm_uf_group table', pointing to this group, as null
  92     $params = array(1 => array($id, 'Integer'));
  93     $query = "UPDATE civicrm_uf_group SET `add_to_group_id`= NULL WHERE `add_to_group_id` = %1";
  94     CRM_Core_DAO::executeQuery($query, $params);
  95
  96     $query = "UPDATE civicrm_uf_group SET `limit_listings_group_id`= NULL WHERE `limit_listings_group_id` = %1";
  97     CRM_Core_DAO::executeQuery($query, $params);
  98
  99     // make sure u delete all the entries from civicrm_mailing_group and civicrm_campaign_group
 100     // CRM-6186
 101     $query = "DELETE FROM civicrm_mailing_group where entity_table = 'civicrm_group' AND entity_id = %1";
 102     CRM_Core_DAO::executeQuery($query, $params);
 103
 104     $query = "DELETE FROM civicrm_campaign_group where entity_table = 'civicrm_group' AND entity_id = %1";
 105     CRM_Core_DAO::executeQuery($query, $params);
 106
 107     $query = "DELETE FROM civicrm_acl_entity_role where entity_table = 'civicrm_group' AND entity_id = %1";
 108     CRM_Core_DAO::executeQuery($query, $params);
 109
 110     // delete from group table
 111     $group = new CRM_Contact_DAO_Group();
 112     $group->id = $id;
 113     $group->delete();
 114
 115     $transaction->commit();
 116
 117     CRM_Utils_Hook::post('delete', 'Group', $id, $group);
 118
 119     // delete the recently created Group
 120     $groupRecent = array(
 121       'id' => $id,
 122       'type' => 'Group',
 123     );
 124     CRM_Utils_Recent::del($groupRecent);
 125   }
 126
 127   /**
 128    * Returns an array of the contacts in the given group.
 129    *
 130    * @param int $id
 131    */
 132   public static function getGroupContacts($id) {
 133     $params = array(array('group', 'IN', array(1 => $id), 0, 0));
 134     list($contacts, $_) = CRM_Contact_BAO_Query::apiQuery($params, array('contact_id'));
 135     return $contacts;
 136   }
 137
 138   /**
 139    * Get the count of a members in a group with the specific status.
 140    *
 141    * @param int $id
 142    *   Group id.
 143    * @param string $status
 144    *   status of members in group
 145    * @param bool $countChildGroups
 146    *
 147    * @return int
 148    *   count of members in the group with above status
 149    */
 150   public static function memberCount($id, $status = 'Added', $countChildGroups = FALSE) {
 151     $groupContact = new CRM_Contact_DAO_GroupContact();
 152     $groupIds = array($id);
 153     if ($countChildGroups) {
 154       $groupIds = CRM_Contact_BAO_GroupNesting::getDescendentGroupIds($groupIds);
 155     }
 156     $count = 0;
 157
 158     $contacts = self::getGroupContacts($id);
 159
 160     foreach ($groupIds as $groupId) {
 161
 162       $groupContacts = self::getGroupContacts($groupId);
 163       foreach ($groupContacts as $gcontact) {
 164         if ($groupId != $id) {
 165           // Loop through main group's contacts
 166           // and subtract from the count for each contact which
 167           // matches one in the present group, if it is not the
 168           // main group
 169           foreach ($contacts as $contact) {
 170             if ($contact['contact_id'] == $gcontact['contact_id']) {
 171               $count--;
 172             }
 173           }
 174         }
 175       }
 176       $groupContact->group_id = $groupId;
 177       if (isset($status)) {
 178         $groupContact->status = $status;
 179       }
 180       $groupContact->_query['condition'] = 'WHERE contact_id NOT IN (SELECT id FROM civicrm_contact WHERE is_deleted = 1)';
 181       $count += $groupContact->count();
 182     }
 183     return $count;
 184   }
 185
 186   /**
 187    * Get the list of member for a group id.
 188    *
 189    * @param int $groupID
 190    * @param bool $useCache
 191    * @param int $limit
 192    *   Number to limit to (or 0 for unlimited).
 193    *
 194    * @return array
 195    *   this array contains the list of members for this group id
 196    */
 197   public static function getMember($groupID, $useCache = TRUE, $limit = 0) {
 198     $params = array(array('group', '=', $groupID, 0, 0));
 199     $returnProperties = array('contact_id');
 200     list($contacts) = CRM_Contact_BAO_Query::apiQuery($params, $returnProperties, NULL, NULL, 0, $limit, $useCache);
 201
 202     $aMembers = array();
 203     foreach ($contacts as $contact) {
 204       $aMembers[$contact['contact_id']] = 1;
 205     }
 206
 207     return $aMembers;
 208   }
 209
 210   /**
 211    * Returns array of group object(s) matching a set of one or Group properties.
 212    *
 213    * @param array $params
 214    *   Limits the set of groups returned.
 215    * @param array $returnProperties
 216    *   Which properties should be included in the returned group objects.
 217    *   (member_count should be last element.)
 218    * @param string $sort
 219    * @param int $offset
 220    * @param int $rowCount
 221    *
 222    * @return array
 223    *   Array of group objects.
 224    *
 225    *
 226    * @todo other BAO functions that use returnProperties (e.g. Query Objects) receive the array flipped & filled with 1s and
 227    * add in essential fields (e.g. id). This should follow a regular pattern like the others
 228    */
 229   public static function getGroups(
 230     $params = NULL,
 231     $returnProperties = NULL,
 232     $sort = NULL,
 233     $offset = NULL,
 234     $rowCount = NULL
 235   ) {
 236     $dao = new CRM_Contact_DAO_Group();
 237     if (!isset($params['is_active'])) {
 238       $dao->is_active = 1;
 239     }
 240     if ($params) {
 241       foreach ($params as $k => $v) {
 242         if ($k == 'name' || $k == 'title') {
 243           $dao->whereAdd($k . ' LIKE "' . CRM_Core_DAO::escapeString($v) . '"');
 244         }
 245         elseif ($k == 'group_type') {
 246           foreach ((array) $v as $type) {
 247             $dao->whereAdd($k . " LIKE '%" . CRM_Core_DAO::VALUE_SEPARATOR . (int) $type . CRM_Core_DAO::VALUE_SEPARATOR . "%'");
 248           }
 249         }
 250         elseif (is_array($v)) {
 251           foreach ($v as &$num) {
 252             $num = (int) $num;
 253           }
 254           $dao->whereAdd($k . ' IN (' . implode(',', $v) . ')');
 255         }
 256         else {
 257           $dao->$k = $v;
 258         }
 259       }
 260     }
 261
 262     if ($offset || $rowCount) {
 263       $offset = ($offset > 0) ? $offset : 0;
 264       $rowCount = ($rowCount > 0) ? $rowCount : 25;
 265       $dao->limit($offset, $rowCount);
 266     }
 267
 268     if ($sort) {
 269       $dao->orderBy($sort);
 270     }
 271
 272     // return only specific fields if returnproperties are sent
 273     if (!empty($returnProperties)) {
 274       $dao->selectAdd();
 275       $dao->selectAdd(implode(',', $returnProperties));
 276     }
 277     $dao->find();
 278
 279     $flag = $returnProperties && in_array('member_count', $returnProperties) ? 1 : 0;
 280
 281     $groups = array();
 282     while ($dao->fetch()) {
 283       $group = new CRM_Contact_DAO_Group();
 284       if ($flag) {
 285         $dao->member_count = CRM_Contact_BAO_Group::memberCount($dao->id);
 286       }
 287       $groups[] = clone($dao);
 288     }
 289     return $groups;
 290   }
 291
 292   /**
 293    * Make sure that the user has permission to access this group.
 294    *
 295    * @param int $id
 296    *   The id of the object.
 297    * @param bool $excludeHidden
 298    *   Should hidden groups be excluded.
 299    *   Logically this is the wrong place to filter hidden groups out as that is
 300    *   not a permission issue. However, as other functions may rely on that defaulting to
 301    *   FALSE for now & only the api call is calling with true.
 302    *
 303    * @return array
 304    *   The permission that the user has (or NULL)
 305    */
 306   public static function checkPermission($id, $excludeHidden = FALSE) {
 307     $allGroups = CRM_Core_PseudoConstant::allGroup(NULL, $excludeHidden);
 308
 309     $permissions = NULL;
 310     if (CRM_Core_Permission::check('edit all contacts') ||
 311       CRM_ACL_API::groupPermission(CRM_ACL_API::EDIT, $id, NULL,
 312         'civicrm_saved_search', $allGroups
 313       )
 314     ) {
 315       $permissions[] = CRM_Core_Permission::EDIT;
 316     }
 317
 318     if (CRM_Core_Permission::check('view all contacts') ||
 319       CRM_ACL_API::groupPermission(CRM_ACL_API::VIEW, $id, NULL,
 320         'civicrm_saved_search', $allGroups
 321       )
 322     ) {
 323       $permissions[] = CRM_Core_Permission::VIEW;
 324     }
 325
 326     if (!empty($permissions) && CRM_Core_Permission::check('delete contacts')) {
 327       // Note: using !empty() in if condition, restricts the scope of delete
 328       // permission to groups/contacts that are editable/viewable.
 329       // We can remove this !empty condition once we have ACL support for delete functionality.
 330       $permissions[] = CRM_Core_Permission::DELETE;
 331     }
 332
 333     return $permissions;
 334   }
 335
 336   /**
 337    * Create a new group.
 338    *
 339    * @param array $params
 340    *
 341    * @return CRM_Contact_BAO_Group|NULL
 342    *   The new group BAO (if created)
 343    */
 344   public static function create(&$params) {
 345
 346     if (!empty($params['id'])) {
 347       CRM_Utils_Hook::pre('edit', 'Group', $params['id'], $params);
 348     }
 349     else {
 350       CRM_Utils_Hook::pre('create', 'Group', NULL, $params);
 351     }
 352
 353     // form the name only if missing: CRM-627
 354     $nameParam = CRM_Utils_Array::value('name', $params, NULL);
 355     if (!$nameParam && empty($params['id'])) {
 356       $params['name'] = CRM_Utils_String::titleToVar($params['title']);
 357     }
 358
 359     // convert params if array type
 360     if (isset($params['group_type'])) {
 361       if (is_array($params['group_type'])) {
 362         $params['group_type'] = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
 363             $params['group_type']
 364           ) . CRM_Core_DAO::VALUE_SEPARATOR;
 365       }
 366       else {
 367         $params['group_type'] = CRM_Core_DAO::VALUE_SEPARATOR . $params['group_type'] . CRM_Core_DAO::VALUE_SEPARATOR;
 368       }
 369     }
 370     else {
 371       $params['group_type'] = NULL;
 372     }
 373
 374     $session = CRM_Core_Session::singleton();
 375     $cid = $session->get('userID');
 376     // this action is add
 377     if ($cid && empty($params['id'])) {
 378       $params['created_id'] = $cid;
 379     }
 380     // this action is update
 381     if ($cid && !empty($params['id'])) {
 382       $params['modified_id'] = $cid;
 383     }
 384
 385     // CRM-19068.
 386     // Validate parents parameter when creating group.
 387     if (!empty($params['parents'])) {
 388       $parents = is_array($params['parents']) ? array_keys($params['parents']) : (array) $params['parents'];
 389       foreach ($parents as $parent) {
 390         CRM_Utils_Type::validate($parent, 'Integer');
 391       }
 392     }
 393     $group = new CRM_Contact_BAO_Group();
 394     $group->copyValues($params);
 395     //@todo very hacky fix for the fact this function wants to receive 'parents' as an array further down but
 396     // needs it as a separated string for the DB. Preferred approaches are having the copyParams or save fn
 397     // use metadata to translate the array to the appropriate DB type or altering the param in the api layer,
 398     // or at least altering the param in same section as 'group_type' rather than repeating here. However, further down
 399     // we need the $params one to be in it's original form & we are not sure what test coverage we have on that
 400     if (isset($group->parents) && is_array($group->parents)) {
 401       $group->parents = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
 402           array_keys($group->parents)
 403         ) . CRM_Core_DAO::VALUE_SEPARATOR;
 404     }
 405     if (empty($params['id']) &&
 406       !$nameParam
 407     ) {
 408       $group->name .= "_tmp";
 409     }
 410     $group->save();
 411
 412     if (!$group->id) {
 413       return NULL;
 414     }
 415
 416     if (empty($params['id']) &&
 417       !$nameParam
 418     ) {
 419       $group->name = substr($group->name, 0, -4) . "_{$group->id}";
 420     }
 421
 422     $group->buildClause();
 423     $group->save();
 424
 425     // add custom field values
 426     if (!empty($params['custom'])) {
 427       CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_group', $group->id);
 428     }
 429
 430     // make the group, child of domain/site group by default.
 431     $domainGroupID = CRM_Core_BAO_Domain::getGroupId();
 432     if (CRM_Utils_Array::value('no_parent', $params) !== 1) {
 433       if (empty($params['parents']) &&
 434         $domainGroupID != $group->id &&
 435         Civi::settings()->get('is_enabled') &&
 436         !CRM_Contact_BAO_GroupNesting::hasParentGroups($group->id)
 437       ) {
 438         // if no parent present and the group doesn't already have any parents,
 439         // make sure site group goes as parent
 440         $params['parents'] = array($domainGroupID => 1);
 441       }
 442       elseif (array_key_exists('parents', $params) && !is_array($params['parents'])) {
 443         $params['parents'] = array($params['parents'] => 1);
 444       }
 445
 446       if (!empty($params['parents'])) {
 447         foreach ($params['parents'] as $parentId => $dnc) {
 448           if ($parentId && !CRM_Contact_BAO_GroupNesting::isParentChild($parentId, $group->id)) {
 449             CRM_Contact_BAO_GroupNesting::add($parentId, $group->id);
 450           }
 451         }
 452       }
 453
 454       // this is always required, since we don't know when a
 455       // parent group is removed
 456       CRM_Contact_BAO_GroupNestingCache::update();
 457
 458       // update group contact cache for all parent groups
 459       $parentIds = CRM_Contact_BAO_GroupNesting::getParentGroupIds($group->id);
 460       foreach ($parentIds as $parentId) {
 461         CRM_Contact_BAO_GroupContactCache::add($parentId);
 462       }
 463     }
 464
 465     if (!empty($params['organization_id'])) {
 466       $groupOrg = $params;
 467       $groupOrg['group_id'] = $group->id;
 468       CRM_Contact_BAO_GroupOrganization::add($groupOrg);
 469     }
 470
 471     CRM_Utils_System::flushCache();
 472     CRM_Contact_BAO_GroupContactCache::add($group->id);
 473
 474     if (!empty($params['id'])) {
 475       CRM_Utils_Hook::post('edit', 'Group', $group->id, $group);
 476     }
 477     else {
 478       CRM_Utils_Hook::post('create', 'Group', $group->id, $group);
 479     }
 480
 481     $recentOther = array();
 482     if (CRM_Core_Permission::check('edit groups')) {
 483       $recentOther['editUrl'] = CRM_Utils_System::url('civicrm/group', 'reset=1&action=update&id=' . $group->id);
 484       // currently same permission we are using for delete a group
 485       $recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/group', 'reset=1&action=delete&id=' . $group->id);
 486     }
 487
 488     // add the recently added group (unless hidden: CRM-6432)
 489     if (!$group->is_hidden) {
 490       CRM_Utils_Recent::add($group->title,
 491         CRM_Utils_System::url('civicrm/group/search', 'reset=1&force=1&context=smog&gid=' . $group->id),
 492         $group->id,
 493         'Group',
 494         NULL,
 495         NULL,
 496         $recentOther
 497       );
 498     }
 499     return $group;
 500   }
 501
 502   /**
 503    * Given a saved search compute the clause and the tables
 504    * and store it for future use
 505    */
 506   public function buildClause() {
 507     $params = array(array('group', 'IN', array($this->id), 0, 0));
 508
 509     if (!empty($params)) {
 510       $tables = $whereTables = array();
 511       $this->where_clause = CRM_Contact_BAO_Query::getWhereClause($params, NULL, $tables, $whereTables);
 512       if (!empty($tables)) {
 513         $this->select_tables = serialize($tables);
 514       }
 515       if (!empty($whereTables)) {
 516         $this->where_tables = serialize($whereTables);
 517       }
 518     }
 519   }
 520
 521   /**
 522    * Defines a new smart group.
 523    *
 524    * @param array $params
 525    *   Associative array of parameters.
 526    *
 527    * @return CRM_Contact_BAO_Group|NULL
 528    *   The new group BAO (if created)
 529    */
 530   public static function createSmartGroup(&$params) {
 531     if (!empty($params['formValues'])) {
 532       $ssParams = $params;
 533       unset($ssParams['id']);
 534       if (isset($ssParams['saved_search_id'])) {
 535         $ssParams['id'] = $ssParams['saved_search_id'];
 536       }
 537
 538       $savedSearch = CRM_Contact_BAO_SavedSearch::create($params);
 539
 540       $params['saved_search_id'] = $savedSearch->id;
 541     }
 542     else {
 543       return NULL;
 544     }
 545
 546     return self::create($params);
 547   }
 548
 549   /**
 550    * Update the is_active flag in the db.
 551    *
 552    * @param int $id
 553    *   Id of the database record.
 554    * @param bool $isActive
 555    *   Value we want to set the is_active field.
 556    *
 557    * @return CRM_Core_DAO|null
 558    *   DAO object on success, NULL otherwise
 559    */
 560   public static function setIsActive($id, $isActive) {
 561     return CRM_Core_DAO::setFieldValue('CRM_Contact_DAO_Group', $id, 'is_active', $isActive);
 562   }
 563
 564   /**
 565    * Build the condition to retrieve groups.
 566    *
 567    * @param string $groupType
 568    *   Type of group(Access/Mailing) OR the key of the group.
 569    * @param bool $excludeHidden exclude hidden groups.
 570    *
 571    * @return string
 572    */
 573   public static function groupTypeCondition($groupType = NULL, $excludeHidden = TRUE) {
 574     $value = NULL;
 575     if ($groupType == 'Mailing') {
 576       $value = CRM_Core_DAO::VALUE_SEPARATOR . '2' . CRM_Core_DAO::VALUE_SEPARATOR;
 577     }
 578     elseif ($groupType == 'Access') {
 579       $value = CRM_Core_DAO::VALUE_SEPARATOR . '1' . CRM_Core_DAO::VALUE_SEPARATOR;
 580     }
 581     elseif (!empty($groupType)) {
 582       // ie we have been given the group key
 583       $value = CRM_Core_DAO::VALUE_SEPARATOR . $groupType . CRM_Core_DAO::VALUE_SEPARATOR;
 584     }
 585
 586     $condition = NULL;
 587     if ($excludeHidden) {
 588       $condition = "is_hidden = 0";
 589     }
 590
 591     if ($value) {
 592       if ($condition) {
 593         $condition .= " AND group_type LIKE '%$value%'";
 594       }
 595       else {
 596         $condition = "group_type LIKE '%$value%'";
 597       }
 598     }
 599
 600     return $condition;
 601   }
 602
 603   /**
 604    * Get permission relevant clauses.
 605    * CRM-12209
 606    *
 607    * @param bool $force
 608    *
 609    * @return array
 610    */
 611   public static function getPermissionClause($force = FALSE) {
 612     static $clause = 1;
 613     static $retrieved = FALSE;
 614     if (!$retrieved || $force) {
 615       if (CRM_Core_Permission::check('view all contacts') || CRM_Core_Permission::check('edit all contacts')) {
 616         $clause = 1;
 617       }
 618       else {
 619         //get the allowed groups for the current user
 620         $groups = CRM_ACL_API::group(CRM_ACL_API::VIEW);
 621         if (!empty($groups)) {
 622           $groupList = implode(', ', array_values($groups));
 623           $clause = "groups.id IN ( $groupList ) ";
 624         }
 625         else {
 626           $clause = '1 = 0';
 627         }
 628       }
 629     }
 630     $retrieved = TRUE;
 631     return $clause;
 632   }
 633
 634   /**
 635    * @return string
 636    */
 637   public function __toString() {
 638     return $this->title;
 639   }
 640
 641   /**
 642    * This function create the hidden smart group when user perform
 643    * contact search and want to send mailing to search contacts.
 644    *
 645    * @param array $params
 646    *   ( reference ) an assoc array of name/value pairs.
 647    *
 648    * @return array
 649    *   ( smartGroupId, ssId ) smart group id and saved search id
 650    */
 651   public static function createHiddenSmartGroup($params) {
 652     $ssId = CRM_Utils_Array::value('saved_search_id', $params);
 653
 654     //add mapping record only for search builder saved search
 655     $mappingId = NULL;
 656     if ($params['search_context'] == 'builder') {
 657       //save the mapping for search builder
 658       if (!$ssId) {
 659         //save record in mapping table
 660         $temp = array();
 661         $mappingParams = array('mapping_type' => 'Search Builder');
 662         $mapping = CRM_Core_BAO_Mapping::add($mappingParams, $temp);
 663         $mappingId = $mapping->id;
 664       }
 665       else {
 666         //get the mapping id from saved search
 667         $savedSearch = new CRM_Contact_BAO_SavedSearch();
 668         $savedSearch->id = $ssId;
 669         $savedSearch->find(TRUE);
 670         $mappingId = $savedSearch->mapping_id;
 671       }
 672
 673       //save mapping fields
 674       CRM_Core_BAO_Mapping::saveMappingFields($params['form_values'], $mappingId);
 675     }
 676
 677     //create/update saved search record.
 678     $savedSearch = new CRM_Contact_BAO_SavedSearch();
 679     $savedSearch->id = $ssId;
 680     $savedSearch->form_values = serialize($params['form_values']);
 681     $savedSearch->mapping_id = $mappingId;
 682     $savedSearch->search_custom_id = CRM_Utils_Array::value('search_custom_id', $params);
 683     $savedSearch->save();
 684
 685     $ssId = $savedSearch->id;
 686     if (!$ssId) {
 687       return NULL;
 688     }
 689
 690     $smartGroupId = NULL;
 691     if (!empty($params['saved_search_id'])) {
 692       $smartGroupId = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $ssId, 'id', 'saved_search_id');
 693     }
 694     else {
 695       //create group only when new saved search.
 696       $groupParams = array(
 697         'title' => "Hidden Smart Group {$ssId}",
 698         'is_active' => CRM_Utils_Array::value('is_active', $params, 1),
 699         'is_hidden' => CRM_Utils_Array::value('is_hidden', $params, 1),
 700         'group_type' => CRM_Utils_Array::value('group_type', $params),
 701         'visibility' => CRM_Utils_Array::value('visibility', $params),
 702         'saved_search_id' => $ssId,
 703       );
 704
 705       $smartGroup = self::create($groupParams);
 706       $smartGroupId = $smartGroup->id;
 707     }
 708
 709     return array($smartGroupId, $ssId);
 710   }
 711
 712   /**
 713    * wrapper for ajax group selector.
 714    *
 715    * @param array $params
 716    *   Associated array for params record id.
 717    *
 718    * @return array
 719    *   associated array of group list
 720    *   -rp = rowcount
 721    *   -page= offset
 722    * @todo there seems little reason for the small number of functions that call this to pass in
 723    * params that then need to be translated in this function since they are coding them when calling
 724    */
 725   static public function getGroupListSelector(&$params) {
 726     // format the params
 727     $params['offset'] = ($params['page'] - 1) * $params['rp'];
 728     $params['rowCount'] = $params['rp'];
 729     $params['sort'] = CRM_Utils_Array::value('sortBy', $params);
 730
 731     // get groups
 732     $groups = CRM_Contact_BAO_Group::getGroupList($params);
 733
 734     //skip total if we are making call to show only children
 735     if (empty($params['parent_id'])) {
 736       // add total
 737       $params['total'] = CRM_Contact_BAO_Group::getGroupCount($params);
 738
 739       // get all the groups
 740       $allGroups = CRM_Core_PseudoConstant::allGroup();
 741     }
 742
 743     // format params and add links
 744     $groupList = array();
 745     foreach ($groups as $id => $value) {
 746       $group = array();
 747       $group['group_id'] = $value['id'];
 748       $group['count'] = $value['count'];
 749       $group['title'] = $value['title'];
 750
 751       // append parent names if in search mode
 752       if (empty($params['parent_id']) && !empty($value['parents'])) {
 753         $group['parent_id'] = $value['parents'];
 754         $groupIds = explode(',', $value['parents']);
 755         $title = array();
 756         foreach ($groupIds as $gId) {
 757           $title[] = $allGroups[$gId];
 758         }
 759         $group['title'] .= '<div class="crm-row-parent-name"><em>' . ts('Child of') . '</em>: ' . implode(', ', $title) . '</div>';
 760         $value['class'] = array_diff($value['class'], array('crm-row-parent'));
 761       }
 762       $group['DT_RowId'] = 'row_' . $value['id'];
 763       if (empty($params['parentsOnly'])) {
 764         foreach ($value['class'] as $id => $class) {
 765           if ($class == 'crm-group-parent') {
 766             unset($value['class'][$id]);
 767           }
 768         }
 769       }
 770       $group['DT_RowClass'] = 'crm-entity ' . implode(' ', $value['class']);
 771       $group['DT_RowAttr'] = array();
 772       $group['DT_RowAttr']['data-id'] = $value['id'];
 773       $group['DT_RowAttr']['data-entity'] = 'group';
 774
 775       $group['description'] = CRM_Utils_Array::value('description', $value);
 776
 777       if (!empty($value['group_type'])) {
 778         $group['group_type'] = $value['group_type'];
 779       }
 780       else {
 781         $group['group_type'] = '';
 782       }
 783
 784       $group['visibility'] = $value['visibility'];
 785       $group['links'] = $value['action'];
 786       $group['org_info'] = CRM_Utils_Array::value('org_info', $value);
 787       $group['created_by'] = CRM_Utils_Array::value('created_by', $value);
 788
 789       $group['is_parent'] = $value['is_parent'];
 790
 791       array_push($groupList, $group);
 792     }
 793
 794     $groupsDT = array();
 795     $groupsDT['data'] = $groupList;
 796     $groupsDT['recordsTotal'] = !empty($params['total']) ? $params['total'] : NULL;
 797     $groupsDT['recordsFiltered'] = !empty($params['total']) ? $params['total'] : NULL;
 798
 799     return $groupsDT;
 800   }
 801
 802   /**
 803    * This function to get list of groups.
 804    *
 805    * @param array $params
 806    *   Associated array for params.
 807    *
 808    * @return array
 809    */
 810   public static function getGroupList(&$params) {
 811     $config = CRM_Core_Config::singleton();
 812
 813     $whereClause = self::whereClause($params, FALSE);
 814
 815     //$this->pagerAToZ( $whereClause, $params );
 816
 817     $limit = "";
 818     if (!empty($params['rowCount']) &&
 819       $params['rowCount'] > 0
 820     ) {
 821       $limit = " LIMIT {$params['offset']}, {$params['rowCount']} ";
 822     }
 823
 824     $orderBy = ' ORDER BY groups.title asc';
 825     if (!empty($params['sort'])) {
 826       $orderBy = ' ORDER BY ' . CRM_Utils_Type::escape($params['sort'], 'String');
 827
 828       // CRM-16905 - Sort by count cannot be done with sql
 829       if (strpos($params['sort'], 'count') === 0) {
 830         $orderBy = $limit = '';
 831       }
 832     }
 833
 834     $select = $from = $where = "";
 835     $groupOrg = FALSE;
 836     if (CRM_Core_Permission::check('administer Multiple Organizations') &&
 837       CRM_Core_Permission::isMultisiteEnabled()
 838     ) {
 839       $select = ", contact.display_name as org_name, contact.id as org_id";
 840       $from = " LEFT JOIN civicrm_group_organization gOrg
 841                                ON gOrg.group_id = groups.id
 842                         LEFT JOIN civicrm_contact contact
 843                                ON contact.id = gOrg.organization_id ";
 844
 845       //get the Organization ID
 846       $orgID = CRM_Utils_Request::retrieve('oid', 'Positive', CRM_Core_DAO::$_nullObject);
 847       if ($orgID) {
 848         $where = " AND gOrg.organization_id = {$orgID}";
 849       }
 850
 851       $groupOrg = TRUE;
 852     }
 853
 854     $query = "
 855         SELECT groups.*, createdBy.sort_name as created_by {$select}
 856         FROM  civicrm_group groups
 857         LEFT JOIN civicrm_contact createdBy
 858           ON createdBy.id = groups.created_id
 859         {$from}
 860         WHERE $whereClause {$where}
 861         {$orderBy}
 862         {$limit}";
 863
 864     $object = CRM_Core_DAO::executeQuery($query, $params, TRUE, 'CRM_Contact_DAO_Group');
 865
 866     //FIXME CRM-4418, now we are handling delete separately
 867     //if we introduce 'delete for group' make sure to handle here.
 868     $groupPermissions = array(CRM_Core_Permission::VIEW);
 869     if (CRM_Core_Permission::check('edit groups')) {
 870       $groupPermissions[] = CRM_Core_Permission::EDIT;
 871       $groupPermissions[] = CRM_Core_Permission::DELETE;
 872     }
 873
 874     // CRM-9936
 875     $reservedPermission = CRM_Core_Permission::check('administer reserved groups');
 876
 877     $links = self::actionLinks();
 878
 879     $allTypes = CRM_Core_OptionGroup::values('group_type');
 880     $values = $groupsToCount = array();
 881
 882     $visibility = CRM_Core_SelectValues::ufVisibility();
 883
 884     while ($object->fetch()) {
 885       $permission = CRM_Contact_BAO_Group::checkPermission($object->id, $object->title);
 886       //@todo CRM-12209 introduced an ACL check in the whereClause function
 887       // it may be that this checking is now obsolete - or that what remains
 888       // should be removed to the whereClause (which is also accessed by getCount)
 889
 890       if ($permission) {
 891         $newLinks = $links;
 892         $values[$object->id] = array(
 893           'class' => array(),
 894           'count' => '0',
 895         );
 896         CRM_Core_DAO::storeValues($object, $values[$object->id]);
 897
 898         if ($object->saved_search_id) {
 899           $values[$object->id]['title'] .= ' (' . ts('Smart Group') . ')';
 900           // check if custom search, if so fix view link
 901           $customSearchID = CRM_Core_DAO::getFieldValue(
 902             'CRM_Contact_DAO_SavedSearch',
 903             $object->saved_search_id,
 904             'search_custom_id'
 905           );
 906
 907           if ($customSearchID) {
 908             $newLinks[CRM_Core_Action::VIEW]['url'] = 'civicrm/contact/search/custom';
 909             $newLinks[CRM_Core_Action::VIEW]['qs'] = "reset=1&force=1&ssID={$object->saved_search_id}";
 910           }
 911         }
 912
 913         $action = array_sum(array_keys($newLinks));
 914
 915         // CRM-9936
 916         if (array_key_exists('is_reserved', $object)) {
 917           //if group is reserved and I don't have reserved permission, suppress delete/edit
 918           if ($object->is_reserved && !$reservedPermission) {
 919             $action -= CRM_Core_Action::DELETE;
 920             $action -= CRM_Core_Action::UPDATE;
 921             $action -= CRM_Core_Action::DISABLE;
 922           }
 923         }
 924
 925         if (array_key_exists('is_active', $object)) {
 926           if ($object->is_active) {
 927             $action -= CRM_Core_Action::ENABLE;
 928           }
 929           else {
 930             $values[$object->id]['class'][] = 'disabled';
 931             $action -= CRM_Core_Action::VIEW;
 932             $action -= CRM_Core_Action::DISABLE;
 933           }
 934         }
 935
 936         $action = $action & CRM_Core_Action::mask($groupPermissions);
 937
 938         $values[$object->id]['visibility'] = $visibility[$values[$object->id]['visibility']];
 939
 940         $groupsToCount[$object->saved_search_id ? 'civicrm_group_contact_cache' : 'civicrm_group_contact'][] = $object->id;
 941
 942         if (isset($values[$object->id]['group_type'])) {
 943           $groupTypes = explode(CRM_Core_DAO::VALUE_SEPARATOR,
 944             substr($values[$object->id]['group_type'], 1, -1)
 945           );
 946           $types = array();
 947           foreach ($groupTypes as $type) {
 948             $types[] = CRM_Utils_Array::value($type, $allTypes);
 949           }
 950           $values[$object->id]['group_type'] = implode(', ', $types);
 951         }
 952         $values[$object->id]['action'] = CRM_Core_Action::formLink($newLinks,
 953           $action,
 954           array(
 955             'id' => $object->id,
 956             'ssid' => $object->saved_search_id,
 957           ),
 958           ts('more'),
 959           FALSE,
 960           'group.selector.row',
 961           'Group',
 962           $object->id
 963         );
 964
 965         // If group has children, add class for link to view children
 966         $values[$object->id]['is_parent'] = FALSE;
 967         if (array_key_exists('children', $values[$object->id])) {
 968           $values[$object->id]['class'][] = "crm-group-parent";
 969           $values[$object->id]['is_parent'] = TRUE;
 970         }
 971
 972         // If group is a child, add child class
 973         if (array_key_exists('parents', $values[$object->id])) {
 974           $values[$object->id]['class'][] = "crm-group-child";
 975         }
 976
 977         if ($groupOrg) {
 978           if ($object->org_id) {
 979             $contactUrl = CRM_Utils_System::url('civicrm/contact/view', "reset=1&cid={$object->org_id}");
 980             $values[$object->id]['org_info'] = "<a href='{$contactUrl}'>{$object->org_name}</a>";
 981           }
 982           else {
 983             $values[$object->id]['org_info'] = ''; // Empty cell
 984           }
 985         }
 986         else {
 987           $values[$object->id]['org_info'] = NULL; // Collapsed column if all cells are NULL
 988         }
 989         if ($object->created_id) {
 990           $contactUrl = CRM_Utils_System::url('civicrm/contact/view', "reset=1&cid={$object->created_id}");
 991           $values[$object->id]['created_by'] = "<a href='{$contactUrl}'>{$object->created_by}</a>";
 992         }
 993       }
 994     }
 995
 996     // Get group counts - executes one query for regular groups and another for smart groups
 997     foreach ($groupsToCount as $table => $groups) {
 998       $where = "g.group_id IN (" . implode(',', $groups) . ")";
 999       if ($table == 'civicrm_group_contact') {
1000         $where .= " AND g.status = 'Added'";
1001       }
1002       // Exclude deleted contacts
1003       $where .= " and c.id = g.contact_id AND c.is_deleted = 0";
1004       $dao = CRM_Core_DAO::executeQuery("SELECT g.group_id, COUNT(g.id) as `count` FROM $table g, civicrm_contact c WHERE $where GROUP BY g.group_id");
1005       while ($dao->fetch()) {
1006         $values[$dao->group_id]['count'] = $dao->count;
1007       }
1008     }
1009
1010     // CRM-16905 - Sort by count cannot be done with sql
1011     if (!empty($params['sort']) && strpos($params['sort'], 'count') === 0) {
1012       usort($values, function($a, $b) {
1013         return $a['count'] - $b['count'];
1014       });
1015       if (strpos($params['sort'], 'desc')) {
1016         $values = array_reverse($values, TRUE);
1017       }
1018       return array_slice($values, $params['offset'], $params['rowCount']);
1019     }
1020
1021     return $values;
1022   }
1023
1024   /**
1025    * This function to get hierarchical list of groups (parent followed by children)
1026    *
1027    * @param array $groupIDs
1028    *   Array of group ids.
1029    *
1030    * @param NULL $parents
1031    * @param string $spacer
1032    * @param bool $titleOnly
1033    *
1034    * @return array
1035    */
1036   public static function getGroupsHierarchy(
1037     $groupIDs,
1038     $parents = NULL,
1039     $spacer = '<span class="child-indent"></span>',
1040     $titleOnly = FALSE
1041   ) {
1042     if (empty($groupIDs)) {
1043       return array();
1044     }
1045
1046     $groupIdString = '(' . implode(',', array_keys($groupIDs)) . ')';
1047     // <span class="child-icon"></span>
1048     // need to return id, title (w/ spacer), description, visibility
1049
1050     // We need to build a list of tags ordered by hierarchy and sorted by
1051     // name. The hierarchy will be communicated by an accumulation of
1052     // separators in front of the name to give it a visual offset.
1053     // Instead of recursively making mysql queries, we'll make one big
1054     // query and build the hierarchy with the algorithm below.
1055     $groups = array();
1056     $args = array(1 => array($groupIdString, 'String'));
1057     $query = "
1058 SELECT id, title, description, visibility, parents
1059 FROM   civicrm_group
1060 WHERE  id IN $groupIdString
1061 ";
1062     if ($parents) {
1063       // group can have > 1 parent so parents may be comma separated list (eg. '1,2,5'). We just grab and match on 1st parent.
1064       $parentArray = explode(',', $parents);
1065       $parent = $parentArray[0];
1066       $args[2] = array($parent, 'Integer');
1067       $query .= " AND SUBSTRING_INDEX(parents, ',', 1) = %2";
1068     }
1069     $query .= " ORDER BY title";
1070     $dao = CRM_Core_DAO::executeQuery($query, $args);
1071
1072     // Sort the groups into the correct storage by the parent
1073     // $roots represent the current leaf nodes that need to be checked for
1074     // children. $rows represent the unplaced nodes
1075     $roots = $rows = $allGroups = array();
1076     while ($dao->fetch()) {
1077       $allGroups[$dao->id] = array(
1078         'title' => $dao->title,
1079         'visibility' => $dao->visibility,
1080         'description' => $dao->description,
1081       );
1082
1083       if ($dao->parents == $parents) {
1084         $roots[] = array(
1085           'id' => $dao->id,
1086           'prefix' => '',
1087           'title' => $dao->title,
1088         );
1089       }
1090       else {
1091         // group can have > 1 parent so $dao->parents may be comma separated list (eg. '1,2,5'). Grab and match on 1st parent.
1092         $parentArray = explode(',', $dao->parents);
1093         $parent = $parentArray[0];
1094         $rows[] = array(
1095           'id' => $dao->id,
1096           'prefix' => '',
1097           'title' => $dao->title,
1098           'parents' => $parent,
1099         );
1100       }
1101     }
1102     $dao->free();
1103     // While we have nodes left to build, shift the first (alphabetically)
1104     // node of the list, place it in our groups list and loop through the
1105     // list of unplaced nodes to find its children. We make a copy to
1106     // iterate through because we must modify the unplaced nodes list
1107     // during the loop.
1108     while (count($roots)) {
1109       $new_roots = array();
1110       $current_rows = $rows;
1111       $root = array_shift($roots);
1112       $groups[$root['id']] = array($root['prefix'], $root['title']);
1113
1114       // As you find the children, append them to the end of the new set
1115       // of roots (maintain alphabetical ordering). Also remove the node
1116       // from the set of unplaced nodes.
1117       if (is_array($current_rows)) {
1118         foreach ($current_rows as $key => $row) {
1119           if ($row['parents'] == $root['id']) {
1120             $new_roots[] = array(
1121               'id' => $row['id'],
1122               'prefix' => $groups[$root['id']][0] . $spacer,
1123               'title' => $row['title'],
1124             );
1125             unset($rows[$key]);
1126           }
1127         }
1128       }
1129
1130       //As a group, insert the new roots into the beginning of the roots
1131       //list. This maintains the hierarchical ordering of the tags.
1132       $roots = array_merge($new_roots, $roots);
1133     }
1134
1135     // below is the redundant looping to ensure child groups are populated in the case where user does not have
1136     // access to parent groups ( esp. using ACL permissions and logged in user can assess only child groups )
1137     foreach ($rows as $value) {
1138       $groups[$value['id']] = array($value['prefix'], $value['title']);
1139     }
1140     // Prefix titles with the calcuated spacing to give the visual
1141     // appearance of ordering when transformed into HTML in the form layer. Add description and visibility.
1142     $groupsReturn = array();
1143     foreach ($groups as $key => $value) {
1144       if ($titleOnly) {
1145         $groupsReturn[$key] = $value[0] . $value[1];
1146       }
1147       else {
1148         $groupsReturn[$key] = array(
1149           'title' => $value[0] . $value[1],
1150           'description' => $allGroups[$key]['description'],
1151           'visibility' => $allGroups[$key]['visibility'],
1152         );
1153       }
1154     }
1155
1156     return $groupsReturn;
1157   }
1158
1159   /**
1160    * @param array $params
1161    *
1162    * @return NULL|string
1163    */
1164   public static function getGroupCount(&$params) {
1165     $whereClause = self::whereClause($params, FALSE);
1166     $query = "SELECT COUNT(*) FROM civicrm_group groups";
1167
1168     if (!empty($params['created_by'])) {
1169       $query .= "
1170 INNER JOIN civicrm_contact createdBy
1171        ON createdBy.id = groups.created_id";
1172     }
1173     $query .= "
1174 WHERE {$whereClause}";
1175     return CRM_Core_DAO::singleValueQuery($query, $params);
1176   }
1177
1178   /**
1179    * Generate permissioned where clause for group search.
1180    * @param array $params
1181    * @param bool $sortBy
1182    * @param bool $excludeHidden
1183    *
1184    * @return string
1185    */
1186   public static function whereClause(&$params, $sortBy = TRUE, $excludeHidden = TRUE) {
1187     $values = array();
1188     $title = CRM_Utils_Array::value('title', $params);
1189     if ($title) {
1190       $clauses[] = "groups.title LIKE %1";
1191       if (strpos($title, '%') !== FALSE) {
1192         $params[1] = array($title, 'String', FALSE);
1193       }
1194       else {
1195         $params[1] = array($title, 'String', TRUE);
1196       }
1197     }
1198
1199     $groupType = CRM_Utils_Array::value('group_type', $params);
1200     if ($groupType) {
1201       $types = explode(',', $groupType);
1202       if (!empty($types)) {
1203         $clauses[] = 'groups.group_type LIKE %2';
1204         $typeString = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR, $types) . CRM_Core_DAO::VALUE_SEPARATOR;
1205         $params[2] = array($typeString, 'String', TRUE);
1206       }
1207     }
1208
1209     $visibility = CRM_Utils_Array::value('visibility', $params);
1210     if ($visibility) {
1211       $clauses[] = 'groups.visibility = %3';
1212       $params[3] = array($visibility, 'String');
1213     }
1214
1215     $groupStatus = CRM_Utils_Array::value('status', $params);
1216     if ($groupStatus) {
1217       switch ($groupStatus) {
1218         case 1:
1219           $clauses[] = 'groups.is_active = 1';
1220           $params[4] = array($groupStatus, 'Integer');
1221           break;
1222
1223         case 2:
1224           $clauses[] = 'groups.is_active = 0';
1225           $params[4] = array($groupStatus, 'Integer');
1226           break;
1227
1228         case 3:
1229           $clauses[] = '(groups.is_active = 0 OR groups.is_active = 1 )';
1230           break;
1231       }
1232     }
1233
1234     $parentsOnly = CRM_Utils_Array::value('parentsOnly', $params);
1235     if ($parentsOnly) {
1236       $clauses[] = 'groups.parents IS NULL';
1237     }
1238
1239     // only show child groups of a specific parent group
1240     $parent_id = CRM_Utils_Array::value('parent_id', $params);
1241     if ($parent_id) {
1242       $clauses[] = 'groups.id IN (SELECT child_group_id FROM civicrm_group_nesting WHERE parent_group_id = %5)';
1243       $params[5] = array($parent_id, 'Integer');
1244     }
1245
1246     if ($createdBy = CRM_Utils_Array::value('created_by', $params)) {
1247       $clauses[] = "createdBy.sort_name LIKE %6";
1248       if (strpos($createdBy, '%') !== FALSE) {
1249         $params[6] = array($createdBy, 'String', FALSE);
1250       }
1251       else {
1252         $params[6] = array($createdBy, 'String', TRUE);
1253       }
1254     }
1255
1256     if (empty($clauses)) {
1257       $clauses[] = 'groups.is_active = 1';
1258     }
1259
1260     if ($excludeHidden) {
1261       $clauses[] = 'groups.is_hidden = 0';
1262     }
1263
1264     $clauses[] = self::getPermissionClause();
1265
1266     return implode(' AND ', $clauses);
1267   }
1268
1269   /**
1270    * Define action links.
1271    *
1272    * @return array
1273    *   array of action links
1274    */
1275   public static function actionLinks() {
1276     $links = array(
1277       CRM_Core_Action::VIEW => array(
1278         'name' => ts('Contacts'),
1279         'url' => 'civicrm/group/search',
1280         'qs' => 'reset=1&force=1&context=smog&gid=%%id%%',
1281         'title' => ts('Group Contacts'),
1282       ),
1283       CRM_Core_Action::UPDATE => array(
1284         'name' => ts('Settings'),
1285         'url' => 'civicrm/group',
1286         'qs' => 'reset=1&action=update&id=%%id%%',
1287         'title' => ts('Edit Group'),
1288       ),
1289       CRM_Core_Action::DISABLE => array(
1290         'name' => ts('Disable'),
1291         'ref' => 'crm-enable-disable',
1292         'title' => ts('Disable Group'),
1293       ),
1294       CRM_Core_Action::ENABLE => array(
1295         'name' => ts('Enable'),
1296         'ref' => 'crm-enable-disable',
1297         'title' => ts('Enable Group'),
1298       ),
1299       CRM_Core_Action::DELETE => array(
1300         'name' => ts('Delete'),
1301         'url' => 'civicrm/group',
1302         'qs' => 'reset=1&action=delete&id=%%id%%',
1303         'title' => ts('Delete Group'),
1304       ),
1305     );
1306
1307     return $links;
1308   }
1309
1310   /**
1311    * @param $whereClause
1312    * @param array $whereParams
1313    *
1314    * @return string
1315    */
1316   public function pagerAtoZ($whereClause, $whereParams) {
1317     $query = "
1318         SELECT DISTINCT UPPER(LEFT(groups.title, 1)) as sort_name
1319         FROM  civicrm_group groups
1320         WHERE $whereClause
1321         ORDER BY LEFT(groups.title, 1)
1322             ";
1323     $dao = CRM_Core_DAO::executeQuery($query, $whereParams);
1324
1325     return CRM_Utils_PagerAToZ::getAToZBar($dao, $this->_sortByCharacter, TRUE);
1326   }
1327
1328   /**
1329    * Assign Test Value.
1330    *
1331    * @param string $fieldName
1332    * @param array $fieldDef
1333    * @param int $counter
1334    */
1335   protected function assignTestValue($fieldName, &$fieldDef, $counter) {
1336     if ($fieldName == 'children' || $fieldName == 'parents') {
1337       $this->{$fieldName} = "NULL";
1338     }
1339     else {
1340       parent::assignTestValues($fieldName, $fieldDef, $counter);
1341     }
1342   }
1343
1344 }