c46db70e428a57a220c53d2defb847f7a8223448
2 /***************************************************************************
3 * Copyright (C) 2003-2011 Polytechnique.org *
4 * http://opensource.polytechnique.org/ *
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. *
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. *
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 *
19 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
20 ***************************************************************************/
22 require_once dirname(__FILE__
) . '/userfilter/conditions.inc.php';
23 require_once dirname(__FILE__
) . '/userfilter/orders.inc.php';
25 /***********************************
26 *********************************
28 *********************************
29 ***********************************/
31 // {{{ class UserFilter
32 /** This class provides a convenient and centralized way of filtering users.
35 * $uf = new UserFilter(new UFC_Blah($x, $y), new UFO_Coin($z, $t));
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
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)
54 * In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
55 * profile.pid, and $UID with accounts.uid.
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.
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
67 * 'pj' => array('left', 'profile_job', '$ME.pid = $UID');
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.
72 class UserFilter
extends PlFilter
74 protected $joinMethods = array();
76 protected $joinMetas = array(
82 private $sort = array();
83 private $grouper = null
;
84 private $query = null
;
85 private $orderby = null
;
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
;
92 private $lastusercount = null
;
93 private $lastprofilecount = null
;
95 public function __construct($cond = null
, $sort = null
)
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;
106 if (!is_null($cond)) {
107 if ($cond instanceof PlFilterCondition
) {
108 $this->setCondition($cond);
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) {
121 // This will set the visibility to the default correct level.
122 $this->visibility
= Visibility
::defaultForRead();
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.
131 public function getVisibilityConditionForField($field)
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;
143 $sub = $this->addVisibilityAbsoluteFilter($this->visibility
->level());
144 return $sub . '.best_display_level + 0 <= 0 + ' . $field;
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.
152 public function getVisibilityConditionAbsolute($level)
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);
160 if ($this->visibility
->isVisible($level)) {
168 private function buildQuery()
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
),
178 if (is_null($this->orderby
)) {
180 foreach ($this->sort
as $sort) {
181 $orders = array_merge($orders, $sort->buildSort($this));
183 if (count($orders) == 0) {
186 $this->orderby
= 'ORDER BY ' . implode(', ', $orders);
188 $this->orderby
= str_replace(array_keys($this->joinMetas
),
192 if (is_null($this->query
)) {
193 if ($this->with_accounts
) {
194 $from = 'accounts AS a';
196 $this->requireProfiles();
197 $from = 'profiles AS p';
199 $joins = $this->buildJoins();
200 $this->query
= 'FROM ' . $from . '
202 WHERE (' . $where . ')';
206 public function hasGroups()
208 return $this->grouper
!= null
;
211 public function getGroups()
213 return $this->getUIDGroups();
216 public function getUIDGroups()
218 $this->requireAccounts();
220 $token = $this->grouper
->getGroupToken($this);
222 $groups = XDB
::rawFetchAllRow('SELECT ' . $token . ', COUNT(a.uid)
229 public function getPIDGroups()
231 $this->requireProfiles();
233 $token = $this->grouper
->getGroupToken($this);
235 $groups = XDB
::rawFetchAllRow('SELECT ' . $token . ', COUNT(p.pid)
242 private function getUIDList($uids = null
, PlLimit
$limit)
244 $this->requireAccounts();
246 $lim = $limit->getSql();
249 $cond = XDB
::format(' AND a.uid IN {?}', $uids);
251 $fetched = XDB
::rawFetchColumn('SELECT SQL_CALC_FOUND_ROWS a.uid
252 ' . $this->query
. $cond . '
254 ' . $this->orderby
. '
256 $this->lastusercount
= (int)XDB
::fetchOneCell('SELECT FOUND_ROWS()');
260 private function getPIDList($pids = null
, PlLimit
$limit)
262 $this->requireProfiles();
264 $lim = $limit->getSql();
266 if (!is_null($pids)) {
267 $cond = XDB
::format(' AND p.pid IN {?}', $pids);
269 $fetched = XDB
::rawFetchColumn('SELECT SQL_CALC_FOUND_ROWS p.pid
270 ' . $this->query
. $cond . '
272 ' . $this->orderby
. '
274 $this->lastprofilecount
= (int)XDB
::fetchOneCell('SELECT FOUND_ROWS()');
278 private static function defaultLimit($limit) {
279 if ($limit == null
) {
280 return new PlLimit();
286 /** Check that the user match the given rule.
288 public function checkUser(PlUser
$user)
290 $this->requireAccounts();
292 $count = (int)XDB
::rawFetchOneCell('SELECT COUNT(*)
294 . XDB
::format(' AND a.uid = {?}', $user->id()));
298 /** Check that the profile match the given rule.
300 public function checkProfile(Profile
$profile)
302 $this->requireProfiles();
304 $count = (int)XDB
::rawFetchOneCell('SELECT COUNT(*)
306 . XDB
::format(' AND p.pid = {?}', $profile->id()));
310 /** Default filter is on users
312 public function filter(array $users, $limit = null
)
314 return $this->filterUsers($users, self
::defaultLimit($limit));
317 /** Filter a list of users to extract the users matching the rule.
319 public function filterUsers(array $users, $limit = null
)
321 $limit = self
::defaultLimit($limit);
322 $this->requireAccounts();
326 foreach ($users as $user) {
327 if ($user instanceof PlUser
) {
333 $table[$uid] = $user;
335 $fetched = $this->getUIDList($uids, $limit);
337 foreach ($fetched as $uid) {
338 $output[] = $table[$uid];
343 /** Filter a list of profiles to extract the users matching the rule.
345 public function filterProfiles(array $profiles, $limit = null
)
347 $limit = self
::defaultLimit($limit);
348 $this->requireProfiles();
352 foreach ($profiles as $profile) {
353 if ($profile instanceof Profile
) {
354 $pid = $profile->id();
359 $table[$pid] = $profile;
361 $fetched = $this->getPIDList($pids, $limit);
363 foreach ($fetched as $pid) {
364 $output[] = $table[$pid];
369 public function getUIDs($limit = null
)
371 $limit = self
::defaultLimit($limit);
372 return $this->getUIDList(null
, $limit);
375 public function getUID($pos = 0)
377 $uids =$this->getUIDList(null
, new PlLimit(1, $pos));
378 if (count($uids) == 0) {
385 public function getPIDs($limit = null
)
387 $limit = self
::defaultLimit($limit);
388 return $this->getPIDList(null
, $limit);
391 public function getPID($pos = 0)
393 $pids =$this->getPIDList(null
, new PlLimit(1, $pos));
394 if (count($pids) == 0) {
401 public function getUsers($limit = null
)
403 return User
::getBulkUsersWithUIDs($this->getUIDs($limit));
406 public function getUser($pos = 0)
408 $uid = $this->getUID($pos);
412 return User
::getWithUID($uid);
416 public function iterUsers($limit = null
)
418 return User
::iterOverUIDs($this->getUIDs($limit));
421 public function getProfiles($limit = null
, $fields = 0x0000, $visibility = null
)
423 return Profile
::getBulkProfilesWithPIDs($this->getPIDs($limit), $fields, $visibility);
426 public function getProfile($pos = 0, $fields = 0x0000, $visibility = null
)
428 $pid = $this->getPID($pos);
432 return Profile
::get($pid, $fields, $visibility);
436 public function iterProfiles($limit = null
, $fields = 0x0000, $visibility = null
)
438 return Profile
::iterOverPIDs($this->getPIDs($limit), true
, $fields, $visibility);
441 public function get($limit = null
)
443 return $this->getUsers($limit);
446 public function getIds($limit = null
)
448 return $this->getUIDs();
451 public function getTotalCount()
453 return $this->getTotalUserCount();
456 public function getTotalUserCount()
458 if (is_null($this->lastusercount
)) {
459 $this->requireAccounts();
461 return (int)XDB
::rawFetchOneCell('SELECT COUNT(DISTINCT a.uid)
464 return $this->lastusercount
;
468 public function getTotalProfileCount()
470 if (is_null($this->lastprofilecount
)) {
471 $this->requireProfiles();
473 return (int)XDB
::rawFetchOneCell('SELECT COUNT(DISTINCT p.pid)
476 return $this->lastprofilecount
;
480 public function setCondition(PlFilterCondition
$cond)
482 $this->root
=& $cond;
486 public function addSort(PlFilterOrder
$sort)
488 if (count($this->sort
) == 0 && $sort instanceof PlFilterGroupableOrder
)
490 $this->grouper
= $sort;
492 $this->sort
[] = $sort;
493 $this->orderby
= null
;
496 public function export()
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();
508 public function exportConditions()
510 return $this->root
->export();
513 public static function fromExport(array $export)
515 $export = new PlDict($export);
516 if (!$export->has('conditions')) {
517 throw new Exception("Cannot build a user filter without conditions");
519 $cond = UserFilterCondition
::fromExport($export->v('conditions'));
521 if ($export->has('sorts')) {
523 foreach ($export->v('sorts') as $sort) {
524 $sorts[] = UserFilterOrder
::fromExport($sort);
527 return new UserFilter($cond, $sorts);
530 public static function fromJSon($json)
532 $export = json_decode($json, true
);
533 if (is_null($export)) {
534 throw new Exception("Invalid json: $json");
536 return self
::fromExport($json);
539 public static function fromExportedConditions(array $export)
541 $cond = UserFilterCondition
::fromExport($export);
542 return new UserFilter($cond);
545 public static function fromJSonConditions($json)
547 $export = json_decode($json, true
);
548 if (is_null($export)) {
549 throw new Exception("Invalid json: $json");
551 return self
::fromExportedConditions($json);
554 static public function getLegacy($promo_min, $promo_max)
556 if ($promo_min != 0) {
557 $min = new UFC_Promo('>=', self
::GRADE_ING
, intval($promo_min));
559 $min = new PFC_True();
561 if ($promo_max != 0) {
562 $max = new UFC_Promo('<=', self
::GRADE_ING
, intval($promo_max));
564 $max = new PFC_True();
566 return new UserFilter(new PFC_And($min, $max));
569 static public function sortByName()
571 return array(new UFO_Name());
574 static public function sortByPromo()
576 return array(new UFO_Promo(), new UFO_Name());
579 static private function getDBSuffix($string)
581 if (is_array($string)) {
582 if (count($string) == 1) {
583 return self
::getDBSuffix(array_pop($string));
585 return md5(implode('|', $string));
587 return preg_replace('/[^a-z0-9]/i', '', $string);
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
598 private function register_optional(array &$table, $val)
601 $sub = $this->option++
;
604 $sub = self
::getDBSuffix($val);
608 $table[$sub] = $index;
612 /** PROFILE VS ACCOUNT
614 private $with_profiles = false
;
615 private $with_accounts = false
;
616 public function requireAccounts()
618 $this->with_accounts
= true
;
621 public function accountsRequired()
623 return $this->with_accounts
;
626 public function requireProfiles()
628 $this->with_profiles
= true
;
631 public function profilesRequired()
633 return $this->with_profiles
;
636 protected function accountJoins()
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');
648 private $vlevels = array();
649 private $vfields = array();
650 public function addVisibilityAbsoluteFilter($level)
652 $sub = 'pvel_' . $level;
653 $this->vlevels
[$level] = $sub;
657 public function addVisibilityFieldFilter($field)
659 $sub = 'pvef_' . self
::getDBSuffix($field);
660 $this->vfields
[$field] = $sub;
664 protected function visibilityJoins()
667 foreach ($this->vlevels
as $level => $sub) {
668 $joins[$sub] = PlSqlJoin
::inner('profile_visibility_enum', '$ME.access_level = {?}', $level);
670 foreach ($this->vfields
as $field => $sub) {
671 $joins[$sub] = PlSqlJoin
::inner('profile_visibility_enum', '$ME.access_level = ' . $field);
679 public function requirePerms()
681 $this->requireAccounts();
686 protected function permJoins()
689 return array('at' => PlSqlJoin
::left('account_types', '$ME.type = a.type'));
697 const DISPLAY
= 'display';
699 public function addDisplayFilter()
701 $this->requireProfiles();
706 protected function displayJoins()
709 return array('pd' => PlSqlJoin
::left('profile_display', '$ME.pid = $PID'));
718 private $with_logger = false
;
719 public function addLoggerFilter()
721 $this->with_logger
= true
;
722 $this->requireAccounts();
725 protected function loggerJoins()
728 if ($this->with_logger
) {
729 $joins['ls'] = PlSqlJoin
::left('log_sessions', '$ME.uid = $UID');
736 private $name_tokens = array();
737 private $nb_tokens = 0;
739 public function addNameTokensFilter($token)
741 $this->requireProfiles();
742 $sub = 'sn' . (1 +
$this->nb_tokens
);
744 $this->name_tokens
[$sub] = $token;
748 protected function nameTokensJoins()
750 /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
752 foreach ($this->name_tokens
as $sub => $token) {
753 $joins[$sub] = PlSqlJoin
::left('search_name', '$ME.pid = $PID');
758 public function getNameTokens()
760 return $this->name_tokens
;
766 private $with_nat = false
;
767 public function addNationalityFilter()
769 $this->with_nat
= true
;
773 protected function nationalityJoins()
776 if ($this->with_nat
) {
777 $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');
784 const GRADE_ING
= Profile
::DEGREE_X
;
785 const GRADE_PHD
= Profile
::DEGREE_D
;
786 const GRADE_MST
= Profile
::DEGREE_M
;
787 static public function isGrade($grade)
789 return ($grade !== 0) && ($grade == self
::GRADE_ING ||
$grade == self
::GRADE_PHD ||
$grade == self
::GRADE_MST
);
792 static public function assertGrade($grade)
794 if (!self
::isGrade($grade)) {
795 Platal
::page()->killError("Diplôme non valide: $grade");
799 static public function promoYear($grade)
801 // XXX: Definition of promotion for phds and masters might change in near future.
802 return ($grade == UserFilter
::GRADE_ING
) ?
'entry_year' : 'grad_year';
805 private $pepe = array();
806 private $with_pee = false
;
807 public function addEducationFilter($x = false
, $grade = null
)
809 $this->requireProfiles();
811 $index = $this->option
;
812 $sub = $this->option++
;
814 self
::assertGrade($grade);
817 $this->with_pee
= true
;
820 $this->pepe
[$index] = $sub;
824 protected function educationJoins()
827 if ($this->with_pee
) {
828 $joins['pee'] = PlSqlJoin
::inner('profile_education_enum', 'pee.abbreviation = \'X\'');
830 foreach ($this->pepe
as $grade => $sub) {
831 if ($this->isGrade($grade)) {
832 $joins['pe' . $sub] = PlSqlJoin
::left('profile_education', '$ME.eduid = pee.id AND $ME.pid = $PID');
833 $joins['pede' . $sub] = PlSqlJoin
::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.degree LIKE {?}', $grade);
835 $joins['pe' . $sub] = PlSqlJoin
::left('profile_education', '$ME.pid = $PID');
836 $joins['pee' . $sub] = PlSqlJoin
::inner('profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
837 $joins['pede' . $sub] = PlSqlJoin
::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
846 private $gpm = array();
847 public function addGroupFilter($group = null
)
849 $this->requireAccounts();
850 if (!is_null($group)) {
851 if (is_int($group) ||
ctype_digit($group)) {
852 $index = $sub = $group;
855 $sub = self
::getDBSuffix($group);
858 $sub = 'group_' . $this->option++
;
862 $this->gpm
[$sub] = $index;
866 private $gpfm = array();
867 public function addGroupFormerMemberFilter()
869 $this->requireAccounts();
870 $sub = '_' . $this->option++
;
871 $this->gpfm
[] = $sub;
875 protected function groupJoins()
878 foreach ($this->gpm
as $sub => $key) {
880 $joins['gpa' . $sub] = PlSqlJoin
::inner('groups');
881 $joins['gpm' . $sub] = PlSqlJoin
::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
882 } else if (is_int($key) ||
ctype_digit($key)) {
883 $joins['gpm' . $sub] = PlSqlJoin
::left('group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
885 $joins['gpa' . $sub] = PlSqlJoin
::inner('groups', '$ME.diminutif = {?}', $key);
886 $joins['gpm' . $sub] = PlSqlJoin
::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
889 foreach ($this->gpfm
as $sub) {
890 $joins['gpfm' . $sub] = PlSqlJoin
::left('group_former_members', '$ME.uid = $UID');
897 private $nls = array();
898 public function addNewsLetterFilter($nlid)
900 $this->requireAccounts();
901 $sub = 'nl_' . $nlid;
902 $this->nls
[$nlid] = $sub;
906 protected function newsLetterJoins()
909 foreach ($this->nls
as $key => $sub) {
910 $joins[$sub] = PlSqlJoin
::left('newsletter_ins', '$ME.nlid = {?} AND $ME.uid = $UID', $key);
918 private $with_bi = false
;
919 private $with_bd = false
;
920 public function addBinetsFilter($with_enum = false
)
922 $this->requireProfiles();
923 $this->with_bi
= true
;
925 $this->with_bd
= true
;
932 protected function binetsJoins()
935 if ($this->with_bi
) {
936 $joins['bi'] = PlSqlJoin
::left('profile_binets', '$ME.pid = $PID');
938 if ($this->with_bd
) {
939 $joins['bd'] = PlSqlJoin
::left('profile_binet_enum', '$ME.id = bi.binet_id');
946 private $ra = array();
947 /** Allows filtering by redirection.
948 * @param $email If null, enable a left join on the email redirection table
949 * (email_redirect_account); otherwise, perform a left join on users having
950 * that email as a redirection.
951 * @return Suffix to use to access the adequate table.
953 public function addEmailRedirectFilter($email = null
)
955 $this->requireAccounts();
956 return $this->register_optional($this->ra
, $email);
959 const ALIAS_BEST
= 'bestalias';
960 const ALIAS_FORLIFE
= 'forlife';
961 const ALIAS_AUXILIARY
= 'alias_aux';
962 private $sa = array();
963 /** Allows filtering by source email.
964 * @param $email If null, enable a left join on the email source table
965 * (email_source_account); otherwise, perform a left join on users having
966 * that email as a source email.
967 * @return Suffix to use to access the adequate table.
969 public function addAliasFilter($email = null
)
971 $this->requireAccounts();
972 return $this->register_optional($this->sa
, $email);
975 private $with_rf = false
;
976 /** Allows filtering by active redirection.
977 * @return Suffix to use to access the adequate table.
979 public function addActiveEmailRedirectFilter($email = null
)
981 $this->requireAccounts();
982 $this->with_rf
= true
;
985 protected function emailJoins()
989 foreach ($this->ra
as $sub => $redirections) {
990 if (is_null($redirections)) {
991 $joins['ra' . $sub] = PlSqlJoin
::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\'');
993 if (!is_array($redirections)) {
994 $key = array($redirections);
996 $joins['ra' . $sub] = PlSqlJoin
::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\'
997 AND $ME.redirect IN {?}', $redirections);
1000 foreach ($this->sa
as $sub => $emails) {
1001 if (is_null($emails)) {
1002 $joins['sa' . $sub] = PlSqlJoin
::left('email_source_account', '$ME.uid = $UID');
1003 } else if ($sub == self
::ALIAS_BEST
) {
1004 $joins['sa' . $sub] = PlSqlJoin
::left('email_source_account', '$ME.uid = $UID AND FIND_IN_SET(\'bestalias\', $ME.flags)');
1005 } else if ($sub == self
::ALIAS_FORLIFE
) {
1006 $joins['sa' . $sub] = PlSqlJoin
::left('email_source_account', '$ME.uid = $UID AND $ME.type = \'forlife\'');
1007 } else if ($sub == self
::ALIAS_AUXILIARY
) {
1008 $joins['sa' . $sub] = PlSqlJoin
::left('email_source_account', '$ME.uid = $UID AND $ME.type = \'alias_aux\'');
1010 if (!is_array($emails)) {
1011 $key = array($emails);
1013 $joins['sa' . $sub] = PlSqlJoin
::left('email_source_account', '$ME.uid = $UID AND $ME.email IN {?}', $emails);
1016 if ($this->with_rf
) {
1017 $joins['rf'] = PlSqlJoin
::left('email_redirect_account', '$ME.uid = $UID AND $ME.type != \'imap\' AND $ME.flags = \'active\'');;
1025 private $types = array();
1026 public function addAddressFilter($type)
1028 $this->requireProfiles();
1029 $this->with_pa
= true
;
1031 $sub = '_' . $this->option++
;
1032 $this->types
[$type] = $sub;
1036 protected function addressJoins()
1039 foreach ($this->types
as $type => $sub) {
1040 $joins['pa' . $sub] = PlSqlJoin
::inner('profile_addresses', '$ME.pid = $PID');
1041 $joins['pac' . $sub] = PlSqlJoin
::inner('profile_addresses_components',
1042 '$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');
1043 $joins['pace' . $sub] = PlSqlJoin
::inner('profile_addresses_components_enum',
1044 '$ME.id = pac' . $sub . '.component_id AND FIND_IN_SET({?}, $ME.types)', $type);
1054 private $pc = false
;
1055 private $pce = array();
1056 private $pcr = false
;
1057 public function addCorpsFilter($type)
1059 $this->requireProfiles();
1061 if ($type == UFC_Corps
::CURRENT
) {
1062 $this->pce
['pcec'] = 'current_corpsid';
1064 } else if ($type == UFC_Corps
::ORIGIN
) {
1065 $this->pce
['pceo'] = 'original_corpsid';
1070 public function addCorpsRankFilter()
1072 $this->requireProfiles();
1078 protected function corpsJoins()
1082 $joins['pc'] = PlSqlJoin
::left('profile_corps', '$ME.pid = $PID');
1085 $joins['pcr'] = PlSqlJoin
::left('profile_corps_rank_enum', '$ME.id = pc.rankid');
1087 foreach($this->pce
as $sub => $field) {
1088 $joins[$sub] = PlSqlJoin
::left('profile_corps_enum', '$ME.id = pc.' . $field);
1096 const JOB_USERDEFINED
= 0x0001;
1097 const JOB_CV
= 0x0002;
1098 const JOB_ANY
= 0x0003;
1102 * pje => profile_job_enum
1103 * pjt => profile_job_terms
1105 private $with_pj = false
;
1106 private $with_pje = false
;
1107 private $with_pjt = 0;
1109 public function addJobFilter()
1111 $this->requireProfiles();
1112 $this->with_pj
= true
;
1116 public function addJobCompanyFilter()
1118 $this->addJobFilter();
1119 $this->with_pje
= true
;
1124 * Adds a filter on job terms of profile.
1125 * @param $nb the number of job terms to use
1126 * @return an array of the fields to filter (one for each term).
1128 public function addJobTermsFilter($nb = 1)
1130 $this->with_pjt
= $nb;
1131 $jobtermstable = array();
1132 for ($i = 1; $i <= $nb; ++
$i) {
1133 $jobtermstable[] = 'pjtr_'.$i;
1135 return $jobtermstable;
1138 protected function jobJoins()
1141 if ($this->with_pj
) {
1142 $joins['pj'] = PlSqlJoin
::left('profile_job', '$ME.pid = $PID');
1144 if ($this->with_pje
) {
1145 $joins['pje'] = PlSqlJoin
::left('profile_job_enum', '$ME.id = pj.jobid');
1147 if ($this->with_pjt
> 0) {
1148 for ($i = 1; $i <= $this->with_pjt
; ++
$i) {
1149 $joins['pjt_'.$i] = PlSqlJoin
::left('profile_job_term', '$ME.pid = $PID');
1150 $joins['pjtr_'.$i] = PlSqlJoin
::left('profile_job_term_relation', '$ME.jtid_2 = pjt_'.$i.'.jtid');
1159 private $with_pnw = false
;
1160 public function addNetworkingFilter()
1162 $this->requireAccounts();
1163 $this->with_pnw
= true
;
1167 protected function networkingJoins()
1170 if ($this->with_pnw
) {
1171 $joins['pnw'] = PlSqlJoin
::left('profile_networking', '$ME.pid = $PID');
1179 private $with_ptel = false
;
1181 public function addPhoneFilter()
1183 $this->requireAccounts();
1184 $this->with_ptel
= true
;
1188 protected function phoneJoins()
1191 if ($this->with_ptel
) {
1192 $joins['ptel'] = PlSqlJoin
::left('profile_phones', '$ME.pid = $PID');
1200 private $with_pmed = false
;
1201 public function addMedalFilter()
1203 $this->requireProfiles();
1204 $this->with_pmed
= true
;
1208 protected function medalJoins()
1211 if ($this->with_pmed
) {
1212 $joins['pmed'] = PlSqlJoin
::left('profile_medals', '$ME.pid = $PID');
1219 private $dts = array();
1221 const DELTATEN_MESSAGE
= 2;
1224 public function addDeltaTenFilter($type)
1226 $this->requireProfiles();
1228 case self
::DELTATEN
:
1229 $this->dts
['pdt'] = 'profile_deltaten';
1231 case self
::DELTATEN_MESSAGE
:
1232 $this->dts
['pdtm'] = 'profile_deltaten';
1235 Platal
::page()->killError("Undefined DeltaTen filter.");
1239 protected function deltatenJoins()
1242 foreach ($this->dts
as $sub => $tab) {
1243 $joins[$sub] = PlSqlJoin
::left($tab, '$ME.pid = $PID');
1251 private $pms = array();
1252 private $mjtr = false
;
1254 const MENTOR_EXPERTISE
= 2;
1255 const MENTOR_COUNTRY
= 3;
1256 const MENTOR_TERM
= 4;
1258 public function addMentorFilter($type)
1260 $this->requireProfiles();
1263 $this->pms
['pm'] = 'profile_mentor';
1265 case self
::MENTOR_EXPERTISE
:
1266 $this->pms
['pme'] = 'profile_mentor';
1268 case self
::MENTOR_COUNTRY
:
1269 $this->pms
['pmc'] = 'profile_mentor_country';
1271 case self
::MENTOR_TERM
:
1272 $this->pms
['pmt'] = 'profile_mentor_term';
1276 Platal
::page()->killError("Undefined mentor filter.");
1280 protected function mentorJoins()
1283 foreach ($this->pms
as $sub => $tab) {
1284 $joins[$sub] = PlSqlJoin
::left($tab, '$ME.pid = $PID');
1287 $joins['mjtr'] = PlSqlJoin
::left('profile_job_term_relation', '$ME.jtid_2 = pmt.jtid');
1294 private $cts = array();
1295 public function addContactFilter($uid = null
)
1297 $this->requireProfiles();
1298 return $this->register_optional($this->cts
, is_null($uid) ? null
: 'user_' . $uid);
1301 protected function contactJoins()
1304 foreach ($this->cts
as $sub=>$key) {
1305 if (is_null($key)) {
1306 $joins['c' . $sub] = PlSqlJoin
::left('contacts', '$ME.contact = $PID');
1308 $joins['c' . $sub] = PlSqlJoin
::left('contacts', '$ME.uid = {?} AND $ME.contact = $PID', substr($key, 5));
1317 private $wn = array();
1318 public function addWatchRegistrationFilter($uid = null
)
1320 $this->requireAccounts();
1321 return $this->register_optional($this->wn
, is_null($uid) ? null
: 'user_' . $uid);
1324 private $wp = array();
1325 public function addWatchPromoFilter($uid = null
)
1327 $this->requireAccounts();
1328 return $this->register_optional($this->wp
, is_null($uid) ? null
: 'user_' . $uid);
1331 private $w = array();
1332 public function addWatchFilter($uid = null
)
1334 $this->requireAccounts();
1335 return $this->register_optional($this->w
, is_null($uid) ? null
: 'user_' . $uid);
1338 protected function watchJoins()
1341 foreach ($this->w
as $sub=>$key) {
1342 if (is_null($key)) {
1343 $joins['w' . $sub] = PlSqlJoin
::left('watch');
1345 $joins['w' . $sub] = PlSqlJoin
::left('watch', '$ME.uid = {?}', substr($key, 5));
1348 foreach ($this->wn
as $sub=>$key) {
1349 if (is_null($key)) {
1350 $joins['wn' . $sub] = PlSqlJoin
::left('watch_nonins', '$ME.ni_id = $UID');
1352 $joins['wn' . $sub] = PlSqlJoin
::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
1355 foreach ($this->wn
as $sub=>$key) {
1356 if (is_null($key)) {
1357 $joins['wn' . $sub] = PlSqlJoin
::left('watch_nonins', '$ME.ni_id = $UID');
1359 $joins['wn' . $sub] = PlSqlJoin
::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
1362 foreach ($this->wp
as $sub=>$key) {
1363 if (is_null($key)) {
1364 $joins['wp' . $sub] = PlSqlJoin
::left('watch_promo');
1366 $joins['wp' . $sub] = PlSqlJoin
::left('watch_promo', '$ME.uid = {?}', substr($key, 5));
1375 private $with_photo;
1376 public function addPhotoFilter()
1378 $this->requireProfiles();
1379 $this->with_photo
= true
;
1383 protected function photoJoins()
1385 if ($this->with_photo
) {
1386 return array('photo' => PlSqlJoin
::left('profile_photos', '$ME.pid = $PID'));
1396 public function addMarketingHash()
1398 $this->requireAccounts();
1399 $this->with_rm
= true
;
1402 protected function marketingJoins()
1404 if ($this->with_rm
) {
1405 return array('rm' => PlSqlJoin
::left('register_marketing', '$ME.uid = $UID'));
1415 // Lists partner shortnames in use, as a $partner_shortname => true map.
1416 private $ppss = array();
1418 /** Add a filter on user having settings for a given partner.
1419 * @param $partner_id the ID of the partner
1420 * @return the name of the table to use in joins (e.g ppss_$partner_id).
1422 public function addPartnerSharingFilter($partner_id)
1424 $this->requireProfiles();
1425 $sub = "ppss_$partner_id";
1426 $this->ppss
[$sub] = $partner_id;
1430 protected function partnerSharingJoins()
1433 foreach ($this->ppss
as $sub => $partner_id) {
1434 $joins[$sub] = PlSqlJoin
::left('profile_partnersharing_settings', '$ME.pid = $PID AND $ME.partner_id = {?} AND $ME.sharing_level != \'none\'', $partner_id);
1439 public function restrictVisibilityForPartner($partner_id)
1441 $sub = $this->addPartnerSharingFilter($partner_id);
1442 $this->visibility_field
= $sub . '.sharing_level';
1446 // {{{ class ProfileFilter
1447 class ProfileFilter
extends UserFilter
1449 public function get($limit = null
)
1451 return $this->getProfiles($limit);
1454 public function getIds($limit = null
)
1456 return $this->getPIDs();
1459 public function filter(array $profiles, $limit = null
)
1461 return $this->filterProfiles($profiles, self
::defaultLimit($limit));
1464 public function getTotalCount()
1466 return $this->getTotalProfileCount();
1469 public function getGroups()
1471 return $this->getPIDGroups();
1476 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8: