CRM/Contact/BAO/Group.php

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