CRM/Contact/BAO/GroupContactCache.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.6                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2014                                |
   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-2014
  32  * $Id$
  33  *
  34  */
  35 class CRM_Contact_BAO_GroupContactCache extends CRM_Contact_DAO_GroupContactCache {
  36
  37   static $_alreadyLoaded = array();
  38
  39   /**
  40    * Check to see if we have cache entries for this group
  41    * if not, regenerate, else return
  42    *
  43    * @param $groupIDs
  44    *   Of group that we are checking against.
  45    *
  46    * @return boolean
  47    *   TRUE if we did not regenerate, FALSE if we did
  48    */
  49   public static function check($groupIDs) {
  50     if (empty($groupIDs)) {
  51       return TRUE;
  52     }
  53
  54     return self::loadAll($groupIDs);
  55   }
  56
  57   /**
  58    * Common function that formulates the query to see which groups needs to be refreshed
  59    * based on their cache date and the smartGroupCacheTimeOut
  60    *
  61    * @param string $groupIDClause
  62    *   The clause which limits which groups we need to evaluate.
  63    * @param bool $includeHiddenGroups
  64    *   Hidden groups are excluded by default.
  65    *
  66    * @return string
  67    *   the sql query which lists the groups that need to be refreshed
  68    * @static
  69    */
  70   public static function groupRefreshedClause($groupIDClause = NULL, $includeHiddenGroups = FALSE) {
  71     $smartGroupCacheTimeout = self::smartGroupCacheTimeout();
  72     $now = CRM_Utils_Date::getUTCTime();
  73
  74     $query = "
  75 SELECT  g.id
  76 FROM    civicrm_group g
  77 WHERE   ( g.saved_search_id IS NOT NULL OR g.children IS NOT NULL )
  78 AND     g.is_active = 1
  79 AND     ( g.cache_date IS NULL OR
  80           ( TIMESTAMPDIFF(MINUTE, g.cache_date, $now) >= $smartGroupCacheTimeout ) OR
  81           ( $now >= g.refresh_date )
  82         )
  83 ";
  84
  85     if (!$includeHiddenGroups) {
  86       $query .= "AND (g.is_hidden = 0 OR g.is_hidden IS NULL)";
  87     }
  88
  89     if (!empty($groupIDClause)) {
  90       $query .= " AND ( $groupIDClause ) ";
  91     }
  92
  93     return $query;
  94   }
  95
  96   /**
  97    * Checks to see if a group has been refreshed recently. This is primarily used
  98    * in a locking scenario when some other process might have refreshed things underneath
  99    * this process
 100    *
 101    * @param int $groupID
 102    *   The group ID.
 103    * @param bool $includeHiddenGroups
 104    *   Hidden groups are excluded by default.
 105    *
 106    * @return string
 107    *   the sql query which lists the groups that need to be refreshed
 108    * @static
 109    */
 110   public static function shouldGroupBeRefreshed($groupID, $includeHiddenGroups = FALSE) {
 111     $query = self::groupRefreshedClause("g.id = %1", $includeHiddenGroups);
 112     $params = array(1 => array($groupID, 'Integer'));
 113
 114     // if the query returns the group ID, it means the group is a valid candidate for refreshing
 115     return CRM_Core_DAO::singleValueQuery($query, $params);
 116   }
 117
 118   /**
 119    * Check to see if we have cache entries for this group
 120    * if not, regenerate, else return
 121    *
 122    * @param int /array $groupID groupID of group that we are checking against
 123    *                           if empty, all groups are checked
 124    * @param int $limit
 125    *   Limits the number of groups we evaluate.
 126    *
 127    * @return boolean
 128    *   TRUE if we did not regenerate, FALSE if we did
 129    */
 130   public static function loadAll($groupIDs = NULL, $limit = 0) {
 131     // ensure that all the smart groups are loaded
 132     // this function is expensive and should be sparingly used if groupIDs is empty
 133     if (empty($groupIDs)) {
 134       $groupIDClause = NULL;
 135       $groupIDs = array();
 136     }
 137     else {
 138       if (!is_array($groupIDs)) {
 139         $groupIDs = array($groupIDs);
 140       }
 141
 142       // note escapeString is a must here and we can't send the imploded value as second arguement to
 143       // the executeQuery(), since that would put single quote around the string and such a string
 144       // of comma separated integers would not work.
 145       $groupIDString = CRM_Core_DAO::escapeString(implode(', ', $groupIDs));
 146
 147       $groupIDClause = "g.id IN ({$groupIDString})";
 148     }
 149
 150     $query = self::groupRefreshedClause($groupIDClause);
 151
 152     $limitClause = $orderClause = NULL;
 153     if ($limit > 0) {
 154       $limitClause = " LIMIT 0, $limit";
 155       $orderClause = " ORDER BY g.cache_date, g.refresh_date";
 156     }
 157     // We ignore hidden groups and disabled groups
 158     $query .= "
 159         $orderClause
 160         $limitClause
 161 ";
 162
 163     $dao = CRM_Core_DAO::executeQuery($query);
 164     $processGroupIDs = array();
 165     $refreshGroupIDs = $groupIDs;
 166     while ($dao->fetch()) {
 167       $processGroupIDs[] = $dao->id;
 168
 169       // remove this id from refreshGroupIDs
 170       foreach ($refreshGroupIDs as $idx => $gid) {
 171         if ($gid == $dao->id) {
 172           unset($refreshGroupIDs[$idx]);
 173           break;
 174         }
 175       }
 176     }
 177
 178     if (!empty($refreshGroupIDs)) {
 179       $refreshGroupIDString = CRM_Core_DAO::escapeString(implode(', ', $refreshGroupIDs));
 180       $time = CRM_Utils_Date::getUTCTime(self::smartGroupCacheTimeout() * 60);
 181       $query = "
 182 UPDATE civicrm_group g
 183 SET    g.refresh_date = $time
 184 WHERE  g.id IN ( {$refreshGroupIDString} )
 185 AND    g.refresh_date IS NULL
 186 ";
 187       CRM_Core_DAO::executeQuery($query);
 188     }
 189
 190     if (empty($processGroupIDs)) {
 191       return TRUE;
 192     }
 193     else {
 194       self::add($processGroupIDs);
 195       return FALSE;
 196     }
 197   }
 198
 199   /**
 200    * FIXME: This function should not be needed, because the cache table should not be getting truncated
 201    */
 202   public static function fillIfEmpty() {
 203     if (!CRM_Core_DAO::singleValueQuery("SELECT COUNT(id) FROM civicrm_group_contact_cache")) {
 204       self::loadAll();
 205     }
 206   }
 207
 208   /**
 209    * @param int $groupID
 210    */
 211   public static function add($groupID) {
 212     // first delete the current cache
 213     self::remove($groupID);
 214     if (!is_array($groupID)) {
 215       $groupID = array($groupID);
 216     }
 217
 218     $returnProperties = array('contact_id');
 219     foreach ($groupID as $gid) {
 220       $params = array(array('group', 'IN', array($gid => 1), 0, 0));
 221       // the below call updates the cache table as a byproduct of the query
 222       CRM_Contact_BAO_Query::apiQuery($params, $returnProperties, NULL, NULL, 0, 0, FALSE);
 223     }
 224   }
 225
 226   /**
 227    * @param int $groupID
 228    * @param $values
 229    */
 230   public static function store(&$groupID, &$values) {
 231     $processed = FALSE;
 232
 233     // sort the values so we put group IDs in front and hence optimize
 234     // mysql storage (or so we think) CRM-9493
 235     sort($values);
 236
 237     // to avoid long strings, lets do BULK_INSERT_COUNT values at a time
 238     while (!empty($values)) {
 239       $processed = TRUE;
 240       $input = array_splice($values, 0, CRM_Core_DAO::BULK_INSERT_COUNT);
 241       $str = implode(',', $input);
 242       $sql = "INSERT IGNORE INTO civicrm_group_contact_cache (group_id,contact_id) VALUES $str;";
 243       CRM_Core_DAO::executeQuery($sql);
 244     }
 245     self::updateCacheTime($groupID, $processed);
 246   }
 247
 248   /**
 249    * Change the cache_date
 250    *
 251    * @param array $groupID
 252    * @param bool $processed
 253    *   Whether the cache data was recently modified.
 254    */
 255   public static function updateCacheTime($groupID, $processed) {
 256     // only update cache entry if we had any values
 257     if ($processed) {
 258       // also update the group with cache date information
 259       //make sure to give original timezone settings again.
 260       $now = CRM_Utils_Date::getUTCTime();
 261       $refresh = 'null';
 262     }
 263     else {
 264       $now = 'null';
 265       $refresh = 'null';
 266     }
 267
 268     $groupIDs = implode(',', $groupID);
 269     $sql = "
 270 UPDATE civicrm_group
 271 SET    cache_date = $now, refresh_date = $refresh
 272 WHERE  id IN ( $groupIDs )
 273 ";
 274     CRM_Core_DAO::executeQuery($sql);
 275   }
 276
 277   /**
 278    * Removes all the cache entries pertaining to a specific group
 279    * If no groupID is passed in, removes cache entries for all groups
 280    * Has an optimization to bypass repeated invocations of this function.
 281    * Note that this function is an advisory, i.e. the removal respects the
 282    * cache date, i.e. the removal is not done if the group was recently
 283    * loaded into the cache.
 284    *
 285    * @param int $groupID
 286    *   the groupID to delete cache entries, NULL for all groups.
 287    * @param bool $onceOnly
 288    *   run the function exactly once for all groups.
 289    *
 290    * @return void
 291    * @static
 292    */
 293   public static function remove($groupID = NULL, $onceOnly = TRUE) {
 294     static $invoked = FALSE;
 295
 296     // typically this needs to happy only once per instance
 297     // this is especially TRUE in import, where we dont need
 298     // to do this all the time
 299     // this optimization is done only when no groupID is passed
 300     // i.e. cache is reset for all groups
 301     if (
 302       $onceOnly &&
 303       $invoked &&
 304       $groupID == NULL
 305     ) {
 306       return;
 307     }
 308
 309     if ($groupID == NULL) {
 310       $invoked = TRUE;
 311     }
 312     elseif (is_array($groupID)) {
 313       foreach ($groupID as $gid) {
 314         unset(self::$_alreadyLoaded[$gid]);
 315       }
 316     }
 317     elseif ($groupID && array_key_exists($groupID, self::$_alreadyLoaded)) {
 318       unset(self::$_alreadyLoaded[$groupID]);
 319     }
 320
 321     $refresh = NULL;
 322     $params = array();
 323     $smartGroupCacheTimeout = self::smartGroupCacheTimeout();
 324
 325     $now = CRM_Utils_Date::getUTCTime();
 326     $refreshTime = CRM_Utils_Date::getUTCTime($smartGroupCacheTimeout * 60);
 327
 328     if (!isset($groupID)) {
 329       if ($smartGroupCacheTimeout == 0) {
 330         $query = "
 331 TRUNCATE civicrm_group_contact_cache
 332 ";
 333         $update = "
 334 UPDATE civicrm_group g
 335 SET    cache_date = null,
 336        refresh_date = null
 337 ";
 338       }
 339       else {
 340         $query = "
 341 DELETE     gc
 342 FROM       civicrm_group_contact_cache gc
 343 INNER JOIN civicrm_group g ON g.id = gc.group_id
 344 WHERE      TIMESTAMPDIFF(MINUTE, g.cache_date, $now) >= $smartGroupCacheTimeout
 345 ";
 346         $update = "
 347 UPDATE civicrm_group g
 348 SET    cache_date = null,
 349        refresh_date = null
 350 WHERE  TIMESTAMPDIFF(MINUTE, cache_date, $now) >= $smartGroupCacheTimeout
 351 ";
 352         $refresh = "
 353 UPDATE civicrm_group g
 354 SET    refresh_date = $refreshTime
 355 WHERE  TIMESTAMPDIFF(MINUTE, cache_date, $now) < $smartGroupCacheTimeout
 356 AND    refresh_date IS NULL
 357 ";
 358       }
 359     }
 360     elseif (is_array($groupID)) {
 361       $groupIDs = implode(', ', $groupID);
 362       $query = "
 363 DELETE     g
 364 FROM       civicrm_group_contact_cache g
 365 WHERE      g.group_id IN ( $groupIDs )
 366 ";
 367       $update = "
 368 UPDATE civicrm_group g
 369 SET    cache_date = null,
 370        refresh_date = null
 371 WHERE  id IN ( $groupIDs )
 372 ";
 373     }
 374     else {
 375       $query = "
 376 DELETE     g
 377 FROM       civicrm_group_contact_cache g
 378 WHERE      g.group_id = %1
 379 ";
 380       $update = "
 381 UPDATE civicrm_group g
 382 SET    cache_date = null,
 383        refresh_date = null
 384 WHERE  id = %1
 385 ";
 386       $params = array(1 => array($groupID, 'Integer'));
 387     }
 388
 389     CRM_Core_DAO::executeQuery($query, $params);
 390
 391     if ($refresh) {
 392       CRM_Core_DAO::executeQuery($refresh, $params);
 393     }
 394
 395     // also update the cache_date for these groups
 396     CRM_Core_DAO::executeQuery($update, $params);
 397   }
 398
 399   /**
 400    * Removes one or more contacts from the smart group cache
 401    * @param int|array $cid
 402    * @param int $groupId
 403    * @return bool
 404    *   TRUE if successful.
 405    */
 406   public static function removeContact($cid, $groupId = NULL) {
 407     $cids = array();
 408     // sanitize input
 409     foreach ((array) $cid as $c) {
 410       $cids[] = CRM_Utils_Type::escape($c, 'Integer');
 411     }
 412     if ($cids) {
 413       $condition = count($cids) == 1 ? "= {$cids[0]}" : "IN (" . implode(',', $cids) . ")";
 414       if ($groupId) {
 415         $condition .= " AND group_id = " . CRM_Utils_Type::escape($groupId, 'Integer');
 416       }
 417       $sql = "DELETE FROM civicrm_group_contact_cache WHERE contact_id $condition";
 418       CRM_Core_DAO::executeQuery($sql);
 419       return TRUE;
 420     }
 421     return FALSE;
 422   }
 423
 424   /**
 425    * Load the smart group cache for a saved search
 426    *
 427    * @param object $group
 428    *   The smart group that needs to be loaded.
 429    * @param bool $force
 430    *   Should we force a search through.
 431    */
 432   public static function load(&$group, $force = FALSE) {
 433     $groupID = $group->id;
 434     $savedSearchID = $group->saved_search_id;
 435     if (array_key_exists($groupID, self::$_alreadyLoaded) && !$force) {
 436       return;
 437     }
 438
 439     // grab a lock so other processes dont compete and do the same query
 440     $lockName = "civicrm.group.{$groupID}";
 441     $lock = new CRM_Core_Lock($lockName);
 442     if (!$lock->isAcquired()) {
 443       // this can cause inconsistent results since we dont know if the other process
 444       // will fill up the cache before our calling routine needs it.
 445       // however this routine does not return the status either, so basically
 446       // its a "lets return and hope for the best"
 447       return;
 448     }
 449
 450     self::$_alreadyLoaded[$groupID] = 1;
 451
 452     // we now have the lock, but some other proces could have actually done the work
 453     // before we got here, so before we do any work, lets ensure that work needs to be
 454     // done
 455     // we allow hidden groups here since we dont know if the caller wants to evaluate an
 456     // hidden group
 457     if (!$force && !self::shouldGroupBeRefreshed($groupID, TRUE)) {
 458       $lock->release();
 459       return;
 460     }
 461
 462     $sql = NULL;
 463     $idName = 'id';
 464     $customClass = NULL;
 465     if ($savedSearchID) {
 466       $ssParams = CRM_Contact_BAO_SavedSearch::getSearchParams($savedSearchID);
 467
 468       // rectify params to what proximity search expects if there is a value for prox_distance
 469       // CRM-7021
 470       if (!empty($ssParams)) {
 471         CRM_Contact_BAO_ProximityQuery::fixInputParams($ssParams);
 472       }
 473
 474
 475       $returnProperties = array();
 476       if (CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_SavedSearch', $savedSearchID, 'mapping_id')) {
 477         $fv = CRM_Contact_BAO_SavedSearch::getFormValues($savedSearchID);
 478         $returnProperties = CRM_Core_BAO_Mapping::returnProperties($fv);
 479       }
 480
 481       if (isset($ssParams['customSearchID'])) {
 482         // if custom search
 483
 484         // we split it up and store custom class
 485         // so temp tables are not destroyed if they are used
 486         // hence customClass is defined above at top of function
 487         $customClass =
 488           CRM_Contact_BAO_SearchCustom::customClass($ssParams['customSearchID'], $savedSearchID);
 489         $searchSQL = $customClass->contactIDs();
 490         $searchSQL = str_replace('ORDER BY contact_a.id ASC', '', $searchSQL);
 491         $idName = 'contact_id';
 492       }
 493       else {
 494         $formValues = CRM_Contact_BAO_SavedSearch::getFormValues($savedSearchID);
 495
 496         $query =
 497           new CRM_Contact_BAO_Query(
 498             $ssParams, $returnProperties, NULL,
 499             FALSE, FALSE, 1,
 500             TRUE, TRUE,
 501             FALSE,
 502             CRM_Utils_Array::value('display_relationship_type', $formValues),
 503             CRM_Utils_Array::value('operator', $formValues, 'AND')
 504           );
 505         $query->_useDistinct = FALSE;
 506         $query->_useGroupBy = FALSE;
 507         $searchSQL =
 508           $query->searchQuery(
 509             0, 0, NULL,
 510             FALSE, FALSE,
 511             FALSE, TRUE,
 512             TRUE,
 513             NULL, NULL, NULL,
 514             TRUE
 515           );
 516       }
 517       $groupID = CRM_Utils_Type::escape($groupID, 'Integer');
 518       $sql = $searchSQL . " AND contact_a.id NOT IN (
 519                               SELECT contact_id FROM civicrm_group_contact
 520                               WHERE civicrm_group_contact.status = 'Removed'
 521                               AND   civicrm_group_contact.group_id = $groupID ) ";
 522     }
 523
 524     if ($sql) {
 525       $sql = preg_replace("/^\s*SELECT/", "SELECT $groupID as group_id, ", $sql);
 526     }
 527
 528     // lets also store the records that are explicitly added to the group
 529     // this allows us to skip the group contact LEFT JOIN
 530     $sqlB = "
 531 SELECT $groupID as group_id, contact_id as $idName
 532 FROM   civicrm_group_contact
 533 WHERE  civicrm_group_contact.status = 'Added'
 534   AND  civicrm_group_contact.group_id = $groupID ";
 535
 536     $groupIDs = array($groupID);
 537     self::remove($groupIDs);
 538     $processed = FALSE;
 539     $tempTable = 'civicrm_temp_group_contact_cache' . rand(0, 2000);
 540     foreach (array($sql, $sqlB) as $selectSql) {
 541       if (!$selectSql) {
 542         continue;
 543       }
 544       $insertSql = "CREATE TEMPORARY TABLE $tempTable ($selectSql);";
 545       $processed = TRUE;
 546       $result = CRM_Core_DAO::executeQuery($insertSql);
 547       CRM_Core_DAO::executeQuery(
 548         "INSERT IGNORE INTO civicrm_group_contact_cache (contact_id, group_id)
 549         SELECT DISTINCT $idName, group_id FROM $tempTable
 550       ");
 551       CRM_Core_DAO::executeQuery(" DROP TABLE $tempTable");
 552     }
 553
 554     self::updateCacheTime($groupIDs, $processed);
 555
 556     if ($group->children) {
 557
 558       //Store a list of contacts who are removed from the parent group
 559       $sql = "
 560 SELECT contact_id
 561 FROM civicrm_group_contact
 562 WHERE  civicrm_group_contact.status = 'Removed'
 563 AND  civicrm_group_contact.group_id = $groupID ";
 564       $dao = CRM_Core_DAO::executeQuery($sql);
 565       $removed_contacts = array();
 566       while ($dao->fetch()) {
 567         $removed_contacts[] = $dao->contact_id;
 568       }
 569
 570       $childrenIDs = explode(',', $group->children);
 571       foreach ($childrenIDs as $childID) {
 572         $contactIDs = CRM_Contact_BAO_Group::getMember($childID, FALSE);
 573         //Unset each contact that is removed from the parent group
 574         foreach ($removed_contacts as $removed_contact) {
 575           unset($contactIDs[$removed_contact]);
 576         }
 577         $values = array();
 578         foreach ($contactIDs as $contactID => $dontCare) {
 579           $values[] = "({$groupID},{$contactID})";
 580         }
 581
 582         self::store($groupIDs, $values);
 583       }
 584     }
 585
 586     $lock->release();
 587   }
 588
 589   /**
 590    * @return int
 591    */
 592   public static function smartGroupCacheTimeout() {
 593     $config = CRM_Core_Config::singleton();
 594
 595     if (
 596       isset($config->smartGroupCacheTimeout) &&
 597       is_numeric($config->smartGroupCacheTimeout) &&
 598       $config->smartGroupCacheTimeout > 0
 599     ) {
 600       return $config->smartGroupCacheTimeout;
 601     }
 602
 603     // lets have a min cache time of 5 mins if not set
 604     return 5;
 605   }
 606
 607   /**
 608    * Get all the smart groups that this contact belongs to
 609    * Note that this could potentially be a super slow function since
 610    * it ensure that all contact groups are loaded in the cache
 611    *
 612    * @param int $contactID
 613    * @param bool $showHidden
 614    *   Hidden groups are shown only if this flag is set.
 615    *
 616    * @return array
 617    *   an array of groups that this contact belongs to
 618    */
 619   public static function contactGroup($contactID, $showHidden = FALSE) {
 620     if (empty($contactID)) {
 621       return;
 622     }
 623
 624     if (is_array($contactID)) {
 625       $contactIDs = $contactID;
 626     }
 627     else {
 628       $contactIDs = array($contactID);
 629     }
 630
 631     self::loadAll();
 632
 633     $hiddenClause = '';
 634     if (!$showHidden) {
 635       $hiddenClause = ' AND (g.is_hidden = 0 OR g.is_hidden IS NULL) ';
 636     }
 637
 638     $contactIDString = CRM_Core_DAO::escapeString(implode(', ', $contactIDs));
 639     $sql = "
 640 SELECT     gc.group_id, gc.contact_id, g.title, g.children, g.description
 641 FROM       civicrm_group_contact_cache gc
 642 INNER JOIN civicrm_group g ON g.id = gc.group_id
 643 WHERE      gc.contact_id IN ($contactIDString)
 644            $hiddenClause
 645 ORDER BY   gc.contact_id, g.children
 646 ";
 647
 648     $dao = CRM_Core_DAO::executeQuery($sql);
 649     $contactGroup = array();
 650     $prevContactID = NULL;
 651     while ($dao->fetch()) {
 652       if (
 653         $prevContactID &&
 654         $prevContactID != $dao->contact_id
 655       ) {
 656         $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
 657       }
 658       $prevContactID = $dao->contact_id;
 659       if (!array_key_exists($dao->contact_id, $contactGroup)) {
 660         $contactGroup[$dao->contact_id] =
 661           array('group' => array(), 'groupTitle' => array());
 662       }
 663
 664       $contactGroup[$dao->contact_id]['group'][] =
 665         array(
 666           'id' => $dao->group_id,
 667           'title' => $dao->title,
 668           'description' => $dao->description,
 669           'children' => $dao->children,
 670         );
 671       $contactGroup[$dao->contact_id]['groupTitle'][] = $dao->title;
 672     }
 673
 674     if ($prevContactID) {
 675       $contactGroup[$prevContactID]['groupTitle'] = implode(', ', $contactGroup[$prevContactID]['groupTitle']);
 676     }
 677
 678     if ((!empty($contactGroup[$contactID]) && is_numeric($contactID))) {
 679       return $contactGroup[$contactID];
 680     }
 681     else {
 682       return $contactGroup;
 683     }
 684   }
 685
 686 }