CRM/Contact/BAO/GroupContactCache.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   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  */
  33 class CRM_Contact_BAO_GroupContactCache extends CRM_Contact_DAO_GroupContactCache {
  34
  35   static $_alreadyLoaded = array();
  36
  37   /**
  38    * Check to see if we have cache entries for this group.
  39    *
  40    * If not, regenerate, else return.
  41    *
  42    * @param $groupIDs
  43    *   Of group that we are checking against.
  44    *
  45    * @return bool
  46    *   TRUE if we did not regenerate, FALSE if we did
  47    */
  48   public static function check($groupIDs) {
  49     if (empty($groupIDs)) {
  50       return TRUE;
  51     }
  52
  53     return self::loadAll($groupIDs);
  54   }
  55
  56   /**
  57    * Common function that formulates the query to see which groups needs to be refreshed
  58    * based on their cache date and the smartGroupCacheTimeOut
  59    *
  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.
  64    *
  65    * @return string
  66    *   the sql query which lists the groups that need to be refreshed
  67    */
  68   public static function groupRefreshedClause($groupIDClause = NULL, $includeHiddenGroups = FALSE) {
  69     $smartGroupCacheTimeout = self::smartGroupCacheTimeout();
  70     $now = CRM_Utils_Date::getUTCTime();
  71
  72     $query = "
  73 SELECT  g.id
  74 FROM    civicrm_group g
  75 WHERE   ( g.saved_search_id IS NOT NULL OR g.children IS NOT NULL )
  76 AND     g.is_active = 1
  77 AND     ( g.cache_date IS NULL OR
  78           ( TIMESTAMPDIFF(MINUTE, g.cache_date, $now) >= $smartGroupCacheTimeout ) OR
  79           ( $now >= g.refresh_date )
  80         )
  81 ";
  82
  83     if (!$includeHiddenGroups) {
  84       $query .= "AND (g.is_hidden = 0 OR g.is_hidden IS NULL)";
  85     }
  86
  87     if (!empty($groupIDClause)) {
  88       $query .= " AND ( $groupIDClause ) ";
  89     }
  90
  91     return $query;
  92   }
  93
  94   /**
  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
  97    * this process
  98    *
  99    * @param int $groupID
 100    *   The group ID.
 101    * @param bool $includeHiddenGroups
 102    *   Hidden groups are excluded by default.
 103    *
 104    * @return string
 105    *   the sql query which lists the groups that need to be refreshed
 106    */
 107   public static function shouldGroupBeRefreshed($groupID, $includeHiddenGroups = FALSE) {
 108     $query = self::groupRefreshedClause("g.id = %1", $includeHiddenGroups);
 109     $params = array(1 => array($groupID, 'Integer'));
 110
 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);
 113   }
 114
 115   /**
 116    * Check to see if we have cache entries for this group
 117    * if not, regenerate, else return
 118    *
 119    * @param int /array $groupIDs groupIDs of group that we are checking against
 120    *                           if empty, all groups are checked
 121    * @param int $limit
 122    *   Limits the number of groups we evaluate.
 123    *
 124    * @return bool
 125    *   TRUE if we did not regenerate, FALSE if we did
 126    */
 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;
 132       $groupIDs = array();
 133     }
 134     else {
 135       if (!is_array($groupIDs)) {
 136         $groupIDs = array($groupIDs);
 137       }
 138
 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));
 143
 144       $groupIDClause = "g.id IN ({$groupIDString})";
 145     }
 146
 147     $query = self::groupRefreshedClause($groupIDClause);
 148
 149     $limitClause = $orderClause = NULL;
 150     if ($limit > 0) {
 151       $limitClause = " LIMIT 0, $limit";
 152       $orderClause = " ORDER BY g.cache_date, g.refresh_date";
 153     }
 154     // We ignore hidden groups and disabled groups
 155     $query .= "
 156         $orderClause
 157         $limitClause
 158 ";
 159
 160     $dao = CRM_Core_DAO::executeQuery($query);
 161     $processGroupIDs = array();
 162     $refreshGroupIDs = $groupIDs;
 163     while ($dao->fetch()) {
 164       $processGroupIDs[] = $dao->id;
 165
 166       // remove this id from refreshGroupIDs
 167       foreach ($refreshGroupIDs as $idx => $gid) {
 168         if ($gid == $dao->id) {
 169           unset($refreshGroupIDs[$idx]);
 170           break;
 171         }
 172       }
 173     }
 174
 175     if (!empty($refreshGroupIDs)) {
 176       $refreshGroupIDString = CRM_Core_DAO::escapeString(implode(', ', $refreshGroupIDs));
 177       $time = CRM_Utils_Date::getUTCTime(self::smartGroupCacheTimeout() * 60);
 178       $query = "
 179 UPDATE civicrm_group g
 180 SET    g.refresh_date = $time
 181 WHERE  g.id IN ( {$refreshGroupIDString} )
 182 AND    g.refresh_date IS NULL
 183 ";
 184       CRM_Core_DAO::executeQuery($query);
 185     }
 186
 187     if (empty($processGroupIDs)) {
 188       return TRUE;
 189     }
 190     else {
 191       self::add($processGroupIDs);
 192       return FALSE;
 193     }
 194   }
 195
 196   /**
 197    * FIXME: This function should not be needed, because the cache table should not be getting truncated
 198    */
 199   public static function fillIfEmpty() {
 200     if (!CRM_Core_DAO::singleValueQuery("SELECT COUNT(id) FROM civicrm_group_contact_cache")) {
 201       self::loadAll();
 202     }
 203   }
 204
 205   /**
 206    * @param int $groupID
 207    */
 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);
 213     }
 214
 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);
 220     }
 221   }
 222
 223   /**
 224    * @param int $groupID
 225    * @param $values
 226    */
 227   public static function store(&$groupID, &$values) {
 228     $processed = FALSE;
 229
 230     // sort the values so we put group IDs in front and hence optimize
 231     // mysql storage (or so we think) CRM-9493
 232     sort($values);
 233
 234     // to avoid long strings, lets do BULK_INSERT_COUNT values at a time
 235     while (!empty($values)) {
 236       $processed = TRUE;
 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);
 241     }
 242     self::updateCacheTime($groupID, $processed);
 243   }
 244
 245   /**
 246    * Change the cache_date.
 247    *
 248    * @param array $groupID
 249    * @param bool $processed
 250    *   Whether the cache data was recently modified.
 251    */
 252   public static function updateCacheTime($groupID, $processed) {
 253     // only update cache entry if we had any values
 254     if ($processed) {
 255       // also update the group with cache date information
 256       //make sure to give original timezone settings again.
 257       $now = CRM_Utils_Date::getUTCTime();
 258       $refresh = 'null';
 259     }
 260     else {
 261       $now = 'null';
 262       $refresh = 'null';
 263     }
 264
 265     $groupIDs = implode(',', $groupID);
 266     $sql = "
 267 UPDATE civicrm_group
 268 SET    cache_date = $now, refresh_date = $refresh
 269 WHERE  id IN ( $groupIDs )
 270 ";
 271     CRM_Core_DAO::executeQuery($sql);
 272   }
 273
 274   /**
 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.
 281    *
 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.
 286    */
 287   public static function remove($groupID = NULL, $onceOnly = TRUE) {
 288     static $invoked = FALSE;
 289
 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
 295     if (
 296       $onceOnly &&
 297       $invoked &&
 298       $groupID == NULL
 299     ) {
 300       return;
 301     }
 302
 303     if ($groupID == NULL) {
 304       $invoked = TRUE;
 305     }
 306     elseif (is_array($groupID)) {
 307       foreach ($groupID as $gid) {
 308         unset(self::$_alreadyLoaded[$gid]);
 309       }
 310     }
 311     elseif ($groupID && array_key_exists($groupID, self::$_alreadyLoaded)) {
 312       unset(self::$_alreadyLoaded[$groupID]);
 313     }
 314
 315     $refresh = NULL;
 316     $params = array();
 317     $smartGroupCacheTimeout = self::smartGroupCacheTimeout();
 318
 319     $now = CRM_Utils_Date::getUTCTime();
 320     $refreshTime = CRM_Utils_Date::getUTCTime($smartGroupCacheTimeout * 60);
 321
 322     if (!isset($groupID)) {
 323       if ($smartGroupCacheTimeout == 0) {
 324         $query = "
 325 TRUNCATE civicrm_group_contact_cache
 326 ";
 327         $update = "
 328 UPDATE civicrm_group g
 329 SET    cache_date = null,
 330        refresh_date = null
 331 ";
 332       }
 333       else {
 334
 335         $query = "
 336 DELETE     gc
 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
 340 ";
 341         $update = "
 342 UPDATE civicrm_group g
 343 SET    cache_date = null,
 344        refresh_date = null
 345 WHERE  g.cache_date >= %1
 346 ";
 347         $refresh = "
 348 UPDATE civicrm_group g
 349 SET    refresh_date = $refreshTime
 350 WHERE  g.cache_date < %1
 351 AND    refresh_date IS NULL
 352 ";
 353         $cacheTime = date('Y-m-d H-i-s', strtotime("- $smartGroupCacheTimeout minutes"));
 354         $params = array(1 => array($cacheTime, 'String'));
 355       }
 356     }
 357     elseif (is_array($groupID)) {
 358       $groupIDs = implode(', ', $groupID);
 359       $query = "
 360 DELETE     g
 361 FROM       civicrm_group_contact_cache g
 362 WHERE      g.group_id IN ( $groupIDs )
 363 ";
 364       $update = "
 365 UPDATE civicrm_group g
 366 SET    cache_date = null,
 367        refresh_date = null
 368 WHERE  id IN ( $groupIDs )
 369 ";
 370     }
 371     else {
 372       $query = "
 373 DELETE     g
 374 FROM       civicrm_group_contact_cache g
 375 WHERE      g.group_id = %1
 376 ";
 377       $update = "
 378 UPDATE civicrm_group g
 379 SET    cache_date = null,
 380        refresh_date = null
 381 WHERE  id = %1
 382 ";
 383       $params = array(1 => array($groupID, 'Integer'));
 384     }
 385
 386     CRM_Core_DAO::executeQuery($query, $params);
 387
 388     if ($refresh) {
 389       CRM_Core_DAO::executeQuery($refresh, $params);
 390     }
 391
 392     // also update the cache_date for these groups
 393     CRM_Core_DAO::executeQuery($update, $params);
 394   }
 395
 396   /**
 397    * Removes one or more contacts from the smart group cache.
 398    * @param int|array $cid
 399    * @param int $groupId
 400    * @return bool
 401    *   TRUE if successful.
 402    */
 403   public static function removeContact($cid, $groupId = NULL) {
 404     $cids = array();
 405     // sanitize input
 406     foreach ((array) $cid as $c) {
 407       $cids[] = CRM_Utils_Type::escape($c, 'Integer');
 408     }
 409     if ($cids) {
 410       $condition = count($cids) == 1 ? "= {$cids[0]}" : "IN (" . implode(',', $cids) . ")";
 411       if ($groupId) {
 412         $condition .= " AND group_id = " . CRM_Utils_Type::escape($groupId, 'Integer');
 413       }
 414       $sql = "DELETE FROM civicrm_group_contact_cache WHERE contact_id $condition";
 415       CRM_Core_DAO::executeQuery($sql);
 416       return TRUE;
 417     }
 418     return FALSE;
 419   }
 420
 421   /**
 422    * Load the smart group cache for a saved search.
 423    *
 424    * @param object $group
 425    *   The smart group that needs to be loaded.
 426    * @param bool $force
 427    *   Should we force a search through.
 428    */
 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) {
 433       return;
 434     }
 435
 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"
 443       return;
 444     }
 445
 446     self::$_alreadyLoaded[$groupID] = 1;
 447
 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
 450     // done
 451     // we allow hidden groups here since we dont know if the caller wants to evaluate an
 452     // hidden group
 453     if (!$force && !self::shouldGroupBeRefreshed($groupID, TRUE)) {
 454       $lock->release();
 455       return;
 456     }
 457
 458     $sql = NULL;
 459     $idName = 'id';
 460     $customClass = NULL;
 461     if ($savedSearchID) {
 462       $ssParams = CRM_Contact_BAO_SavedSearch::getSearchParams($savedSearchID);
 463
 464       // rectify params to what proximity search expects if there is a value for prox_distance
 465       // CRM-7021
 466       if (!empty($ssParams)) {
 467         CRM_Contact_BAO_ProximityQuery::fixInputParams($ssParams);
 468       }
 469
 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);
 474       }
 475
 476       if (isset($ssParams['customSearchID'])) {
 477         // if custom search
 478
 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 ) ";
 487         }
 488         $idName = 'contact_id';
 489       }
 490       else {
 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).
 500         $query
 501           = new CRM_Contact_BAO_Query(
 502             $ssParams, $returnProperties, NULL,
 503             FALSE, FALSE, 1,
 504             TRUE, TRUE,
 505             FALSE,
 506             CRM_Utils_Array::value('display_relationship_type', $formValues),
 507             CRM_Utils_Array::value('operator', $formValues, 'AND')
 508           );
 509         $query->_useDistinct = FALSE;
 510         $query->_useGroupBy = FALSE;
 511         $searchSQL
 512           = $query->searchQuery(
 513             0, 0, NULL,
 514             FALSE, FALSE,
 515             FALSE, TRUE,
 516             TRUE,
 517             NULL, NULL, NULL,
 518             TRUE
 519           );
 520       }
 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 ) ";
 526     }
 527
 528     if ($sql) {
 529       $sql = preg_replace("/^\s*SELECT/", "SELECT $groupID as group_id, ", $sql);
 530     }
 531
 532     // lets also store the records that are explicitly added to the group
 533     // this allows us to skip the group contact LEFT JOIN
 534     $sqlB = "
 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 ";
 539
 540     $groupIDs = array($groupID);
 541     self::remove($groupIDs);
 542     $processed = FALSE;
 543     $tempTable = 'civicrm_temp_group_contact_cache' . rand(0, 2000);
 544     foreach (array($sql, $sqlB) as $selectSql) {
 545       if (!$selectSql) {
 546         continue;
 547       }
 548       $insertSql = "CREATE TEMPORARY TABLE $tempTable ($selectSql);";
 549       $processed = TRUE;
 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
 554       ");
 555       CRM_Core_DAO::executeQuery(" DROP TEMPORARY TABLE $tempTable");
 556     }
 557
 558     self::updateCacheTime($groupIDs, $processed);
 559
 560     if ($group->children) {
 561
 562       //Store a list of contacts who are removed from the parent group
 563       $sql = "
 564 SELECT contact_id
 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;
 572       }
 573
 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]);
 580         }
 581         $values = array();
 582         foreach ($contactIDs as $contactID => $dontCare) {
 583           $values[] = "({$groupID},{$contactID})";
 584         }
 585
 586         self::store($groupIDs, $values);
 587       }
 588     }
 589
 590     $lock->release();
 591   }
 592
 593   /**
 594    * @return int
 595    */
 596   public static function smartGroupCacheTimeout() {
 597     $config = CRM_Core_Config::singleton();
 598
 599     if (
 600       isset($config->smartGroupCacheTimeout) &&
 601       is_numeric($config->smartGroupCacheTimeout)
 602     ) {
 603       return $config->smartGroupCacheTimeout;
 604     }
 605
 606     // lets have a min cache time of 5 mins if not set
 607     return 5;
 608   }
 609
 610   /**
 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
 614    *
 615    * @param int $contactID
 616    * @param bool $showHidden
 617    *   Hidden groups are shown only if this flag is set.
 618    *
 619    * @return array
 620    *   an array of groups that this contact belongs to
 621    */
 622   public static function contactGroup($contactID, $showHidden = FALSE) {
 623     if (empty($contactID)) {
 624       return NULL;
 625     }
 626
 627     if (is_array($contactID)) {
 628       $contactIDs = $contactID;
 629     }
 630     else {
 631       $contactIDs = array($contactID);
 632     }
 633
 634     self::loadAll();
 635
 636     $hiddenClause = '';
 637     if (!$showHidden) {
 638       $hiddenClause = ' AND (g.is_hidden = 0 OR g.is_hidden IS NULL) ';
 639     }
 640
 641     $contactIDString = CRM_Core_DAO::escapeString(implode(', ', $contactIDs));
 642     $sql = "
 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)
 647            $hiddenClause
 648 ORDER BY   gc.contact_id, g.children
 649 ";
 650
 651     $dao = CRM_Core_DAO::executeQuery($sql);
 652     $contactGroup = array();
 653     $prevContactID = NULL;
 654     while ($dao->fetch()) {
 655       if (
 656         $prevContactID &&
 657         $prevContactID != $dao->contact_id
 658       ) {
 659         $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
 660       }
 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());
 665       }
 666
 667       $contactGroup[$dao->contact_id]['group'][]
 668         = array(
 669           'id' => $dao->group_id,
 670           'title' => $dao->title,
 671           'description' => $dao->description,
 672           'children' => $dao->children,
 673         );
 674       $contactGroup[$dao->contact_id]['groupTitle'][] = $dao->title;
 675     }
 676
 677     if ($prevContactID) {
 678       $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
 679     }
 680
 681     if ((!empty($contactGroup[$contactID]) && is_numeric($contactID))) {
 682       return $contactGroup[$contactID];
 683     }
 684     else {
 685       return $contactGroup;
 686     }
 687   }
 688
 689 }