3 +--------------------------------------------------------------------+
4 | CiviCRM version 4.7 |
5 +--------------------------------------------------------------------+
6 | Copyright CiviCRM LLC (c) 2004-2015 |
7 +--------------------------------------------------------------------+
8 | This file is a part of CiviCRM. |
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. |
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. |
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 +--------------------------------------------------------------------+
31 * @copyright CiviCRM LLC (c) 2004-2015
33 class CRM_Contact_BAO_GroupContactCache
extends CRM_Contact_DAO_GroupContactCache
{
35 static $_alreadyLoaded = array();
38 * Check to see if we have cache entries for this group.
40 * If not, regenerate, else return.
43 * Of group that we are checking against.
46 * TRUE if we did not regenerate, FALSE if we did
48 public static function check($groupIDs) {
49 if (empty($groupIDs)) {
53 return self
::loadAll($groupIDs);
57 * Common function that formulates the query to see which groups needs to be refreshed
58 * based on their cache date and the smartGroupCacheTimeOut
60 * @param string $groupIDClause
61 * The clause which limits which groups we need to evaluate.
62 * @param bool $includeHiddenGroups
63 * Hidden groups are excluded by default.
66 * the sql query which lists the groups that need to be refreshed
68 public static function groupRefreshedClause($groupIDClause = NULL, $includeHiddenGroups = FALSE) {
69 $smartGroupCacheTimeout = self
::smartGroupCacheTimeout();
70 $now = CRM_Utils_Date
::getUTCTime();
75 WHERE ( g.saved_search_id IS NOT NULL OR g.children IS NOT NULL )
77 AND ( g.cache_date IS NULL OR
78 ( TIMESTAMPDIFF(MINUTE, g.cache_date, $now) >= $smartGroupCacheTimeout ) OR
79 ( $now >= g.refresh_date )
83 if (!$includeHiddenGroups) {
84 $query .= "AND (g.is_hidden = 0 OR g.is_hidden IS NULL)";
87 if (!empty($groupIDClause)) {
88 $query .= " AND ( $groupIDClause ) ";
95 * Checks to see if a group has been refreshed recently. This is primarily used
96 * in a locking scenario when some other process might have refreshed things underneath
101 * @param bool $includeHiddenGroups
102 * Hidden groups are excluded by default.
105 * the sql query which lists the groups that need to be refreshed
107 public static function shouldGroupBeRefreshed($groupID, $includeHiddenGroups = FALSE) {
108 $query = self
::groupRefreshedClause("g.id = %1", $includeHiddenGroups);
109 $params = array(1 => array($groupID, 'Integer'));
111 // if the query returns the group ID, it means the group is a valid candidate for refreshing
112 return CRM_Core_DAO
::singleValueQuery($query, $params);
116 * Check to see if we have cache entries for this group
117 * if not, regenerate, else return
119 * @param int /array $groupIDs groupIDs of group that we are checking against
120 * if empty, all groups are checked
122 * Limits the number of groups we evaluate.
125 * TRUE if we did not regenerate, FALSE if we did
127 public static function loadAll($groupIDs = NULL, $limit = 0) {
128 // ensure that all the smart groups are loaded
129 // this function is expensive and should be sparingly used if groupIDs is empty
130 if (empty($groupIDs)) {
131 $groupIDClause = NULL;
135 if (!is_array($groupIDs)) {
136 $groupIDs = array($groupIDs);
139 // note escapeString is a must here and we can't send the imploded value as second argument to
140 // the executeQuery(), since that would put single quote around the string and such a string
141 // of comma separated integers would not work.
142 $groupIDString = CRM_Core_DAO
::escapeString(implode(', ', $groupIDs));
144 $groupIDClause = "g.id IN ({$groupIDString})";
147 $query = self
::groupRefreshedClause($groupIDClause);
149 $limitClause = $orderClause = NULL;
151 $limitClause = " LIMIT 0, $limit";
152 $orderClause = " ORDER BY g.cache_date, g.refresh_date";
154 // We ignore hidden groups and disabled groups
160 $dao = CRM_Core_DAO
::executeQuery($query);
161 $processGroupIDs = array();
162 $refreshGroupIDs = $groupIDs;
163 while ($dao->fetch()) {
164 $processGroupIDs[] = $dao->id
;
166 // remove this id from refreshGroupIDs
167 foreach ($refreshGroupIDs as $idx => $gid) {
168 if ($gid == $dao->id
) {
169 unset($refreshGroupIDs[$idx]);
175 if (!empty($refreshGroupIDs)) {
176 $refreshGroupIDString = CRM_Core_DAO
::escapeString(implode(', ', $refreshGroupIDs));
177 $time = CRM_Utils_Date
::getUTCTime(self
::smartGroupCacheTimeout() * 60);
179 UPDATE civicrm_group g
180 SET g.refresh_date = $time
181 WHERE g.id IN ( {$refreshGroupIDString} )
182 AND g.refresh_date IS NULL
184 CRM_Core_DAO
::executeQuery($query);
187 if (empty($processGroupIDs)) {
191 self
::add($processGroupIDs);
197 * FIXME: This function should not be needed, because the cache table should not be getting truncated
199 public static function fillIfEmpty() {
200 if (!CRM_Core_DAO
::singleValueQuery("SELECT COUNT(id) FROM civicrm_group_contact_cache")) {
206 * @param int $groupID
208 public static function add($groupID) {
209 // first delete the current cache
210 self
::remove($groupID);
211 if (!is_array($groupID)) {
212 $groupID = array($groupID);
215 $returnProperties = array('contact_id');
216 foreach ($groupID as $gid) {
217 $params = array(array('group', 'IN', array($gid), 0, 0));
218 // the below call updates the cache table as a byproduct of the query
219 CRM_Contact_BAO_Query
::apiQuery($params, $returnProperties, NULL, NULL, 0, 0, FALSE);
224 * @param int $groupID
227 public static function store(&$groupID, &$values) {
230 // sort the values so we put group IDs in front and hence optimize
231 // mysql storage (or so we think) CRM-9493
234 // to avoid long strings, lets do BULK_INSERT_COUNT values at a time
235 while (!empty($values)) {
237 $input = array_splice($values, 0, CRM_Core_DAO
::BULK_INSERT_COUNT
);
238 $str = implode(',', $input);
239 $sql = "INSERT IGNORE INTO civicrm_group_contact_cache (group_id,contact_id) VALUES $str;";
240 CRM_Core_DAO
::executeQuery($sql);
242 self
::updateCacheTime($groupID, $processed);
246 * Change the cache_date.
248 * @param array $groupID
249 * @param bool $processed
250 * Whether the cache data was recently modified.
252 public static function updateCacheTime($groupID, $processed) {
253 // only update cache entry if we had any values
255 // also update the group with cache date information
256 //make sure to give original timezone settings again.
257 $now = CRM_Utils_Date
::getUTCTime();
265 $groupIDs = implode(',', $groupID);
268 SET cache_date = $now, refresh_date = $refresh
269 WHERE id IN ( $groupIDs )
271 CRM_Core_DAO
::executeQuery($sql);
275 * Removes all the cache entries pertaining to a specific group.
276 * If no groupID is passed in, removes cache entries for all groups
277 * Has an optimization to bypass repeated invocations of this function.
278 * Note that this function is an advisory, i.e. the removal respects the
279 * cache date, i.e. the removal is not done if the group was recently
280 * loaded into the cache.
282 * @param int $groupID
283 * the groupID to delete cache entries, NULL for all groups.
284 * @param bool $onceOnly
285 * run the function exactly once for all groups.
287 public static function remove($groupID = NULL, $onceOnly = TRUE) {
288 static $invoked = FALSE;
290 // typically this needs to happy only once per instance
291 // this is especially TRUE in import, where we dont need
292 // to do this all the time
293 // this optimization is done only when no groupID is passed
294 // i.e. cache is reset for all groups
303 if ($groupID == NULL) {
306 elseif (is_array($groupID)) {
307 foreach ($groupID as $gid) {
308 unset(self
::$_alreadyLoaded[$gid]);
311 elseif ($groupID && array_key_exists($groupID, self
::$_alreadyLoaded)) {
312 unset(self
::$_alreadyLoaded[$groupID]);
317 $smartGroupCacheTimeout = self
::smartGroupCacheTimeout();
319 $now = CRM_Utils_Date
::getUTCTime();
320 $refreshTime = CRM_Utils_Date
::getUTCTime($smartGroupCacheTimeout * 60);
322 if (!isset($groupID)) {
323 if ($smartGroupCacheTimeout == 0) {
325 TRUNCATE civicrm_group_contact_cache
328 UPDATE civicrm_group g
329 SET cache_date = null,
337 FROM civicrm_group_contact_cache gc
338 INNER JOIN civicrm_group g ON g.id = gc.group_id
339 WHERE g.cache_date <= %1
342 UPDATE civicrm_group g
343 SET cache_date = null,
345 WHERE g.cache_date <= %1
348 UPDATE civicrm_group g
349 SET refresh_date = $refreshTime
350 WHERE g.cache_date > %1
351 AND refresh_date IS NULL
353 $cacheTime = date('Y-m-d H-i-s', strtotime("- $smartGroupCacheTimeout minutes"));
354 $params = array(1 => array($cacheTime, 'String'));
357 elseif (is_array($groupID)) {
358 $groupIDs = implode(', ', $groupID);
361 FROM civicrm_group_contact_cache g
362 WHERE g.group_id IN ( $groupIDs )
365 UPDATE civicrm_group g
366 SET cache_date = null,
368 WHERE id IN ( $groupIDs )
374 FROM civicrm_group_contact_cache g
375 WHERE g.group_id = %1
378 UPDATE civicrm_group g
379 SET cache_date = null,
383 $params = array(1 => array($groupID, 'Integer'));
386 CRM_Core_DAO
::executeQuery($query, $params);
389 CRM_Core_DAO
::executeQuery($refresh, $params);
392 // also update the cache_date for these groups
393 CRM_Core_DAO
::executeQuery($update, $params);
397 * Removes one or more contacts from the smart group cache.
398 * @param int|array $cid
399 * @param int $groupId
401 * TRUE if successful.
403 public static function removeContact($cid, $groupId = NULL) {
406 foreach ((array) $cid as $c) {
407 $cids[] = CRM_Utils_Type
::escape($c, 'Integer');
410 $condition = count($cids) == 1 ?
"= {$cids[0]}" : "IN (" . implode(',', $cids) . ")";
412 $condition .= " AND group_id = " . CRM_Utils_Type
::escape($groupId, 'Integer');
414 $sql = "DELETE FROM civicrm_group_contact_cache WHERE contact_id $condition";
415 CRM_Core_DAO
::executeQuery($sql);
422 * Load the smart group cache for a saved search.
424 * @param object $group
425 * The smart group that needs to be loaded.
427 * Should we force a search through.
429 public static function load(&$group, $force = FALSE) {
430 $groupID = $group->id
;
431 $savedSearchID = $group->saved_search_id
;
432 if (array_key_exists($groupID, self
::$_alreadyLoaded) && !$force) {
436 // grab a lock so other processes dont compete and do the same query
437 $lock = Civi
::lockManager()->acquire("data.core.group.{$groupID}");
438 if (!$lock->isAcquired()) {
439 // this can cause inconsistent results since we dont know if the other process
440 // will fill up the cache before our calling routine needs it.
441 // however this routine does not return the status either, so basically
442 // its a "lets return and hope for the best"
446 self
::$_alreadyLoaded[$groupID] = 1;
448 // we now have the lock, but some other process could have actually done the work
449 // before we got here, so before we do any work, lets ensure that work needs to be
451 // we allow hidden groups here since we dont know if the caller wants to evaluate an
453 if (!$force && !self
::shouldGroupBeRefreshed($groupID, TRUE)) {
461 if ($savedSearchID) {
462 $ssParams = CRM_Contact_BAO_SavedSearch
::getSearchParams($savedSearchID);
464 // rectify params to what proximity search expects if there is a value for prox_distance
466 if (!empty($ssParams)) {
467 CRM_Contact_BAO_ProximityQuery
::fixInputParams($ssParams);
470 $returnProperties = array();
471 if (CRM_Core_DAO
::getFieldValue('CRM_Contact_DAO_SavedSearch', $savedSearchID, 'mapping_id')) {
472 $fv = CRM_Contact_BAO_SavedSearch
::getFormValues($savedSearchID);
473 $returnProperties = CRM_Core_BAO_Mapping
::returnProperties($fv);
476 if (isset($ssParams['customSearchID'])) {
479 // we split it up and store custom class
480 // so temp tables are not destroyed if they are used
481 // hence customClass is defined above at top of function
482 $customClass = CRM_Contact_BAO_SearchCustom
::customClass($ssParams['customSearchID'], $savedSearchID);
483 $searchSQL = $customClass->contactIDs();
484 $searchSQL = str_replace('ORDER BY contact_a.id ASC', '', $searchSQL);
485 if (!strstr($searchSQL, 'WHERE')) {
486 $searchSQL .= " WHERE ( 1 ) ";
488 $idName = 'contact_id';
491 $formValues = CRM_Contact_BAO_SavedSearch
::getFormValues($savedSearchID);
492 // CRM-17075 using the formValues in this way imposes extra logic and complexity.
493 // we have the where_clause and where tables stored in the saved_search table
494 // and should use these rather than re-processing the form criteria (which over-works
495 // the link between the form layer & the query layer too).
496 // It's hard to think of when you would want to use anything other than return
497 // properties = array('contact_id' => 1) here as the point would appear to be to
498 // generate the list of contact ids in the group.
499 // @todo review this to use values in saved_search table (preferably for 4.8).
501 = new CRM_Contact_BAO_Query(
502 $ssParams, $returnProperties, NULL,
506 CRM_Utils_Array
::value('display_relationship_type', $formValues),
507 CRM_Utils_Array
::value('operator', $formValues, 'AND')
509 $query->_useDistinct
= FALSE;
510 $query->_useGroupBy
= FALSE;
512 = $query->searchQuery(
521 $groupID = CRM_Utils_Type
::escape($groupID, 'Integer');
522 $sql = $searchSQL . " AND contact_a.id NOT IN (
523 SELECT contact_id FROM civicrm_group_contact
524 WHERE civicrm_group_contact.status = 'Removed'
525 AND civicrm_group_contact.group_id = $groupID ) ";
529 $sql = preg_replace("/^\s*SELECT/", "SELECT $groupID as group_id, ", $sql);
532 // lets also store the records that are explicitly added to the group
533 // this allows us to skip the group contact LEFT JOIN
535 SELECT $groupID as group_id, contact_id as $idName
536 FROM civicrm_group_contact
537 WHERE civicrm_group_contact.status = 'Added'
538 AND civicrm_group_contact.group_id = $groupID ";
540 $groupIDs = array($groupID);
541 self
::remove($groupIDs);
543 $tempTable = 'civicrm_temp_group_contact_cache' . rand(0, 2000);
544 foreach (array($sql, $sqlB) as $selectSql) {
548 $insertSql = "CREATE TEMPORARY TABLE $tempTable ($selectSql);";
550 $result = CRM_Core_DAO
::executeQuery($insertSql);
551 CRM_Core_DAO
::executeQuery(
552 "INSERT IGNORE INTO civicrm_group_contact_cache (contact_id, group_id)
553 SELECT DISTINCT $idName, group_id FROM $tempTable
555 CRM_Core_DAO
::executeQuery(" DROP TEMPORARY TABLE $tempTable");
558 self
::updateCacheTime($groupIDs, $processed);
560 if ($group->children
) {
562 //Store a list of contacts who are removed from the parent group
565 FROM civicrm_group_contact
566 WHERE civicrm_group_contact.status = 'Removed'
567 AND civicrm_group_contact.group_id = $groupID ";
568 $dao = CRM_Core_DAO
::executeQuery($sql);
569 $removed_contacts = array();
570 while ($dao->fetch()) {
571 $removed_contacts[] = $dao->contact_id
;
574 $childrenIDs = explode(',', $group->children
);
575 foreach ($childrenIDs as $childID) {
576 $contactIDs = CRM_Contact_BAO_Group
::getMember($childID, FALSE);
577 //Unset each contact that is removed from the parent group
578 foreach ($removed_contacts as $removed_contact) {
579 unset($contactIDs[$removed_contact]);
582 foreach ($contactIDs as $contactID => $dontCare) {
583 $values[] = "({$groupID},{$contactID})";
586 self
::store($groupIDs, $values);
596 public static function smartGroupCacheTimeout() {
597 $config = CRM_Core_Config
::singleton();
600 isset($config->smartGroupCacheTimeout
) &&
601 is_numeric($config->smartGroupCacheTimeout
)
603 return $config->smartGroupCacheTimeout
;
606 // lets have a min cache time of 5 mins if not set
611 * Get all the smart groups that this contact belongs to.
612 * Note that this could potentially be a super slow function since
613 * it ensure that all contact groups are loaded in the cache
615 * @param int $contactID
616 * @param bool $showHidden
617 * Hidden groups are shown only if this flag is set.
620 * an array of groups that this contact belongs to
622 public static function contactGroup($contactID, $showHidden = FALSE) {
623 if (empty($contactID)) {
627 if (is_array($contactID)) {
628 $contactIDs = $contactID;
631 $contactIDs = array($contactID);
638 $hiddenClause = ' AND (g.is_hidden = 0 OR g.is_hidden IS NULL) ';
641 $contactIDString = CRM_Core_DAO
::escapeString(implode(', ', $contactIDs));
643 SELECT gc.group_id, gc.contact_id, g.title, g.children, g.description
644 FROM civicrm_group_contact_cache gc
645 INNER JOIN civicrm_group g ON g.id = gc.group_id
646 WHERE gc.contact_id IN ($contactIDString)
648 ORDER BY gc.contact_id, g.children
651 $dao = CRM_Core_DAO
::executeQuery($sql);
652 $contactGroup = array();
653 $prevContactID = NULL;
654 while ($dao->fetch()) {
657 $prevContactID != $dao->contact_id
659 $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
661 $prevContactID = $dao->contact_id
;
662 if (!array_key_exists($dao->contact_id
, $contactGroup)) {
663 $contactGroup[$dao->contact_id
]
664 = array('group' => array(), 'groupTitle' => array());
667 $contactGroup[$dao->contact_id
]['group'][]
669 'id' => $dao->group_id
,
670 'title' => $dao->title
,
671 'description' => $dao->description
,
672 'children' => $dao->children
,
674 $contactGroup[$dao->contact_id
]['groupTitle'][] = $dao->title
;
677 if ($prevContactID) {
678 $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
681 if ((!empty($contactGroup[$contactID]) && is_numeric($contactID))) {
682 return $contactGroup[$contactID];
685 return $contactGroup;