classes/userfilter.php

   1 <?php
   2 /***************************************************************************
   3  *  Copyright (C) 2003-2014 Polytechnique.org                              *
   4  *  http://opensource.polytechnique.org/                                   *
   5  *                                                                         *
   6  *  This program is free software; you can redistribute it and/or modify   *
   7  *  it under the terms of the GNU General Public License as published by   *
   8  *  the Free Software Foundation; either version 2 of the License, or      *
   9  *  (at your option) any later version.                                    *
  10  *                                                                         *
  11  *  This program is distributed in the hope that it will be useful,        *
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of         *
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          *
  14  *  GNU General Public License for more details.                           *
  15  *                                                                         *
  16  *  You should have received a copy of the GNU General Public License      *
  17  *  along with this program; if not, write to the Free Software            *
  18  *  Foundation, Inc.,                                                      *
  19  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                *
  20  ***************************************************************************/
  21
  22 require_once dirname(__FILE__) . '/userfilter/conditions.inc.php';
  23 require_once dirname(__FILE__) . '/userfilter/orders.inc.php';
  24
  25 /***********************************
  26   *********************************
  27           USER FILTER CLASS
  28   *********************************
  29  ***********************************/
  30
  31 // {{{ class UserFilter
  32 /** This class provides a convenient and centralized way of filtering users.
  33  *
  34  * Usage:
  35  * $uf = new UserFilter(new UFC_Blah($x, $y), new UFO_Coin($z, $t));
  36  *
  37  * Resulting UserFilter can be used to:
  38  * - get a list of User objects matching the filter
  39  * - get a list of UIDs matching the filter
  40  * - get the number of users matching the filter
  41  * - check whether a given User matches the filter
  42  * - filter a list of User objects depending on whether they match the filter
  43  *
  44  * Usage for UFC and UFO objects:
  45  * A UserFilter will call all private functions named XXXJoins.
  46  * These functions must return an array containing the list of join
  47  * required by the various UFC and UFO associated to the UserFilter.
  48  * Entries in those returned array are of the following form:
  49  *   'join_tablealias' => array('join_type', 'joined_table', 'join_criter')
  50  * which will be translated into :
  51  *   join_type JOIN joined_table AS join_tablealias ON (join_criter)
  52  * in the final query.
  53  *
  54  * In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
  55  * profile.pid, and $UID with accounts.uid.
  56  *
  57  * For each kind of "JOIN" needed, a function named addXXXFilter() should be defined;
  58  * its parameter will be used to set various private vars of the UserFilter describing
  59  * the required joins ; such a function shall return the "join_tablealias" to use
  60  * when referring to the joined table.
  61  *
  62  * For example, if data from profile_job must be available to filter results,
  63  * the UFC object will call $uf-addJobFilter(), which will set the 'with_pj' var and
  64  * return 'pj', the short name to use when referring to profile_job; when building
  65  * the query, calling the jobJoins function will return an array containing a single
  66  * row:
  67  *   'pj' => array('left', 'profile_job', '$ME.pid = $UID');
  68  *
  69  * The 'register_optional' function can be used to generate unique table aliases when
  70  * the same table has to be joined several times with different aliases.
  71  */
  72 class UserFilter extends PlFilter
  73 {
  74     protected $joinMethods = array();
  75
  76     protected $joinMetas = array(
  77                                 '$PID' => 'p.pid',
  78                                 '$UID' => 'a.uid',
  79                                 );
  80
  81     private $root;
  82     private $sort = array();
  83     private $grouper = null;
  84     private $query = null;
  85     private $orderby = null;
  86
  87     // Store the current 'search' visibility.
  88     private $visibility = null;
  89     // If the 'search' visibility should be based on a DB field instead.
  90     private $visibility_field = null;
  91
  92     private $lastusercount = null;
  93     private $lastprofilecount = null;
  94
  95     public function __construct($cond = null, $sort = null)
  96     {
  97         if (empty($this->joinMethods)) {
  98             $class = new ReflectionClass('UserFilter');
  99             foreach ($class->getMethods() as $method) {
 100                 $name = $method->getName();
 101                 if (substr($name, -5) == 'Joins' && $name != 'buildJoins') {
 102                     $this->joinMethods[] = $name;
 103                 }
 104             }
 105         }
 106         if (!is_null($cond)) {
 107             if ($cond instanceof PlFilterCondition) {
 108                 $this->setCondition($cond);
 109             }
 110         }
 111         if (!is_null($sort)) {
 112             if ($sort instanceof PlFilterOrder) {
 113                 $this->addSort($sort);
 114             } else if (is_array($sort)) {
 115                 foreach ($sort as $s) {
 116                     $this->addSort($s);
 117                 }
 118             }
 119         }
 120
 121         // This will set the visibility to the default correct level.
 122         $this->visibility = Visibility::defaultForRead();
 123     }
 124
 125     /** Get the SQL condition to filter by visibility level for a field.
 126      * This will return a SQL condition which evaluates to True if the given
 127      * field display level is available from the current access level.
 128      * @param $field Name of the field holding a display level
 129      * @return string SQL condition, properly escaped, for that field.
 130      */
 131     public function getVisibilityConditionForField($field)
 132     {
 133         if ($this->visibility_field != null) {
 134             // Use enum 'bit' arithmetic.
 135             // Display levels are ordered as 'hidden, private, ax, public'
 136             // Thus ax > private.
 137             // The $sub.display_level cell will contain the 'most private' display
 138             // level available based on $field. If it is 'ax' and $field is
 139             // 'private','ax' <= 'private' is false.
 140             $sub = $this->addVisibilityFieldFilter($this->visibility_field);
 141             return $sub . '.best_display_level + 0 <= 0 + ' . $field;
 142         } else {
 143             $sub = $this->addVisibilityAbsoluteFilter($this->visibility->level());
 144             return $sub . '.best_display_level + 0 <= 0 + ' . $field;
 145         }
 146     }
 147
 148     /** Get the SQL condition to filter by a given visibility level.
 149      * @param $level One of Visibility::EXPORT_*
 150      * @return string A SQL condition, properly escaped, which evaluates to 'true' if the $level can be viewed with the current access level.
 151      */
 152     public function getVisibilityConditionAbsolute($level)
 153     {
 154         if ($this->visibility_field != null) {
 155             // The $sub.display_levels cell will contain allowed display levels
 156             // for an access level of $this->visibility_field.
 157             $sub = $this->addVisibilityFieldFilter($this->visibility_field);
 158             return XDB::format('FIND_IN_SET({?}, ' . $sub . '.display_levels)', $level);
 159         } else {
 160             if ($this->visibility->isVisible($level)) {
 161                 return 'TRUE';
 162             } else {
 163                 return 'FALSE';
 164             }
 165         }
 166     }
 167
 168     private function buildQuery()
 169     {
 170         // The root condition is built first because some orders need info
 171         // available only once all UFC have set their conditions (UFO_Score)
 172         if (is_null($this->query)) {
 173             $where = $this->root->buildCondition($this);
 174             $where = str_replace(array_keys($this->joinMetas),
 175                                  $this->joinMetas,
 176                                  $where);
 177         }
 178         if (is_null($this->orderby)) {
 179             $orders = array();
 180             foreach ($this->sort as $sort) {
 181                 $orders = array_merge($orders, $sort->buildSort($this));
 182             }
 183             if (count($orders) == 0) {
 184                 $this->orderby = '';
 185             } else {
 186                 $this->orderby = 'ORDER BY  ' . implode(', ', $orders);
 187             }
 188             $this->orderby = str_replace(array_keys($this->joinMetas),
 189                                          $this->joinMetas,
 190                                          $this->orderby);
 191         }
 192         if (is_null($this->query)) {
 193             if ($this->with_accounts) {
 194                 $from = 'accounts AS a';
 195             } else {
 196                 $this->requireProfiles();
 197                 $from = 'profiles AS p';
 198             }
 199             $joins = $this->buildJoins();
 200             $this->query = 'FROM  ' . $from . '
 201                                ' . $joins . '
 202                            WHERE  (' . $where . ')';
 203         }
 204     }
 205
 206     public function hasGroups()
 207     {
 208         return $this->grouper != null;
 209     }
 210
 211     public function getGroups()
 212     {
 213         return $this->getUIDGroups();
 214     }
 215
 216     public function getUIDGroups()
 217     {
 218         $this->requireAccounts();
 219         $this->buildQuery();
 220         $token = $this->grouper->getGroupToken($this);
 221
 222         $groups = XDB::rawFetchAllRow('SELECT ' . $token . ', COUNT(a.uid)
 223                                       ' . $this->query . '
 224                                       GROUP BY  ' . $token,
 225                                       0);
 226         return $groups;
 227     }
 228
 229     public function getPIDGroups()
 230     {
 231         $this->requireProfiles();
 232         $this->buildQuery();
 233         $token = $this->grouper->getGroupToken($this);
 234
 235         $groups = XDB::rawFetchAllRow('SELECT ' . $token . ', COUNT(p.pid)
 236                                       ' . $this->query . '
 237                                       GROUP BY  ' . $token,
 238                                       0);
 239         return $groups;
 240     }
 241
 242     private function getUIDList($uids = null, PlLimit $limit)
 243     {
 244         $this->requireAccounts();
 245         $this->buildQuery();
 246         $lim = $limit->getSql();
 247         $cond = '';
 248         if (!empty($uids)) {
 249             $cond = XDB::format(' AND a.uid IN {?}', $uids);
 250         }
 251         $fetched = XDB::rawFetchColumn('SELECT SQL_CALC_FOUND_ROWS  a.uid
 252                                        ' . $this->query . $cond . '
 253                                        GROUP BY  a.uid
 254                                        ' . $this->orderby . '
 255                                        ' . $lim);
 256         $this->lastusercount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
 257         return $fetched;
 258     }
 259
 260     private function getPIDList($pids = null, PlLimit $limit)
 261     {
 262         $this->requireProfiles();
 263         $this->buildQuery();
 264         $lim = $limit->getSql();
 265         $cond = '';
 266         if (!is_null($pids)) {
 267             $cond = XDB::format(' AND p.pid IN {?}', $pids);
 268         }
 269         $fetched = XDB::rawFetchColumn('SELECT  SQL_CALC_FOUND_ROWS  p.pid
 270                                        ' . $this->query . $cond . '
 271                                        GROUP BY  p.pid
 272                                        ' . $this->orderby . '
 273                                        ' . $lim);
 274         $this->lastprofilecount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
 275         return $fetched;
 276     }
 277
 278     private static function defaultLimit($limit) {
 279         if ($limit == null) {
 280             return new PlLimit();
 281         } else {
 282             return $limit;
 283         }
 284     }
 285
 286     /** Check that the user match the given rule.
 287      */
 288     public function checkUser(PlUser $user)
 289     {
 290         $this->requireAccounts();
 291         $this->buildQuery();
 292         $count = (int)XDB::rawFetchOneCell('SELECT  COUNT(*)
 293                                            ' . $this->query
 294                                              . XDB::format(' AND a.uid = {?}', $user->id()));
 295         return $count == 1;
 296     }
 297
 298     /** Check that the profile match the given rule.
 299      */
 300     public function checkProfile(Profile $profile)
 301     {
 302         $this->requireProfiles();
 303         $this->buildQuery();
 304         $count = (int)XDB::rawFetchOneCell('SELECT  COUNT(*)
 305                                            ' . $this->query
 306                                              . XDB::format(' AND p.pid = {?}', $profile->id()));
 307         return $count == 1;
 308     }
 309
 310     /** Default filter is on users
 311      */
 312     public function filter(array $users, $limit = null)
 313     {
 314         return $this->filterUsers($users, self::defaultLimit($limit));
 315     }
 316
 317     /** Filter a list of users to extract the users matching the rule.
 318      */
 319     public function filterUsers(array $users, $limit = null)
 320     {
 321         $limit = self::defaultLimit($limit);
 322         $this->requireAccounts();
 323         $this->buildQuery();
 324         $table = array();
 325         $uids  = array();
 326         foreach ($users as $user) {
 327             if ($user instanceof PlUser) {
 328                 $uid = $user->id();
 329             } else {
 330                 $uid = $user;
 331             }
 332             $uids[] = $uid;
 333             $table[$uid] = $user;
 334         }
 335         $fetched = $this->getUIDList($uids, $limit);
 336         $output = array();
 337         foreach ($fetched as $uid) {
 338             $output[] = $table[$uid];
 339         }
 340         return $output;
 341     }
 342
 343     /** Filter a list of profiles to extract the users matching the rule.
 344      */
 345     public function filterProfiles(array $profiles, $limit = null)
 346     {
 347         $limit = self::defaultLimit($limit);
 348         $this->requireProfiles();
 349         $this->buildQuery();
 350         $table = array();
 351         $pids  = array();
 352         foreach ($profiles as $profile) {
 353             if ($profile instanceof Profile) {
 354                 $pid = $profile->id();
 355             } else {
 356                 $pid = $profile;
 357             }
 358             $pids[] = $pid;
 359             $table[$pid] = $profile;
 360         }
 361         $fetched = $this->getPIDList($pids, $limit);
 362         $output = array();
 363         foreach ($fetched as $pid) {
 364             $output[] = $table[$pid];
 365         }
 366         return $output;
 367     }
 368
 369     public function getUIDs($limit = null)
 370     {
 371         $limit = self::defaultLimit($limit);
 372         return $this->getUIDList(null, $limit);
 373     }
 374
 375     public function getUID($pos = 0)
 376     {
 377         $uids =$this->getUIDList(null, new PlLimit(1, $pos));
 378         if (count($uids) == 0) {
 379             return null;
 380         } else {
 381             return $uids[0];
 382         }
 383     }
 384
 385     public function getPIDs($limit = null)
 386     {
 387         $limit = self::defaultLimit($limit);
 388         return $this->getPIDList(null, $limit);
 389     }
 390
 391     public function getPID($pos = 0)
 392     {
 393         $pids =$this->getPIDList(null, new PlLimit(1, $pos));
 394         if (count($pids) == 0) {
 395             return null;
 396         } else {
 397             return $pids[0];
 398         }
 399     }
 400
 401     public function getUsers($limit = null)
 402     {
 403         return User::getBulkUsersWithUIDs($this->getUIDs($limit));
 404     }
 405
 406     public function getUser($pos = 0)
 407     {
 408         $uid = $this->getUID($pos);
 409         if ($uid == null) {
 410             return null;
 411         } else {
 412             return User::getWithUID($uid);
 413         }
 414     }
 415
 416     public function iterUsers($limit = null)
 417     {
 418         return User::iterOverUIDs($this->getUIDs($limit));
 419     }
 420
 421     public function getProfiles($limit = null, $fields = 0x0000, $visibility = null)
 422     {
 423         return Profile::getBulkProfilesWithPIDs($this->getPIDs($limit), $fields, $visibility);
 424     }
 425
 426     public function getProfile($pos = 0, $fields = 0x0000, $visibility = null)
 427     {
 428         $pid = $this->getPID($pos);
 429         if ($pid == null) {
 430             return null;
 431         } else {
 432             return Profile::get($pid, $fields, $visibility);
 433         }
 434     }
 435
 436     public function iterProfiles($limit = null, $fields = 0x0000, $visibility = null)
 437     {
 438         return Profile::iterOverPIDs($this->getPIDs($limit), true, $fields, $visibility);
 439     }
 440
 441     public function get($limit = null)
 442     {
 443         return $this->getUsers($limit);
 444     }
 445
 446     public function getIds($limit = null)
 447     {
 448         return $this->getUIDs();
 449     }
 450
 451     public function getTotalCount()
 452     {
 453         return $this->getTotalUserCount();
 454     }
 455
 456     public function getTotalUserCount()
 457     {
 458         if (is_null($this->lastusercount)) {
 459             $this->requireAccounts();
 460             $this->buildQuery();
 461             return (int)XDB::rawFetchOneCell('SELECT  COUNT(DISTINCT a.uid)
 462                                           ' . $this->query);
 463         } else {
 464             return $this->lastusercount;
 465         }
 466     }
 467
 468     public function getTotalProfileCount()
 469     {
 470         if (is_null($this->lastprofilecount)) {
 471             $this->requireProfiles();
 472             $this->buildQuery();
 473             return (int)XDB::rawFetchOneCell('SELECT  COUNT(DISTINCT p.pid)
 474                                           ' . $this->query);
 475         } else {
 476             return $this->lastprofilecount;
 477         }
 478     }
 479
 480     public function setCondition(PlFilterCondition $cond)
 481     {
 482         $this->root =& $cond;
 483         $this->query = null;
 484     }
 485
 486     public function addSort(PlFilterOrder $sort)
 487     {
 488         if (count($this->sort) == 0 && $sort instanceof PlFilterGroupableOrder)
 489         {
 490             $this->grouper = $sort;
 491         }
 492         $this->sort[] = $sort;
 493         $this->orderby = null;
 494     }
 495
 496     public function export()
 497     {
 498         $export = array('conditions' => $this->root->export());
 499         if (!empty($this->sort)) {
 500             $export['sorts'] = array();
 501             foreach ($this->sort as $sort) {
 502                 $export['sorts'][] = $sort->export();
 503             }
 504         }
 505         return $export;
 506     }
 507
 508     public function exportConditions()
 509     {
 510         return $this->root->export();
 511     }
 512
 513     public static function fromExport(array $export)
 514     {
 515         $export = new PlDict($export);
 516         if (!$export->has('conditions')) {
 517             throw new Exception("Cannot build a user filter without conditions");
 518         }
 519         $cond = UserFilterCondition::fromExport($export->v('conditions'));
 520         $sorts = null;
 521         if ($export->has('sorts')) {
 522             $sorts = array();
 523             foreach ($export->v('sorts') as $sort) {
 524                 $sorts[] = UserFilterOrder::fromExport($sort);
 525             }
 526         }
 527         return new UserFilter($cond, $sorts);
 528     }
 529
 530     public static function fromJSon($json)
 531     {
 532         $export = json_decode($json, true);
 533         if (is_null($export)) {
 534             throw new Exception("Invalid json: $json");
 535         }
 536         return self::fromExport($json);
 537     }
 538
 539     public static function fromExportedConditions(array $export)
 540     {
 541         $cond = UserFilterCondition::fromExport($export);
 542         return new UserFilter($cond);
 543     }
 544
 545     public static function fromJSonConditions($json)
 546     {
 547         $export = json_decode($json, true);
 548         if (is_null($export)) {
 549             throw new Exception("Invalid json: $json");
 550         }
 551         return self::fromExportedConditions($json);
 552     }
 553
 554     static public function getLegacy($promo_min, $promo_max)
 555     {
 556         if ($promo_min != 0) {
 557             $min = new UFC_Promo('>=', self::GRADE_ING, intval($promo_min));
 558         } else {
 559             $min = new PFC_True();
 560         }
 561         if ($promo_max != 0) {
 562             $max = new UFC_Promo('<=', self::GRADE_ING, intval($promo_max));
 563         } else {
 564             $max = new PFC_True();
 565         }
 566         return new UserFilter(new PFC_And($min, $max));
 567     }
 568
 569     static public function sortByName()
 570     {
 571         return array(new UFO_Name());
 572     }
 573
 574     static public function sortByPromo()
 575     {
 576         return array(new UFO_Promo(), new UFO_Name());
 577     }
 578
 579     static private function getDBSuffix($string)
 580     {
 581         if (is_array($string)) {
 582             if (count($string) == 1) {
 583                 return self::getDBSuffix(array_pop($string));
 584             }
 585             return md5(implode('|', $string));
 586         } else {
 587             return preg_replace('/[^a-z0-9]/i', '', $string);
 588         }
 589     }
 590
 591
 592     /** Stores a new (and unique) table alias in the &$table table
 593      * @param   &$table Array in which the table alias must be stored
 594      * @param   $val    Value which will then be used to build the join
 595      * @return          Name of the newly created alias
 596      */
 597     private $option = 0;
 598     private function register_optional(array &$table, $val)
 599     {
 600         if (is_null($val)) {
 601             $sub   = $this->option++;
 602             $index = null;
 603         } else {
 604             $sub   = self::getDBSuffix($val);
 605             $index = $val;
 606         }
 607         $sub = '_' . $sub;
 608         $table[$sub] = $index;
 609         return $sub;
 610     }
 611
 612     /** PROFILE VS ACCOUNT
 613      */
 614     private $with_profiles  = false;
 615     private $with_accounts  = false;
 616     public function requireAccounts()
 617     {
 618         $this->with_accounts = true;
 619     }
 620
 621     public function accountsRequired()
 622     {
 623         return $this->with_accounts;
 624     }
 625
 626     public function requireProfiles()
 627     {
 628         $this->with_profiles = true;
 629     }
 630
 631     public function profilesRequired()
 632     {
 633         return $this->with_profiles;
 634     }
 635
 636     protected function accountJoins()
 637     {
 638         $joins = array();
 639         if ($this->with_profiles && $this->with_accounts) {
 640             $joins['ap'] = PlSqlJoin::left('account_profiles', '$ME.uid = $UID AND FIND_IN_SET(\'owner\', ap.perms)');
 641             $joins['p'] = PlSqlJoin::left('profiles', '$PID = ap.pid');
 642         }
 643         return $joins;
 644     }
 645
 646     /** PERMISSIONS
 647      */
 648     private $at = false;
 649     public function requirePerms()
 650     {
 651         $this->requireAccounts();
 652         $this->at = true;
 653         return 'at';
 654     }
 655
 656     protected function permJoins()
 657     {
 658         if ($this->at) {
 659             return array('at' => PlSqlJoin::left('account_types', '$ME.type = a.type'));
 660         } else {
 661             return array();
 662         }
 663     }
 664
 665     /** DISPLAY
 666      */
 667     const DISPLAY = 'display';
 668     private $pd = false;
 669     public function addDisplayFilter()
 670     {
 671         $this->requireProfiles();
 672         $this->pd = true;
 673         return '';
 674     }
 675
 676     protected function displayJoins()
 677     {
 678         if ($this->pd) {
 679             return array('pd' => PlSqlJoin::left('profile_display', '$ME.pid = $PID'));
 680         } else {
 681             return array();
 682         }
 683     }
 684
 685     /** LOGGER
 686      */
 687
 688     private $with_logger = false;
 689     public function addLoggerFilter()
 690     {
 691         $this->with_logger = true;
 692         $this->requireAccounts();
 693         return 'ls';
 694     }
 695     protected function loggerJoins()
 696     {
 697         $joins = array();
 698         if ($this->with_logger) {
 699             $joins['ls'] = PlSqlJoin::left('log_sessions', '$ME.uid = $UID');
 700         }
 701         return $joins;
 702     }
 703
 704     /** NAMETOKENS
 705      */
 706     private $name_tokens = array();
 707     private $nb_tokens = 0;
 708
 709     public function addNameTokensFilter($token)
 710     {
 711         $this->requireProfiles();
 712         $sub = 'sn' . (1 + $this->nb_tokens);
 713         $this->nb_tokens++;
 714         $this->name_tokens[$sub] = $token;
 715         return $sub;
 716     }
 717
 718     protected function nameTokensJoins()
 719     {
 720         /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
 721         $joins = array();
 722         foreach ($this->name_tokens as $sub => $token) {
 723             $joins[$sub] = PlSqlJoin::left('search_name', '$ME.pid = $PID');
 724         }
 725         return $joins;
 726     }
 727
 728     public function getNameTokens()
 729     {
 730         return $this->name_tokens;
 731     }
 732
 733     /** NATIONALITY
 734      */
 735
 736     private $with_nat = false;
 737     public function addNationalityFilter()
 738     {
 739         $this->with_nat = true;
 740         return 'ngc';
 741     }
 742
 743     protected function nationalityJoins()
 744     {
 745         $joins = array();
 746         if ($this->with_nat) {
 747             $joins['ngc'] = PlSqlJoin::left('geoloc_countries', '$ME.iso_3166_1_a2 = p.nationality1 OR $ME.iso_3166_1_a2 = p.nationality2 OR $ME.iso_3166_1_a2 = p.nationality3');
 748         }
 749         return $joins;
 750     }
 751
 752     /** EDUCATION
 753      */
 754     const GRADE_ING = Profile::DEGREE_X;
 755     const GRADE_PHD = Profile::DEGREE_D;
 756     const GRADE_MST = Profile::DEGREE_M;
 757     static public function isGrade($grade)
 758     {
 759         return ($grade !== 0) && ($grade == self::GRADE_ING || $grade == self::GRADE_PHD || $grade == self::GRADE_MST);
 760     }
 761
 762     static public function assertGrade($grade)
 763     {
 764         if (!self::isGrade($grade)) {
 765             Platal::page()->killError("Diplôme non valide: $grade");
 766         }
 767     }
 768
 769     static public function promoYear($grade)
 770     {
 771         // XXX: Definition of promotion for phds and masters might change in near future.
 772         return ($grade == UserFilter::GRADE_ING) ? 'entry_year' : 'grad_year';
 773     }
 774
 775     private $pepe     = array();
 776     private $with_pee = false;
 777     public function addEducationFilter($x = false, $grade = null)
 778     {
 779         $this->requireProfiles();
 780         if (!$x) {
 781             $index = $this->option;
 782             $sub   = $this->option++;
 783         } else {
 784             self::assertGrade($grade);
 785             $index = $grade;
 786             $sub   = $grade[0];
 787             $this->with_pee = true;
 788         }
 789         $sub = '_' . $sub;
 790         $this->pepe[$index] = $sub;
 791         return $sub;
 792     }
 793
 794     protected function educationJoins()
 795     {
 796         $joins = array();
 797         if ($this->with_pee) {
 798             $joins['pee'] = PlSqlJoin::inner('profile_education_enum', 'pee.abbreviation = \'X\'');
 799         }
 800         foreach ($this->pepe as $grade => $sub) {
 801             if ($this->isGrade($grade)) {
 802                 $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.eduid = pee.id AND $ME.pid = $PID');
 803                 $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.degree LIKE {?}', $grade);
 804             } else {
 805                 $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.pid = $PID');
 806                 $joins['pee' . $sub] = PlSqlJoin::inner('profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
 807                 $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
 808             }
 809         }
 810         return $joins;
 811     }
 812
 813
 814     /** GROUPS
 815      */
 816     private $gpm = array();
 817     public function addGroupFilter($group = null)
 818     {
 819         $this->requireAccounts();
 820         if (!is_null($group)) {
 821             if (is_int($group) || ctype_digit($group)) {
 822                 $index = $sub = $group;
 823             } else {
 824                 $index = $group;
 825                 $sub   = self::getDBSuffix($group);
 826             }
 827         } else {
 828             $sub = 'group_' . $this->option++;
 829             $index = null;
 830         }
 831         $sub = '_' . $sub;
 832         $this->gpm[$sub] = $index;
 833         return $sub;
 834     }
 835
 836     private $gpfm = array();
 837     public function addGroupFormerMemberFilter()
 838     {
 839         $this->requireAccounts();
 840         $sub = '_' . $this->option++;
 841         $this->gpfm[] = $sub;
 842         return $sub;
 843     }
 844
 845     protected function groupJoins()
 846     {
 847         $joins = array();
 848         foreach ($this->gpm as $sub => $key) {
 849             if (is_null($key)) {
 850                 $joins['gpa' . $sub] = PlSqlJoin::inner('groups');
 851                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
 852             } else if (is_int($key) || ctype_digit($key)) {
 853                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
 854             } else {
 855                 $joins['gpa' . $sub] = PlSqlJoin::inner('groups', '$ME.diminutif = {?}', $key);
 856                 $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
 857             }
 858         }
 859         foreach ($this->gpfm as $sub) {
 860             $joins['gpfm' . $sub] = PlSqlJoin::left('group_former_members', '$ME.uid = $UID');
 861         }
 862         return $joins;
 863     }
 864
 865     /** NLS
 866      */
 867     private $nls = array();
 868     public function addNewsLetterFilter($nlid)
 869     {
 870         $this->requireAccounts();
 871         $sub = 'nl_' . $nlid;
 872         $this->nls[$nlid] = $sub;
 873         return $sub;
 874     }
 875
 876     protected function newsLetterJoins()
 877     {
 878         $joins = array();
 879         foreach ($this->nls as $key => $sub) {
 880             $joins[$sub] = PlSqlJoin::left('newsletter_ins', '$ME.nlid = {?} AND $ME.uid = $UID', $key);
 881         }
 882         return $joins;
 883     }
 884
 885     /** BINETS
 886      */
 887
 888     private $with_bi = false;
 889     private $with_bd = false;
 890     public function addBinetsFilter($with_enum = false)
 891     {
 892         $this->requireProfiles();
 893         $this->with_bi = true;
 894         if ($with_enum) {
 895             $this->with_bd = true;
 896             return 'bd';
 897         } else {
 898             return 'bi';
 899         }
 900     }
 901
 902     protected function binetsJoins()
 903     {
 904         $joins = array();
 905         if ($this->with_bi) {
 906             $joins['bi'] = PlSqlJoin::left('profile_binets', '$ME.pid = $PID');
 907         }
 908         if ($this->with_bd) {
 909             $joins['bd'] = PlSqlJoin::left('profile_binet_enum', '$ME.id = bi.binet_id');
 910         }
 911         return $joins;
 912     }
 913
 914     /** EMAILS
 915      */
 916     private $ra = array();
 917     /** Allows filtering by redirection.
 918      * @param $email If null, enable a left join on the email redirection table
 919      *  (email_redirect_account); otherwise, perform a left join on users having
 920      *  that email as a redirection.
 921      * @return Suffix to use to access the adequate table.
 922      */
 923     public function addEmailRedirectFilter($email = null)
 924     {
 925         $this->requireAccounts();
 926         return $this->register_optional($this->ra, $email);
 927     }
 928
 929     const ALIAS_BEST      = 'bestalias';
 930     const ALIAS_FORLIFE   = 'forlife';
 931     const ALIAS_AUXILIARY = 'alias_aux';
 932     private $sa = array();
 933     /** Allows filtering by source email.
 934      * @param $email If null, enable a left join on the email source table
 935      *  (email_source_account); otherwise, perform a left join on users having
 936      *  that email as a source email.
 937      * @return Suffix to use to access the adequate table.
 938      */
 939     public function addAliasFilter($email = null)
 940     {
 941         $this->requireAccounts();
 942         return $this->register_optional($this->sa, $email);
 943     }
 944
 945     private $with_rf = false;
 946     /** Allows filtering by active redirection.
 947      * @return Suffix to use to access the adequate table.
 948      */
 949     public function addActiveEmailRedirectFilter($email = null)
 950     {
 951         $this->requireAccounts();
 952         $this->with_rf = true;
 953     }
 954
 955     protected function emailJoins()
 956     {
 957         global $globals;
 958         $joins = array();
 959         foreach ($this->ra as $sub => $redirections) {
 960             if (is_null($redirections)) {
 961                 $joins['ra' . $sub] = PlSqlJoin::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\'');
 962             } else {
 963                 if (!is_array($redirections)) {
 964                     $key = array($redirections);
 965                 }
 966                 $joins['ra' . $sub] = PlSqlJoin::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\'
 967                                                                                  AND $ME.redirect IN {?}', $redirections);
 968             }
 969         }
 970         foreach ($this->sa as $sub => $emails) {
 971             if (is_null($emails)) {
 972                 $joins['sa' . $sub] = PlSqlJoin::left('email_source_account', '$ME.uid = $UID');
 973             } else if ($sub == self::ALIAS_BEST) {
 974                 $joins['sa' . $sub] = PlSqlJoin::left('email_source_account', '$ME.uid = $UID AND FIND_IN_SET(\'bestalias\', $ME.flags)');
 975             } else if ($sub == self::ALIAS_FORLIFE) {
 976                 $joins['sa' . $sub] = PlSqlJoin::left('email_source_account', '$ME.uid = $UID AND $ME.type = \'forlife\'');
 977             } else if ($sub == self::ALIAS_AUXILIARY) {
 978                 $joins['sa' . $sub] = PlSqlJoin::left('email_source_account', '$ME.uid = $UID AND $ME.type = \'alias_aux\'');
 979             } else {
 980                 if (!is_array($emails)) {
 981                     $key = array($emails);
 982                 }
 983                 $joins['sa' . $sub] = PlSqlJoin::left('email_source_account', '$ME.uid = $UID AND $ME.email IN {?}', $emails);
 984             }
 985         }
 986         if ($this->with_rf) {
 987             $joins['rf'] = PlSqlJoin::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\' AND $ME.flags = \'active\'');;
 988         }
 989         return $joins;
 990     }
 991
 992
 993     /** ADDRESSES
 994      */
 995     private $types = array();
 996     public function addAddressFilter($type)
 997     {
 998         $this->requireProfiles();
 999         $this->with_pa = true;
1000
1001         $sub = '_' . $this->option++;
1002         $this->types[$type] = $sub;
1003         return $sub;
1004     }
1005
1006     protected function addressJoins()
1007     {
1008         $joins = array();
1009         foreach ($this->types as $type => $sub) {
1010             $joins['pa' . $sub] = PlSqlJoin::inner('profile_addresses', '$ME.pid = $PID');
1011             $joins['pac' . $sub] = PlSqlJoin::inner('profile_addresses_components',
1012                                                     '$ME.pid = pa' . $sub . '.pid AND $ME.jobid = pa' . $sub . '.jobid AND $ME.groupid = pa' . $sub . '.groupid AND $ME.type = pa' . $sub . '.type AND $ME.id = pa' . $sub . '.id');
1013             $joins['pace' . $sub] = PlSqlJoin::inner('profile_addresses_components_enum',
1014                                                      '$ME.id = pac' . $sub . '.component_id AND FIND_IN_SET({?}, $ME.types)', $type);
1015         }
1016
1017         return $joins;
1018     }
1019
1020
1021     /** CORPS
1022      */
1023
1024     private $pc = false;
1025     private $pce = array();
1026     private $pcr = false;
1027     public function addCorpsFilter($type)
1028     {
1029         $this->requireProfiles();
1030         $this->pc = true;
1031         if ($type == UFC_Corps::CURRENT) {
1032             $this->pce['pcec'] = 'current_corpsid';
1033             return 'pcec';
1034         } else if ($type == UFC_Corps::ORIGIN) {
1035             $this->pce['pceo'] = 'original_corpsid';
1036             return 'pceo';
1037         }
1038     }
1039
1040     public function addCorpsRankFilter()
1041     {
1042         $this->requireProfiles();
1043         $this->pc = true;
1044         $this->pcr = true;
1045         return 'pcr';
1046     }
1047
1048     protected function corpsJoins()
1049     {
1050         $joins = array();
1051         if ($this->pc) {
1052             $joins['pc'] = PlSqlJoin::left('profile_corps', '$ME.pid = $PID');
1053         }
1054         if ($this->pcr) {
1055             $joins['pcr'] = PlSqlJoin::left('profile_corps_rank_enum', '$ME.id = pc.rankid');
1056         }
1057         foreach($this->pce as $sub => $field) {
1058             $joins[$sub] = PlSqlJoin::left('profile_corps_enum', '$ME.id = pc.' . $field);
1059         }
1060         return $joins;
1061     }
1062
1063     /** JOBS
1064      */
1065
1066     const JOB_USERDEFINED = 0x0001;
1067     const JOB_CV          = 0x0002;
1068     const JOB_ANY         = 0x0003;
1069
1070     /** Joins :
1071      * pj => profile_job
1072      * pje => profile_job_enum
1073      * pjt => profile_job_terms
1074      */
1075     private $with_pj  = false;
1076     private $with_pje = false;
1077     private $with_pjt = 0;
1078
1079     public function addJobFilter()
1080     {
1081         $this->requireProfiles();
1082         $this->with_pj = true;
1083         return 'pj';
1084     }
1085
1086     public function addJobCompanyFilter()
1087     {
1088         $this->addJobFilter();
1089         $this->with_pje = true;
1090         return 'pje';
1091     }
1092
1093     /**
1094      * Adds a filter on job terms of profile.
1095      * @param $nb the number of job terms to use
1096      * @return an array of the fields to filter (one for each term).
1097      */
1098     public function addJobTermsFilter($nb = 1)
1099     {
1100         $this->with_pjt = $nb;
1101         $jobtermstable = array();
1102         for ($i = 1; $i <= $nb; ++$i) {
1103             $jobtermstable[] = 'pjtr_'.$i;
1104         }
1105         return $jobtermstable;
1106     }
1107
1108     protected function jobJoins()
1109     {
1110         $joins = array();
1111         if ($this->with_pj) {
1112             $joins['pj'] = PlSqlJoin::left('profile_job', '$ME.pid = $PID');
1113         }
1114         if ($this->with_pje) {
1115             $joins['pje'] = PlSqlJoin::left('profile_job_enum', '$ME.id = pj.jobid');
1116         }
1117         if ($this->with_pjt > 0) {
1118             for ($i = 1; $i <= $this->with_pjt; ++$i) {
1119                 $joins['pjt_'.$i] = PlSqlJoin::left('profile_job_term', '$ME.pid = $PID');
1120                 $joins['pjtr_'.$i] = PlSqlJoin::left('profile_job_term_relation', '$ME.jtid_2 = pjt_'.$i.'.jtid');
1121             }
1122         }
1123         return $joins;
1124     }
1125
1126     /** NETWORKING
1127      */
1128
1129     private $with_pnw = false;
1130     public function addNetworkingFilter()
1131     {
1132         $this->requireAccounts();
1133         $this->with_pnw = true;
1134         return 'pnw';
1135     }
1136
1137     protected function networkingJoins()
1138     {
1139         $joins = array();
1140         if ($this->with_pnw) {
1141             $joins['pnw'] = PlSqlJoin::left('profile_networking', '$ME.pid = $PID');
1142         }
1143         return $joins;
1144     }
1145
1146     /** PHONE
1147      */
1148
1149     private $with_ptel = false;
1150
1151     public function addPhoneFilter()
1152     {
1153         $this->requireAccounts();
1154         $this->with_ptel = true;
1155         return 'ptel';
1156     }
1157
1158     protected function phoneJoins()
1159     {
1160         $joins = array();
1161         if ($this->with_ptel) {
1162             $joins['ptel'] = PlSqlJoin::left('profile_phones', '$ME.pid = $PID');
1163         }
1164         return $joins;
1165     }
1166
1167     /** MEDALS
1168      */
1169
1170     private $with_pmed = false;
1171     public function addMedalFilter()
1172     {
1173         $this->requireProfiles();
1174         $this->with_pmed = true;
1175         return 'pmed';
1176     }
1177
1178     protected function medalJoins()
1179     {
1180         $joins = array();
1181         if ($this->with_pmed) {
1182             $joins['pmed'] = PlSqlJoin::left('profile_medals', '$ME.pid = $PID');
1183         }
1184         return $joins;
1185     }
1186
1187     /** DELTATEN
1188      */
1189     private $dts = array();
1190     const DELTATEN = 1;
1191     const DELTATEN_MESSAGE = 2;
1192     // TODO: terms
1193
1194     public function addDeltaTenFilter($type)
1195     {
1196         $this->requireProfiles();
1197         switch ($type) {
1198         case self::DELTATEN:
1199             $this->dts['pdt'] = 'profile_deltaten';
1200             return 'pdt';
1201         case self::DELTATEN_MESSAGE:
1202             $this->dts['pdtm'] = 'profile_deltaten';
1203             return 'pdtm';
1204         default:
1205             Platal::page()->killError("Undefined DeltaTen filter.");
1206         }
1207     }
1208
1209     protected function deltatenJoins()
1210     {
1211         $joins = array();
1212         foreach ($this->dts as $sub => $tab) {
1213             $joins[$sub] = PlSqlJoin::left($tab, '$ME.pid = $PID');
1214         }
1215         return $joins;
1216     }
1217
1218     /** MENTORING
1219      */
1220
1221     private $pms = array();
1222     private $mjtr = false;
1223     const MENTOR = 1;
1224     const MENTOR_EXPERTISE = 2;
1225     const MENTOR_COUNTRY = 3;
1226     const MENTOR_TERM = 4;
1227
1228     public function addMentorFilter($type)
1229     {
1230         $this->requireProfiles();
1231         switch($type) {
1232         case self::MENTOR:
1233             $this->pms['pm'] = 'profile_mentor';
1234             return 'pm';
1235         case self::MENTOR_EXPERTISE:
1236             $this->pms['pme'] = 'profile_mentor';
1237             return 'pme';
1238         case self::MENTOR_COUNTRY:
1239             $this->pms['pmc'] = 'profile_mentor_country';
1240             return 'pmc';
1241         case self::MENTOR_TERM:
1242             $this->pms['pmt'] = 'profile_mentor_term';
1243             $this->mjtr = true;
1244             return 'mjtr';
1245         default:
1246             Platal::page()->killError("Undefined mentor filter.");
1247         }
1248     }
1249
1250     protected function mentorJoins()
1251     {
1252         $joins = array();
1253         foreach ($this->pms as $sub => $tab) {
1254             $joins[$sub] = PlSqlJoin::left($tab, '$ME.pid = $PID');
1255         }
1256         if ($this->mjtr) {
1257             $joins['mjtr'] = PlSqlJoin::left('profile_job_term_relation', '$ME.jtid_2 = pmt.jtid');
1258         }
1259         return $joins;
1260     }
1261
1262     /** CONTACTS
1263      */
1264     private $cts = array();
1265     public function addContactFilter($uid = null)
1266     {
1267         $this->requireProfiles();
1268         return $this->register_optional($this->cts, is_null($uid) ? null : 'user_' . $uid);
1269     }
1270
1271     protected function contactJoins()
1272     {
1273         $joins = array();
1274         foreach ($this->cts as $sub=>$key) {
1275             if (is_null($key)) {
1276                 $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.contact = $PID');
1277             } else {
1278                 $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.uid = {?} AND $ME.contact = $PID', substr($key, 5));
1279             }
1280         }
1281         return $joins;
1282     }
1283
1284
1285     /** CARNET
1286      */
1287     private $wn = array();
1288     public function addWatchRegistrationFilter($uid = null)
1289     {
1290         $this->requireAccounts();
1291         return $this->register_optional($this->wn, is_null($uid) ? null : 'user_' . $uid);
1292     }
1293
1294     private $wp = array();
1295     public function addWatchPromoFilter($uid = null)
1296     {
1297         $this->requireAccounts();
1298         return $this->register_optional($this->wp, is_null($uid) ? null : 'user_' . $uid);
1299     }
1300
1301     private $w = array();
1302     public function addWatchFilter($uid = null)
1303     {
1304         $this->requireAccounts();
1305         return $this->register_optional($this->w, is_null($uid) ? null : 'user_' . $uid);
1306     }
1307
1308     protected function watchJoins()
1309     {
1310         $joins = array();
1311         foreach ($this->w as $sub=>$key) {
1312             if (is_null($key)) {
1313                 $joins['w' . $sub] = PlSqlJoin::left('watch');
1314             } else {
1315                 $joins['w' . $sub] = PlSqlJoin::left('watch', '$ME.uid = {?}', substr($key, 5));
1316             }
1317         }
1318         foreach ($this->wn as $sub=>$key) {
1319             if (is_null($key)) {
1320                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
1321             } else {
1322                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
1323             }
1324         }
1325         foreach ($this->wn as $sub=>$key) {
1326             if (is_null($key)) {
1327                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
1328             } else {
1329                 $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
1330             }
1331         }
1332         foreach ($this->wp as $sub=>$key) {
1333             if (is_null($key)) {
1334                 $joins['wp' . $sub] = PlSqlJoin::left('watch_promo');
1335             } else {
1336                 $joins['wp' . $sub] = PlSqlJoin::left('watch_promo', '$ME.uid = {?}', substr($key, 5));
1337             }
1338         }
1339         return $joins;
1340     }
1341
1342
1343     /** PHOTOS
1344      */
1345     private $with_photo;
1346     public function addPhotoFilter()
1347     {
1348         $this->requireProfiles();
1349         $this->with_photo = true;
1350         return 'photo';
1351     }
1352
1353     protected function photoJoins()
1354     {
1355         if ($this->with_photo) {
1356             return array('photo' => PlSqlJoin::left('profile_photos', '$ME.pid = $PID'));
1357         } else {
1358             return array();
1359         }
1360     }
1361
1362
1363     /** MARKETING
1364      */
1365     private $with_rm;
1366     public function addMarketingHash()
1367     {
1368         $this->requireAccounts();
1369         $this->with_rm = true;
1370     }
1371
1372     protected function marketingJoins()
1373     {
1374         if ($this->with_rm) {
1375             return array('rm' => PlSqlJoin::left('register_marketing', '$ME.uid = $UID'));
1376         } else {
1377             return array();
1378         }
1379     }
1380
1381
1382     /** PARTNER SHARING
1383      */
1384
1385     // Lists partner shortnames in use, as a $partner_shortname => true map.
1386     private $ppss = array();
1387
1388     /** Add a filter on user having settings for a given partner.
1389      * @param $partner_id the ID of the partner
1390      * @return the name of the table to use in joins (e.g ppss_$partner_id).
1391      */
1392     public function addPartnerSharingFilter($partner_id)
1393     {
1394         $this->requireProfiles();
1395         $sub = "ppss_" . $partner_id;
1396         $this->ppss[$sub] = $partner_id;
1397         return $sub;
1398     }
1399
1400     protected function partnerSharingJoins()
1401     {
1402         $joins = array();
1403         foreach ($this->ppss as $sub => $partner_id) {
1404             $joins[$sub] = PlSqlJoin::left('profile_partnersharing_settings', '$ME.pid = $PID AND $ME.partner_id = {?} AND $ME.sharing_level != \'none\'', $partner_id);
1405         }
1406         return $joins;
1407     }
1408
1409     public function restrictVisibilityForPartner($partner_id)
1410     {
1411         $sub = $this->addPartnerSharingFilter($partner_id);
1412         $this->visibility_field = $sub . '.sharing_level';
1413     }
1414
1415     /** VISIBILITY
1416      */
1417     private $vlevels = array();
1418     private $vfields = array();
1419     public function addVisibilityAbsoluteFilter($level)
1420     {
1421         $sub = 'pvel_' . $level;
1422         $this->vlevels[$level] = $sub;
1423         return $sub;
1424     }
1425
1426     public function addVisibilityFieldFilter($field)
1427     {
1428         $sub = 'pvef_' . self::getDBSuffix($field);
1429         $this->vfields[$field] = $sub;
1430         return $sub;
1431     }
1432
1433     /** Since this method might perform inner joins on tables which have been
1434      * joined previously (e.g when using addVisibilityFieldFilter), it has to
1435      * come after the Joins() methods for those tables.
1436      * This is due to the implementation logic for discovering joins and the
1437      * ordering used by PHP introspection.
1438      */
1439     protected function visibilityJoins()
1440     {
1441         $joins = array();
1442         foreach ($this->vlevels as $level => $sub) {
1443             $joins[$sub] = PlSqlJoin::inner('profile_visibility_enum', '$ME.access_level = {?}', $level);
1444         }
1445         foreach ($this->vfields as $field => $sub) {
1446             $joins[$sub] = PlSqlJoin::inner('profile_visibility_enum', '$ME.access_level = ' . $field);
1447         }
1448         return $joins;
1449     }
1450
1451 }
1452 // }}}
1453 // {{{ class ProfileFilter
1454 class ProfileFilter extends UserFilter
1455 {
1456     public function get($limit = null)
1457     {
1458         return $this->getProfiles($limit);
1459     }
1460
1461     public function getIds($limit = null)
1462     {
1463         return $this->getPIDs();
1464     }
1465
1466     public function filter(array $profiles, $limit = null)
1467     {
1468         return $this->filterProfiles($profiles, self::defaultLimit($limit));
1469     }
1470
1471     public function getTotalCount()
1472     {
1473         return $this->getTotalProfileCount();
1474     }
1475
1476     public function getGroups()
1477     {
1478         return $this->getPIDGroups();
1479     }
1480 }
1481 // }}}
1482
1483 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker fenc=utf-8:
1484 ?>