Personal/drupal-civicrm
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
drupal-civicrm/sites/all/modules/civicrm/CRM/Contact/BAO/Group.php

1416 lines
45 KiB
PHP
Raw Normal View History

First commit
2018-01-14 15:10:16 +02:00
<?php
/*
+--------------------------------------------------------------------+
| CiviCRM version 4.7 |
+--------------------------------------------------------------------+
| Copyright CiviCRM LLC (c) 2004-2017 |
+--------------------------------------------------------------------+
| This file is a part of CiviCRM. |
| |
| CiviCRM is free software; you can copy, modify, and distribute it |
| under the terms of the GNU Affero General Public License |
| Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
| |
| CiviCRM is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| See the GNU Affero General Public License for more details. |
| |
| You should have received a copy of the GNU Affero General Public |
| License and the CiviCRM Licensing Exception along |
| with this program; if not, contact CiviCRM LLC |
| at info[AT]civicrm[DOT]org. If you have questions about the |
| GNU Affero General Public License or the licensing of CiviCRM, |
| see the CiviCRM license FAQ at http://civicrm.org/licensing |
+--------------------------------------------------------------------+
*/
/**
*
* @package CRM
* @copyright CiviCRM LLC (c) 2004-2017
*/
class CRM_Contact_BAO_Group extends CRM_Contact_DAO_Group {
/**
* Class constructor.
*/
public function __construct() {
parent::__construct();
}
/**
* Retrieve DB object based on input parameters.
*
* It also stores all the retrieved values in the default array.
*
* @param array $params
* (reference ) an assoc array of name/value pairs.
* @param array $defaults
* (reference ) an assoc array to hold the flattened values.
*
* @return CRM_Contact_BAO_Group
*/
public static function retrieve(&$params, &$defaults) {
$group = new CRM_Contact_DAO_Group();
$group->copyValues($params);
if ($group->find(TRUE)) {
CRM_Core_DAO::storeValues($group, $defaults);
return $group;
}
}
/**
* Delete the group and all the object that connect to this group.
*
* Incredibly destructive.
*
* @param int $id Group id.
*/
public static function discard($id) {
CRM_Utils_Hook::pre('delete', 'Group', $id, CRM_Core_DAO::$_nullArray);
$transaction = new CRM_Core_Transaction();
// added for CRM-1631 and CRM-1794
// delete all subscribed mails with the selected group id
$subscribe = new CRM_Mailing_Event_DAO_Subscribe();
$subscribe->group_id = $id;
$subscribe->delete();
// delete all Subscription records with the selected group id
$subHistory = new CRM_Contact_DAO_SubscriptionHistory();
$subHistory->group_id = $id;
$subHistory->delete();
// delete all crm_group_contact records with the selected group id
$groupContact = new CRM_Contact_DAO_GroupContact();
$groupContact->group_id = $id;
$groupContact->delete();
// make all the 'add_to_group_id' field of 'civicrm_uf_group table', pointing to this group, as null
$params = array(1 => array($id, 'Integer'));
$query = "UPDATE civicrm_uf_group SET `add_to_group_id`= NULL WHERE `add_to_group_id` = %1";
CRM_Core_DAO::executeQuery($query, $params);
$query = "UPDATE civicrm_uf_group SET `limit_listings_group_id`= NULL WHERE `limit_listings_group_id` = %1";
CRM_Core_DAO::executeQuery($query, $params);
// make sure u delete all the entries from civicrm_mailing_group and civicrm_campaign_group
// CRM-6186
$query = "DELETE FROM civicrm_mailing_group where entity_table = 'civicrm_group' AND entity_id = %1";
CRM_Core_DAO::executeQuery($query, $params);
$query = "DELETE FROM civicrm_campaign_group where entity_table = 'civicrm_group' AND entity_id = %1";
CRM_Core_DAO::executeQuery($query, $params);
$query = "DELETE FROM civicrm_acl_entity_role where entity_table = 'civicrm_group' AND entity_id = %1";
CRM_Core_DAO::executeQuery($query, $params);
// delete from group table
$group = new CRM_Contact_DAO_Group();
$group->id = $id;
$group->delete();
$transaction->commit();
CRM_Utils_Hook::post('delete', 'Group', $id, $group);
// delete the recently created Group
$groupRecent = array(
'id' => $id,
'type' => 'Group',
);
CRM_Utils_Recent::del($groupRecent);
}
/**
* Returns an array of the contacts in the given group.
*
* @param int $id
*/
public static function getGroupContacts($id) {
$params = array(array('group', 'IN', array(1 => $id), 0, 0));
list($contacts, $_) = CRM_Contact_BAO_Query::apiQuery($params, array('contact_id'));
return $contacts;
}
/**
* Get the count of a members in a group with the specific status.
*
* @param int $id
* Group id.
* @param string $status
* status of members in group
* @param bool $countChildGroups
*
* @return int
* count of members in the group with above status
*/
public static function memberCount($id, $status = 'Added', $countChildGroups = FALSE) {
$groupContact = new CRM_Contact_DAO_GroupContact();
$groupIds = array($id);
if ($countChildGroups) {
$groupIds = CRM_Contact_BAO_GroupNesting::getDescendentGroupIds($groupIds);
}
$count = 0;
$contacts = self::getGroupContacts($id);
foreach ($groupIds as $groupId) {
$groupContacts = self::getGroupContacts($groupId);
foreach ($groupContacts as $gcontact) {
if ($groupId != $id) {
// Loop through main group's contacts
// and subtract from the count for each contact which
// matches one in the present group, if it is not the
// main group
foreach ($contacts as $contact) {
if ($contact['contact_id'] == $gcontact['contact_id']) {
$count--;
}
}
}
}
$groupContact->group_id = $groupId;
if (isset($status)) {
$groupContact->status = $status;
}
$groupContact->_query['condition'] = 'WHERE contact_id NOT IN (SELECT id FROM civicrm_contact WHERE is_deleted = 1)';
$count += $groupContact->count();
}
return $count;
}
/**
* Get the list of member for a group id.
*
* @param int $groupID
* @param bool $useCache
* @param int $limit
* Number to limit to (or 0 for unlimited).
*
* @return array
* this array contains the list of members for this group id
*/
public static function getMember($groupID, $useCache = TRUE, $limit = 0) {
$params = array(array('group', '=', $groupID, 0, 0));
$returnProperties = array('contact_id');
list($contacts) = CRM_Contact_BAO_Query::apiQuery($params, $returnProperties, NULL, NULL, 0, $limit, $useCache);
$aMembers = array();
foreach ($contacts as $contact) {
$aMembers[$contact['contact_id']] = 1;
}
return $aMembers;
}
/**
* Returns array of group object(s) matching a set of one or Group properties.
*
* @param array $params
* Limits the set of groups returned.
* @param array $returnProperties
* Which properties should be included in the returned group objects.
* (member_count should be last element.)
* @param string $sort
* @param int $offset
* @param int $rowCount
*
* @return array
* Array of group objects.
*
*
* @todo other BAO functions that use returnProperties (e.g. Query Objects) receive the array flipped & filled with 1s and
* add in essential fields (e.g. id). This should follow a regular pattern like the others
*/
public static function getGroups(
$params = NULL,
$returnProperties = NULL,
$sort = NULL,
$offset = NULL,
$rowCount = NULL
) {
$dao = new CRM_Contact_DAO_Group();
if (!isset($params['is_active'])) {
$dao->is_active = 1;
}
if ($params) {
foreach ($params as $k => $v) {
if ($k == 'name' || $k == 'title') {
$dao->whereAdd($k . ' LIKE "' . CRM_Core_DAO::escapeString($v) . '"');
}
elseif ($k == 'group_type') {
foreach ((array) $v as $type) {
$dao->whereAdd($k . " LIKE '%" . CRM_Core_DAO::VALUE_SEPARATOR . (int) $type . CRM_Core_DAO::VALUE_SEPARATOR . "%'");
}
}
elseif (is_array($v)) {
foreach ($v as &$num) {
$num = (int) $num;
}
$dao->whereAdd($k . ' IN (' . implode(',', $v) . ')');
}
else {
$dao->$k = $v;
}
}
}
if ($offset || $rowCount) {
$offset = ($offset > 0) ? $offset : 0;
$rowCount = ($rowCount > 0) ? $rowCount : 25;
$dao->limit($offset, $rowCount);
}
if ($sort) {
$dao->orderBy($sort);
}
// return only specific fields if returnproperties are sent
if (!empty($returnProperties)) {
$dao->selectAdd();
$dao->selectAdd(implode(',', $returnProperties));
}
$dao->find();
$flag = $returnProperties && in_array('member_count', $returnProperties) ? 1 : 0;
$groups = array();
while ($dao->fetch()) {
$group = new CRM_Contact_DAO_Group();
if ($flag) {
$dao->member_count = CRM_Contact_BAO_Group::memberCount($dao->id);
}
$groups[] = clone($dao);
}
return $groups;
}
/**
* Make sure that the user has permission to access this group.
*
* @param int $id
* The id of the object.
* @param bool $excludeHidden
* Should hidden groups be excluded.
* Logically this is the wrong place to filter hidden groups out as that is
* not a permission issue. However, as other functions may rely on that defaulting to
* FALSE for now & only the api call is calling with true.
*
* @return array
* The permission that the user has (or NULL)
*/
public static function checkPermission($id, $excludeHidden = FALSE) {
$allGroups = CRM_Core_PseudoConstant::allGroup(NULL, $excludeHidden);
$permissions = NULL;
if (CRM_Core_Permission::check('edit all contacts') ||
CRM_ACL_API::groupPermission(CRM_ACL_API::EDIT, $id, NULL,
'civicrm_saved_search', $allGroups
)
) {
$permissions[] = CRM_Core_Permission::EDIT;
}
if (CRM_Core_Permission::check('view all contacts') ||
CRM_ACL_API::groupPermission(CRM_ACL_API::VIEW, $id, NULL,
'civicrm_saved_search', $allGroups
)
) {
$permissions[] = CRM_Core_Permission::VIEW;
}
if (!empty($permissions) && CRM_Core_Permission::check('delete contacts')) {
// Note: using !empty() in if condition, restricts the scope of delete
// permission to groups/contacts that are editable/viewable.
// We can remove this !empty condition once we have ACL support for delete functionality.
$permissions[] = CRM_Core_Permission::DELETE;
}
return $permissions;
}
/**
* Create a new group.
*
* @param array $params
*
* @return CRM_Contact_BAO_Group|NULL
* The new group BAO (if created)
*/
public static function create(&$params) {
if (!empty($params['id'])) {
CRM_Utils_Hook::pre('edit', 'Group', $params['id'], $params);
}
else {
CRM_Utils_Hook::pre('create', 'Group', NULL, $params);
}
// form the name only if missing: CRM-627
$nameParam = CRM_Utils_Array::value('name', $params, NULL);
if (!$nameParam && empty($params['id'])) {
$params['name'] = CRM_Utils_String::titleToVar($params['title']);
}
// convert params if array type
if (isset($params['group_type'])) {
if (is_array($params['group_type'])) {
$params['group_type'] = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
CRM_Utils_Array::convertCheckboxFormatToArray($params['group_type'])
) . CRM_Core_DAO::VALUE_SEPARATOR;
}
else {
$params['group_type'] = CRM_Core_DAO::VALUE_SEPARATOR . $params['group_type'] . CRM_Core_DAO::VALUE_SEPARATOR;
}
}
else {
$params['group_type'] = NULL;
}
$session = CRM_Core_Session::singleton();
$cid = $session->get('userID');
// this action is add
if ($cid && empty($params['id'])) {
$params['created_id'] = $cid;
}
// this action is update
if ($cid && !empty($params['id'])) {
$params['modified_id'] = $cid;
}
// CRM-19068.
// Validate parents parameter when creating group.
if (!empty($params['parents'])) {
$parents = is_array($params['parents']) ? array_keys($params['parents']) : (array) $params['parents'];
foreach ($parents as $parent) {
CRM_Utils_Type::validate($parent, 'Integer');
}
}
$group = new CRM_Contact_BAO_Group();
$group->copyValues($params);
//@todo very hacky fix for the fact this function wants to receive 'parents' as an array further down but
// needs it as a separated string for the DB. Preferred approaches are having the copyParams or save fn
// use metadata to translate the array to the appropriate DB type or altering the param in the api layer,
// or at least altering the param in same section as 'group_type' rather than repeating here. However, further down
// we need the $params one to be in it's original form & we are not sure what test coverage we have on that
if (isset($group->parents) && is_array($group->parents)) {
$group->parents = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR,
array_keys($group->parents)
) . CRM_Core_DAO::VALUE_SEPARATOR;
}
if (empty($params['id']) &&
!$nameParam
) {
$group->name .= "_tmp";
}
$group->save();
if (!$group->id) {
return NULL;
}
if (empty($params['id']) &&
!$nameParam
) {
$group->name = substr($group->name, 0, -4) . "_{$group->id}";
}
$group->buildClause();
$group->save();
// add custom field values
if (!empty($params['custom'])) {
CRM_Core_BAO_CustomValueTable::store($params['custom'], 'civicrm_group', $group->id);
}
// make the group, child of domain/site group by default.
$domainGroupID = CRM_Core_BAO_Domain::getGroupId();
if (CRM_Utils_Array::value('no_parent', $params) !== 1) {
if (empty($params['parents']) &&
$domainGroupID != $group->id &&
Civi::settings()->get('is_enabled') &&
!CRM_Contact_BAO_GroupNesting::hasParentGroups($group->id)
) {
// if no parent present and the group doesn't already have any parents,
// make sure site group goes as parent
$params['parents'] = array($domainGroupID => 1);
}
elseif (array_key_exists('parents', $params) && !is_array($params['parents'])) {
$params['parents'] = array($params['parents'] => 1);
}
if (!empty($params['parents'])) {
foreach ($params['parents'] as $parentId => $dnc) {
if ($parentId && !CRM_Contact_BAO_GroupNesting::isParentChild($parentId, $group->id)) {
CRM_Contact_BAO_GroupNesting::add($parentId, $group->id);
}
}
}
// this is always required, since we don't know when a
// parent group is removed
CRM_Contact_BAO_GroupNestingCache::update();
// update group contact cache for all parent groups
$parentIds = CRM_Contact_BAO_GroupNesting::getParentGroupIds($group->id);
foreach ($parentIds as $parentId) {
CRM_Contact_BAO_GroupContactCache::add($parentId);
}
}
if (!empty($params['organization_id'])) {
$groupOrg = $params;
$groupOrg['group_id'] = $group->id;
CRM_Contact_BAO_GroupOrganization::add($groupOrg);
}
self::flushCaches();
CRM_Contact_BAO_GroupContactCache::add($group->id);
if (!empty($params['id'])) {
CRM_Utils_Hook::post('edit', 'Group', $group->id, $group);
}
else {
CRM_Utils_Hook::post('create', 'Group', $group->id, $group);
}
$recentOther = array();
if (CRM_Core_Permission::check('edit groups')) {
$recentOther['editUrl'] = CRM_Utils_System::url('civicrm/group', 'reset=1&action=update&id=' . $group->id);
// currently same permission we are using for delete a group
$recentOther['deleteUrl'] = CRM_Utils_System::url('civicrm/group', 'reset=1&action=delete&id=' . $group->id);
}
// add the recently added group (unless hidden: CRM-6432)
if (!$group->is_hidden) {
CRM_Utils_Recent::add($group->title,
CRM_Utils_System::url('civicrm/group/search', 'reset=1&force=1&context=smog&gid=' . $group->id),
$group->id,
'Group',
NULL,
NULL,
$recentOther
);
}
return $group;
}
/**
* Given a saved search compute the clause and the tables
* and store it for future use
*/
public function buildClause() {
$params = array(array('group', 'IN', array($this->id), 0, 0));
if (!empty($params)) {
$tables = $whereTables = array();
$this->where_clause = CRM_Contact_BAO_Query::getWhereClause($params, NULL, $tables, $whereTables);
if (!empty($tables)) {
$this->select_tables = serialize($tables);
}
if (!empty($whereTables)) {
$this->where_tables = serialize($whereTables);
}
}
}
/**
* Defines a new smart group.
*
* @param array $params
* Associative array of parameters.
*
* @return CRM_Contact_BAO_Group|NULL
* The new group BAO (if created)
*/
public static function createSmartGroup(&$params) {
if (!empty($params['formValues'])) {
$ssParams = $params;
unset($ssParams['id']);
if (isset($ssParams['saved_search_id'])) {
$ssParams['id'] = $ssParams['saved_search_id'];
}
$savedSearch = CRM_Contact_BAO_SavedSearch::create($params);
$params['saved_search_id'] = $savedSearch->id;
}
else {
return NULL;
}
return self::create($params);
}
/**
* Update the is_active flag in the db.
*
* @param int $id
* Id of the database record.
* @param bool $isActive
* Value we want to set the is_active field.
*
* @return CRM_Core_DAO|null
* DAO object on success, NULL otherwise
*/
public static function setIsActive($id, $isActive) {
return CRM_Core_DAO::setFieldValue('CRM_Contact_DAO_Group', $id, 'is_active', $isActive);
}
/**
* Build the condition to retrieve groups.
*
* @param string $groupType
* Type of group(Access/Mailing) OR the key of the group.
* @param bool $excludeHidden exclude hidden groups.
*
* @return string
*/
public static function groupTypeCondition($groupType = NULL, $excludeHidden = TRUE) {
$value = NULL;
if ($groupType == 'Mailing') {
$value = CRM_Core_DAO::VALUE_SEPARATOR . '2' . CRM_Core_DAO::VALUE_SEPARATOR;
}
elseif ($groupType == 'Access') {
$value = CRM_Core_DAO::VALUE_SEPARATOR . '1' . CRM_Core_DAO::VALUE_SEPARATOR;
}
elseif (!empty($groupType)) {
// ie we have been given the group key
$value = CRM_Core_DAO::VALUE_SEPARATOR . $groupType . CRM_Core_DAO::VALUE_SEPARATOR;
}
$condition = NULL;
if ($excludeHidden) {
$condition = "is_hidden = 0";
}
if ($value) {
if ($condition) {
$condition .= " AND group_type LIKE '%$value%'";
}
else {
$condition = "group_type LIKE '%$value%'";
}
}
return $condition;
}
/**
* Get permission relevant clauses.
* CRM-12209
*
* @param bool $force
*
* @return array
*/
public static function getPermissionClause($force = FALSE) {
static $clause = 1;
static $retrieved = FALSE;
if (!$retrieved || $force) {
if (CRM_Core_Permission::check('view all contacts') || CRM_Core_Permission::check('edit all contacts')) {
$clause = 1;
}
else {
//get the allowed groups for the current user
$groups = CRM_ACL_API::group(CRM_ACL_API::VIEW);
if (!empty($groups)) {
$groupList = implode(', ', array_values($groups));
$clause = "groups.id IN ( $groupList ) ";
}
else {
$clause = '1 = 0';
}
}
}
$retrieved = TRUE;
return $clause;
}
/**
* Flush caches that hold group data.
*
* (Actually probably some overkill at the moment.)
*/
protected static function flushCaches() {
CRM_Utils_System::flushCache();
$staticCaches = array(
'CRM_Core_PseudoConstant' => 'groups',
'CRM_ACL_API' => 'group_permission',
'CRM_ACL_BAO_ACL' => 'permissioned_groups',
);
foreach ($staticCaches as $class => $key) {
if (isset(Civi::$statics[$class][$key])) {
unset(Civi::$statics[$class][$key]);
}
}
}
/**
* @return string
*/
public function __toString() {
return $this->title;
}
/**
* This function create the hidden smart group when user perform
* contact search and want to send mailing to search contacts.
*
* @param array $params
* ( reference ) an assoc array of name/value pairs.
*
* @return array
* ( smartGroupId, ssId ) smart group id and saved search id
*/
public static function createHiddenSmartGroup($params) {
$ssId = CRM_Utils_Array::value('saved_search_id', $params);
//add mapping record only for search builder saved search
$mappingId = NULL;
if ($params['search_context'] == 'builder') {
//save the mapping for search builder
if (!$ssId) {
//save record in mapping table
$mappingParams = array(
'mapping_type_id' => CRM_Core_OptionGroup::getValue('mapping_type',
'Search Builder',
'name'
),
);
$mapping = CRM_Core_BAO_Mapping::add($mappingParams);
$mappingId = $mapping->id;
}
else {
//get the mapping id from saved search
$savedSearch = new CRM_Contact_BAO_SavedSearch();
$savedSearch->id = $ssId;
$savedSearch->find(TRUE);
$mappingId = $savedSearch->mapping_id;
}
//save mapping fields
CRM_Core_BAO_Mapping::saveMappingFields($params['form_values'], $mappingId);
}
//create/update saved search record.
$savedSearch = new CRM_Contact_BAO_SavedSearch();
$savedSearch->id = $ssId;
$savedSearch->form_values = serialize($params['form_values']);
$savedSearch->mapping_id = $mappingId;
$savedSearch->search_custom_id = CRM_Utils_Array::value('search_custom_id', $params);
$savedSearch->save();
$ssId = $savedSearch->id;
if (!$ssId) {
return NULL;
}
$smartGroupId = NULL;
if (!empty($params['saved_search_id'])) {
$smartGroupId = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $ssId, 'id', 'saved_search_id');
}
else {
//create group only when new saved search.
$groupParams = array(
'title' => "Hidden Smart Group {$ssId}",
'is_active' => CRM_Utils_Array::value('is_active', $params, 1),
'is_hidden' => CRM_Utils_Array::value('is_hidden', $params, 1),
'group_type' => CRM_Utils_Array::value('group_type', $params),
'visibility' => CRM_Utils_Array::value('visibility', $params),
'saved_search_id' => $ssId,
);
$smartGroup = self::create($groupParams);
$smartGroupId = $smartGroup->id;
}
// Update mapping with the name and description of the hidden smart group.
if ($mappingId) {
$mappingParams = array(
'id' => $mappingId,
'name' => CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $smartGroupId, 'name', 'id'),
'description' => CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $smartGroupId, 'description', 'id'),
'mapping_type_id' => CRM_Core_OptionGroup::getValue('mapping_type',
'Search Builder',
'name'
),
);
CRM_Core_BAO_Mapping::add($mappingParams);
}
return array($smartGroupId, $ssId);
}
/**
* wrapper for ajax group selector.
*
* @param array $params
* Associated array for params record id.
*
* @return array
* associated array of group list
* -rp = rowcount
* -page= offset
* @todo there seems little reason for the small number of functions that call this to pass in
* params that then need to be translated in this function since they are coding them when calling
*/
static public function getGroupListSelector(&$params) {
// format the params
$params['offset'] = ($params['page'] - 1) * $params['rp'];
$params['rowCount'] = $params['rp'];
$params['sort'] = CRM_Utils_Array::value('sortBy', $params);
// get groups
$groups = CRM_Contact_BAO_Group::getGroupList($params);
//skip total if we are making call to show only children
if (empty($params['parent_id'])) {
// add total
$params['total'] = CRM_Contact_BAO_Group::getGroupCount($params);
// get all the groups
$allGroups = CRM_Core_PseudoConstant::allGroup();
}
// format params and add links
$groupList = array();
foreach ($groups as $id => $value) {
$group = array();
$group['group_id'] = $value['id'];
$group['count'] = $value['count'];
$group['title'] = $value['title'];
// append parent names if in search mode
if (empty($params['parent_id']) && !empty($value['parents'])) {
$group['parent_id'] = $value['parents'];
$groupIds = explode(',', $value['parents']);
$title = array();
foreach ($groupIds as $gId) {
$title[] = $allGroups[$gId];
}
$group['title'] .= '<div class="crm-row-parent-name"><em>' . ts('Child of') . '</em>: ' . implode(', ', $title) . '</div>';
$value['class'] = array_diff($value['class'], array('crm-row-parent'));
}
$group['DT_RowId'] = 'row_' . $value['id'];
if (empty($params['parentsOnly'])) {
foreach ($value['class'] as $id => $class) {
if ($class == 'crm-group-parent') {
unset($value['class'][$id]);
}
}
}
$group['DT_RowClass'] = 'crm-entity ' . implode(' ', $value['class']);
$group['DT_RowAttr'] = array();
$group['DT_RowAttr']['data-id'] = $value['id'];
$group['DT_RowAttr']['data-entity'] = 'group';
$group['description'] = CRM_Utils_Array::value('description', $value);
if (!empty($value['group_type'])) {
$group['group_type'] = $value['group_type'];
}
else {
$group['group_type'] = '';
}
$group['visibility'] = $value['visibility'];
$group['links'] = $value['action'];
$group['org_info'] = CRM_Utils_Array::value('org_info', $value);
$group['created_by'] = CRM_Utils_Array::value('created_by', $value);
$group['is_parent'] = $value['is_parent'];
array_push($groupList, $group);
}
$groupsDT = array();
$groupsDT['data'] = $groupList;
$groupsDT['recordsTotal'] = !empty($params['total']) ? $params['total'] : NULL;
$groupsDT['recordsFiltered'] = !empty($params['total']) ? $params['total'] : NULL;
return $groupsDT;
}
/**
* This function to get list of groups.
*
* @param array $params
* Associated array for params.
*
* @return array
*/
public static function getGroupList(&$params) {
$whereClause = self::whereClause($params, FALSE);
$limit = "";
if (!empty($params['rowCount']) &&
$params['rowCount'] > 0
) {
$limit = " LIMIT {$params['offset']}, {$params['rowCount']} ";
}
$orderBy = ' ORDER BY groups.title asc';
if (!empty($params['sort'])) {
$orderBy = ' ORDER BY ' . CRM_Utils_Type::escape($params['sort'], 'String');
// CRM-16905 - Sort by count cannot be done with sql
if (strpos($params['sort'], 'count') === 0) {
$orderBy = $limit = '';
}
}
$select = $from = $where = "";
$groupOrg = FALSE;
if (CRM_Core_Permission::check('administer Multiple Organizations') &&
CRM_Core_Permission::isMultisiteEnabled()
) {
$select = ", contact.display_name as org_name, contact.id as org_id";
$from = " LEFT JOIN civicrm_group_organization gOrg
ON gOrg.group_id = groups.id
LEFT JOIN civicrm_contact contact
ON contact.id = gOrg.organization_id ";
//get the Organization ID
$orgID = CRM_Utils_Request::retrieve('oid', 'Positive');
if ($orgID) {
$where = " AND gOrg.organization_id = {$orgID}";
}
$groupOrg = TRUE;
}
$query = "
SELECT groups.*, createdBy.sort_name as created_by {$select}
FROM civicrm_group groups
LEFT JOIN civicrm_contact createdBy
ON createdBy.id = groups.created_id
{$from}
WHERE $whereClause {$where}
{$orderBy}
{$limit}";
$object = CRM_Core_DAO::executeQuery($query, $params, TRUE, 'CRM_Contact_DAO_Group');
//FIXME CRM-4418, now we are handling delete separately
//if we introduce 'delete for group' make sure to handle here.
$groupPermissions = array(CRM_Core_Permission::VIEW);
if (CRM_Core_Permission::check('edit groups')) {
$groupPermissions[] = CRM_Core_Permission::EDIT;
$groupPermissions[] = CRM_Core_Permission::DELETE;
}
// CRM-9936
$reservedPermission = CRM_Core_Permission::check('administer reserved groups');
$links = self::actionLinks();
$allTypes = CRM_Core_OptionGroup::values('group_type');
$values = array();
$visibility = CRM_Core_SelectValues::ufVisibility();
while ($object->fetch()) {
$newLinks = $links;
$values[$object->id] = array(
'class' => array(),
'count' => '0',
);
CRM_Core_DAO::storeValues($object, $values[$object->id]);
if ($object->saved_search_id) {
$values[$object->id]['title'] .= ' (' . ts('Smart Group') . ')';
// check if custom search, if so fix view link
$customSearchID = CRM_Core_DAO::getFieldValue(
'CRM_Contact_DAO_SavedSearch',
$object->saved_search_id,
'search_custom_id'
);
if ($customSearchID) {
$newLinks[CRM_Core_Action::VIEW]['url'] = 'civicrm/contact/search/custom';
$newLinks[CRM_Core_Action::VIEW]['qs'] = "reset=1&force=1&ssID={$object->saved_search_id}";
}
}
$action = array_sum(array_keys($newLinks));
// CRM-9936
if (array_key_exists('is_reserved', $object)) {
//if group is reserved and I don't have reserved permission, suppress delete/edit
if ($object->is_reserved && !$reservedPermission) {
$action -= CRM_Core_Action::DELETE;
$action -= CRM_Core_Action::UPDATE;
$action -= CRM_Core_Action::DISABLE;
}
}
if (array_key_exists('is_active', $object)) {
if ($object->is_active) {
$action -= CRM_Core_Action::ENABLE;
}
else {
$values[$object->id]['class'][] = 'disabled';
$action -= CRM_Core_Action::VIEW;
$action -= CRM_Core_Action::DISABLE;
}
}
$action = $action & CRM_Core_Action::mask($groupPermissions);
$values[$object->id]['visibility'] = $visibility[$values[$object->id]['visibility']];
if (isset($values[$object->id]['group_type'])) {
$groupTypes = explode(CRM_Core_DAO::VALUE_SEPARATOR,
substr($values[$object->id]['group_type'], 1, -1)
);
$types = array();
foreach ($groupTypes as $type) {
$types[] = CRM_Utils_Array::value($type, $allTypes);
}
$values[$object->id]['group_type'] = implode(', ', $types);
}
$values[$object->id]['action'] = CRM_Core_Action::formLink($newLinks,
$action,
array(
'id' => $object->id,
'ssid' => $object->saved_search_id,
),
ts('more'),
FALSE,
'group.selector.row',
'Group',
$object->id
);
// If group has children, add class for link to view children
$values[$object->id]['is_parent'] = FALSE;
if (array_key_exists('children', $values[$object->id])) {
$values[$object->id]['class'][] = "crm-group-parent";
$values[$object->id]['is_parent'] = TRUE;
}
// If group is a child, add child class
if (array_key_exists('parents', $values[$object->id])) {
$values[$object->id]['class'][] = "crm-group-child";
}
if ($groupOrg) {
if ($object->org_id) {
$contactUrl = CRM_Utils_System::url('civicrm/contact/view', "reset=1&cid={$object->org_id}");
$values[$object->id]['org_info'] = "<a href='{$contactUrl}'>{$object->org_name}</a>";
}
else {
$values[$object->id]['org_info'] = ''; // Empty cell
}
}
else {
$values[$object->id]['org_info'] = NULL; // Collapsed column if all cells are NULL
}
if ($object->created_id) {
$contactUrl = CRM_Utils_System::url('civicrm/contact/view', "reset=1&cid={$object->created_id}");
$values[$object->id]['created_by'] = "<a href='{$contactUrl}'>{$object->created_by}</a>";
}
// By default, we try to get a count of the contacts in each group
// to display to the user on the Manage Group page. However, if
// that will result in the cache being regenerated, then dipslay
// "unknown" instead to avoid a long wait for the user.
if (CRM_Contact_BAO_GroupContactCache::shouldGroupBeRefreshed($object->id)) {
$values[$object->id]['count'] = ts('unknown');
}
else {
$values[$object->id]['count'] = civicrm_api3('Contact', 'getcount', array('group' => $object->id));
}
}
// CRM-16905 - Sort by count cannot be done with sql
if (!empty($params['sort']) && strpos($params['sort'], 'count') === 0) {
usort($values, function($a, $b) {
return $a['count'] - $b['count'];
});
if (strpos($params['sort'], 'desc')) {
$values = array_reverse($values, TRUE);
}
return array_slice($values, $params['offset'], $params['rowCount']);
}
return $values;
}
/**
* This function to get hierarchical list of groups (parent followed by children)
*
* @param array $groupIDs
* Array of group ids.
*
* @param NULL $parents
* @param string $spacer
* @param bool $titleOnly
*
* @return array
*/
public static function getGroupsHierarchy(
$groupIDs,
$parents = NULL,
$spacer = '<span class="child-indent"></span>',
$titleOnly = FALSE
) {
if (empty($groupIDs)) {
return array();
}
$groupIdString = '(' . implode(',', array_keys($groupIDs)) . ')';
// <span class="child-icon"></span>
// need to return id, title (w/ spacer), description, visibility
// We need to build a list of tags ordered by hierarchy and sorted by
// name. The hierarchy will be communicated by an accumulation of
// separators in front of the name to give it a visual offset.
// Instead of recursively making mysql queries, we'll make one big
// query and build the hierarchy with the algorithm below.
$groups = array();
$args = array(1 => array($groupIdString, 'String'));
$query = "
SELECT id, title, description, visibility, parents
FROM civicrm_group
WHERE id IN $groupIdString
";
if ($parents) {
// group can have > 1 parent so parents may be comma separated list (eg. '1,2,5').
$parentArray = explode(',', $parents);
$parent = self::filterActiveGroups($parentArray);
$args[2] = array($parent, 'Integer');
$query .= " AND SUBSTRING_INDEX(parents, ',', 1) = %2";
}
$query .= " ORDER BY title";
$dao = CRM_Core_DAO::executeQuery($query, $args);
// Sort the groups into the correct storage by the parent
// $roots represent the current leaf nodes that need to be checked for
// children. $rows represent the unplaced nodes
// $tree contains the child nodes based on their parent_id.
$roots = array();
$tree = array();
while ($dao->fetch()) {
if ($dao->parents) {
$parentArray = explode(',', $dao->parents);
$parent = self::filterActiveGroups($parentArray);
$tree[$parent][] = array(
'id' => $dao->id,
'title' => $dao->title,
'visibility' => $dao->visibility,
'description' => $dao->description,
);
}
else {
$roots[] = array(
'id' => $dao->id,
'title' => $dao->title,
'visibility' => $dao->visibility,
'description' => $dao->description,
);
}
}
$dao->free();
$hierarchy = array();
for ($i = 0; $i < count($roots); $i++) {
self::buildGroupHierarchy($hierarchy, $roots[$i], $tree, $titleOnly, $spacer, 0);
}
return $hierarchy;
}
/**
* Build a list with groups on alphabetical order and child groups after the parent group.
*
* This is a recursive function filling the $hierarchy parameter.
*
* @param $hierarchy
* @param $group
* @param $tree
* @param $titleOnly
* @param $spacer
* @param $level
*/
private static function buildGroupHierarchy(&$hierarchy, $group, $tree, $titleOnly, $spacer, $level) {
$spaces = str_repeat($spacer, $level);
if ($titleOnly) {
$hierarchy[$group['id']] = $spaces . $group['title'];
}
else {
$hierarchy[$group['id']] = array(
'title' => $spaces . $group['title'],
'description' => $group['description'],
'visibility' => $group['visibility'],
);
}
// For performance reasons we use a for loop rather than a foreach.
// Metrics for performance in an installation with 2867 groups a foreach
// caused the function getGroupsHierarchy with a foreach execution takes
// around 2.2 seoonds (2,200 ms).
// Changing to a for loop execustion takes around 0.02 seconds (20 ms).
if (isset($tree[$group['id']]) && is_array($tree[$group['id']])) {
for ($i = 0; $i < count($tree[$group['id']]); $i++) {
self::buildGroupHierarchy($hierarchy, $tree[$group['id']][$i], $tree, $titleOnly, $spacer, $level + 1);
}
}
}
/**
* @param array $params
*
* @return NULL|string
*/
public static function getGroupCount(&$params) {
$whereClause = self::whereClause($params, FALSE);
$query = "SELECT COUNT(*) FROM civicrm_group groups";
if (!empty($params['created_by'])) {
$query .= "
INNER JOIN civicrm_contact createdBy
ON createdBy.id = groups.created_id";
}
$query .= "
WHERE {$whereClause}";
return CRM_Core_DAO::singleValueQuery($query, $params);
}
/**
* Generate permissioned where clause for group search.
* @param array $params
* @param bool $sortBy
* @param bool $excludeHidden
*
* @return string
*/
public static function whereClause(&$params, $sortBy = TRUE, $excludeHidden = TRUE) {
$values = array();
$title = CRM_Utils_Array::value('title', $params);
if ($title) {
$clauses[] = "groups.title LIKE %1";
if (strpos($title, '%') !== FALSE) {
$params[1] = array($title, 'String', FALSE);
}
else {
$params[1] = array($title, 'String', TRUE);
}
}
$groupType = CRM_Utils_Array::value('group_type', $params);
if ($groupType) {
$types = explode(',', $groupType);
if (!empty($types)) {
$clauses[] = 'groups.group_type LIKE %2';
$typeString = CRM_Core_DAO::VALUE_SEPARATOR . implode(CRM_Core_DAO::VALUE_SEPARATOR, $types) . CRM_Core_DAO::VALUE_SEPARATOR;
$params[2] = array($typeString, 'String', TRUE);
}
}
$visibility = CRM_Utils_Array::value('visibility', $params);
if ($visibility) {
$clauses[] = 'groups.visibility = %3';
$params[3] = array($visibility, 'String');
}
$groupStatus = CRM_Utils_Array::value('status', $params);
if ($groupStatus) {
switch ($groupStatus) {
case 1:
$clauses[] = 'groups.is_active = 1';
$params[4] = array($groupStatus, 'Integer');
break;
case 2:
$clauses[] = 'groups.is_active = 0';
$params[4] = array($groupStatus, 'Integer');
break;
case 3:
$clauses[] = '(groups.is_active = 0 OR groups.is_active = 1 )';
break;
}
}
$parentsOnly = CRM_Utils_Array::value('parentsOnly', $params);
if ($parentsOnly) {
$clauses[] = 'groups.parents IS NULL';
}
// only show child groups of a specific parent group
$parent_id = CRM_Utils_Array::value('parent_id', $params);
if ($parent_id) {
$clauses[] = 'groups.id IN (SELECT child_group_id FROM civicrm_group_nesting WHERE parent_group_id = %5)';
$params[5] = array($parent_id, 'Integer');
}
if ($createdBy = CRM_Utils_Array::value('created_by', $params)) {
$clauses[] = "createdBy.sort_name LIKE %6";
if (strpos($createdBy, '%') !== FALSE) {
$params[6] = array($createdBy, 'String', FALSE);
}
else {
$params[6] = array($createdBy, 'String', TRUE);
}
}
if (empty($clauses)) {
$clauses[] = 'groups.is_active = 1';
}
if ($excludeHidden) {
$clauses[] = 'groups.is_hidden = 0';
}
$clauses[] = self::getPermissionClause();
return implode(' AND ', $clauses);
}
/**
* Define action links.
*
* @return array
* array of action links
*/
public static function actionLinks() {
$links = array(
CRM_Core_Action::VIEW => array(
'name' => ts('Contacts'),
'url' => 'civicrm/group/search',
'qs' => 'reset=1&force=1&context=smog&gid=%%id%%',
'title' => ts('Group Contacts'),
),
CRM_Core_Action::UPDATE => array(
'name' => ts('Settings'),
'url' => 'civicrm/group',
'qs' => 'reset=1&action=update&id=%%id%%',
'title' => ts('Edit Group'),
),
CRM_Core_Action::DISABLE => array(
'name' => ts('Disable'),
'ref' => 'crm-enable-disable',
'title' => ts('Disable Group'),
),
CRM_Core_Action::ENABLE => array(
'name' => ts('Enable'),
'ref' => 'crm-enable-disable',
'title' => ts('Enable Group'),
),
CRM_Core_Action::DELETE => array(
'name' => ts('Delete'),
'url' => 'civicrm/group',
'qs' => 'reset=1&action=delete&id=%%id%%',
'title' => ts('Delete Group'),
),
);
return $links;
}
/**
* @param $whereClause
* @param array $whereParams
*
* @return string
*/
public function pagerAtoZ($whereClause, $whereParams) {
$query = "
SELECT DISTINCT UPPER(LEFT(groups.title, 1)) as sort_name
FROM civicrm_group groups
WHERE $whereClause
ORDER BY LEFT(groups.title, 1)
";
$dao = CRM_Core_DAO::executeQuery($query, $whereParams);
return CRM_Utils_PagerAToZ::getAToZBar($dao, $this->_sortByCharacter, TRUE);
}
/**
* Assign Test Value.
*
* @param string $fieldName
* @param array $fieldDef
* @param int $counter
*/
protected function assignTestValue($fieldName, &$fieldDef, $counter) {
if ($fieldName == 'children' || $fieldName == 'parents') {
$this->{$fieldName} = "NULL";
}
else {
parent::assignTestValues($fieldName, $fieldDef, $counter);
}
}
/**
* Get child group ids
*
* @param array $regularGroupIDs
* Parent Group IDs
*
* @return array
*/
public static function getChildGroupIds($regularGroupIDs) {
$childGroupIDs = array();
foreach ($regularGroupIDs as $regularGroupID) {
// temporary store the child group ID(s) of regular group identified by $id,
// later merge with main child group array
$tempChildGroupIDs = array();
// check that the regular group has any child group, if not then continue
if ($childrenFound = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $regularGroupID, 'children')) {
$tempChildGroupIDs[] = $childrenFound;
}
else {
continue;
}
// as civicrm_group.children stores multiple group IDs in comma imploded string format,
// so we need to convert it into array of child group IDs first
$tempChildGroupIDs = explode(',', implode(',', $tempChildGroupIDs));
$childGroupIDs = array_merge($childGroupIDs, $tempChildGroupIDs);
// recursively fetch the child group IDs
while (count($tempChildGroupIDs)) {
$tempChildGroupIDs = self::getChildGroupIds($tempChildGroupIDs);
if (count($tempChildGroupIDs)) {
$childGroupIDs = array_merge($childGroupIDs, $tempChildGroupIDs);
}
}
}
return $childGroupIDs;
}
/**
* Check parent groups and filter out the disabled ones.
*
* @param array $parentArray
* Array of group Ids.
*
* @return int
*/
public static function filterActiveGroups($parentArray) {
if (count($parentArray) > 1) {
$result = civicrm_api3('Group', 'get', array(
'id' => array('IN' => $parentArray),
'is_active' => TRUE,
'return' => 'id',
));
$activeParentGroupIDs = CRM_Utils_Array::collect('id', $result['values']);
foreach ($parentArray as $key => $groupID) {
if (!array_key_exists($groupID, $activeParentGroupIDs)) {
unset($parentArray[$key]);
}
}
}
return reset($parentArray);
}
}
Reference in a new issue Copy permalink