2 /***************************************************************************
3 * Copyright (C) 2003-2014 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 // {{{ abstract class UserFilterCondition
23 /** This class describe objects which filter users based
24 * on various parameters.
25 * The parameters of the filter must be given to the constructor.
26 * The buildCondition function is called by UserFilter when
27 * actually building the query. That function must call
28 * $uf->addWheteverFilter so that the UserFilter makes
29 * adequate joins. It must return the 'WHERE' condition to use
32 abstract class UserFilterCondition
implements PlFilterCondition
34 const OP_EQUALS
= '=';
35 const OP_GREATER
= '>';
36 const OP_NOTGREATER
= '<=';
37 const OP_LESSER
= '<';
38 const OP_NOTLESSER
= '>=';
39 const OP_NULL
= 'null';
40 const OP_NOTNULL
= 'not null';
41 const OP_CONTAINS
= 'contains';
42 const OP_PREFIX
= 'prefix';
43 const OP_SUFFIX
= 'suffix';
45 protected function buildExport($type)
47 $export = array('type' => $type);
51 public function export()
53 throw new Exception("This class is not exportable");
56 public static function comparisonFromXDBWildcard($wildcard)
59 case XDB
::WILDCARD_EXACT
:
60 return self
::OP_EQUALS
;
61 case XDB
::WILDCARD_PREFIX
:
62 return self
::OP_PREFIX
;
63 case XDB
::WILDCARD_SUFFIX
:
64 return self
::OP_SUFFIX
;
65 case XDB
::WILDCARD_CONTAINS
:
66 return self
::OP_CONTAINS
;
68 throw new Exception("Unknown wildcard mode: $wildcard");
71 public static function xdbWildcardFromComparison($comparison)
73 if (!self
::isStringComparison($comparison)) {
74 throw new Exception("Unknown string comparison: $comparison");
76 switch ($comparison) {
78 return XDB
::WILDCARD_EXACT
;
80 return XDB
::WILDCARD_PREFIX
;
82 return XDB
::WILDCARD_SUFFIX
;
83 case self
::OP_CONTAINS
:
84 return XDB
::WILDCARD_CONTAINS
;
88 private static function isNumericComparison($comparison)
90 return $comparison == self
::OP_EQUALS
91 ||
$comparison == self
::OP_GREATER
92 ||
$comparison == self
::OP_NOTGREATER
93 ||
$comparison == self
::OP_LESSER
94 ||
$comparison == self
::OP_NOTLESSER
;
97 private static function isStringComparison($comparison)
99 return $comparison == self
::OP_EQUALS
100 ||
$comparison == self
::OP_CONTAINS
101 ||
$comparison == self
::OP_PREFIX
102 ||
$comparison == self
::OP_SUFFIX
;
105 public static function fromExport(array $export)
107 $export = new PlDict($export);
108 if (!$export->has('type')) {
109 throw new Exception("Missing type in export");
111 $type = $export->s('type');
119 $class = 'pfc_' . $type;
120 $cond = new $class();
124 if ($export->has('ip')) {
125 $cond = new UFC_Ip($export->s('ip'));
130 if ($export->has('text') && $export->s('comparison') == self
::OP_CONTAINS
) {
131 $cond = new UFC_Comment($export->s('text'));
136 if ($export->has('promo') && self
::isNumericComparison($export->s('comparison'))) {
137 $cond = new UFC_Promo($export->s('comparison'),
138 $export->s('grade', UserFilter
::DISPLAY
),
139 $export->s('promo'));
148 if ($export->has('text')) {
149 $flag = self
::xdbWildcardFromComparison($export->s('comparison'));
150 if ($export->b('search_in_variants')) {
151 $flag |
= UFC_Name
::VARIANTS
;
153 if ($export->b('search_in_particle')) {
154 $flag |
= UFC_Name
::PARTICLE
;
156 $cond = new UFC_Name($type, $export->s('text'), $flag);
164 $values = $export->v('values', array());
165 $class = 'ufc_' . str_replace('_', '', $type);
166 $cond = new $class($values);
170 $values = $export->v('values', array());
171 $school_type = $export->s('school_type');
172 $cond = new UFC_SchoolId($school_type, $values);
176 case 'has_email_redirect':
177 case 'has_valid_email':
178 $class = 'ufc_' . str_replace('_', '', $type);
179 $cond = new $class();
183 throw new Exception("Unknown condition type: $type");
185 if (is_null($cond)) {
186 throw new Exception("Unsupported $type definition");
188 if ($cond instanceof PFC_NChildren
) {
189 $children = $export->v('children', array());
190 foreach ($children as $child) {
191 $cond->addChild(self
::fromExport($child));
193 } else if ($cond instanceof PFC_OneChild
) {
194 if ($export->has('child')) {
195 $cond->setChild(self
::fromExport($export->v('child')));
202 // {{{ class UFC_HasProfile
203 /** Filters users who have a profile
205 class UFC_HasProfile
extends UserFilterCondition
207 public function buildCondition(PlFilter
$uf)
209 $uf->requireProfiles();
210 return '$PID IS NOT NULL';
213 public function export()
215 return $this->buildExport('has_profile');
219 // {{{ class UFC_AccountType
220 /** Filters users who have one of the given account types
222 class UFC_AccountType
extends UserFilterCondition
226 public function __construct()
228 $this->types
= pl_flatten(func_get_args());
231 public function buildCondition(PlFilter
$uf)
233 $uf->requireAccounts();
234 return XDB
::format('a.type IN {?}', $this->types
);
237 public function export()
239 $export = $this->buildExport('account_type');
240 $export['values'] = $this->types
;
245 // {{{ class UFC_AccountPerm
246 /** Filters users who have one of the given permissions
248 class UFC_AccountPerm
extends UserFilterCondition
252 public function __construct()
254 $this->perms
= pl_flatten(func_get_args());
257 public function buildCondition(PlFilter
$uf)
261 foreach ($this->perms
as $perm) {
262 $conds[] = XDB
::format('FIND_IN_SET({?}, IF(a.user_perms IS NULL, at.perms,
263 CONCAT(at.perms, \',\', a.user_perms)))',
267 return self
::COND_TRUE
;
269 return implode(' OR ', $conds);
273 public function export()
275 $export = $this->buildExport('account_perm');
276 $export['values'] = $this->perms
;
281 // {{{ class UFC_Hruid
282 /** Filters users based on their hruid
283 * @param $val Either an hruid, or a list of those
285 class UFC_Hruid
extends UserFilterCondition
289 public function __construct()
291 $this->hruids
= pl_flatten(func_get_args());
294 public function buildCondition(PlFilter
$uf)
296 $uf->requireAccounts();
297 return XDB
::format('a.hruid IN {?}', $this->hruids
);
300 public function export()
302 $export = $this->buildExport('hruid');
303 $export['values'] = $this->hruids
;
308 // {{{ class UFC_Hrpid
309 /** Filters users based on the hrpid of their profiles
310 * @param $val Either an hrpid, or a list of those
312 class UFC_Hrpid
extends UserFilterCondition
316 public function __construct()
318 $this->hrpids
= pl_flatten(func_get_args());
321 public function buildCondition(PlFilter
$uf)
323 $uf->requireProfiles();
324 return XDB
::format('p.hrpid IN {?}', $this->hrpids
);
327 public function export()
329 $export = $this->buildExport('hrpid');
330 $export['values'] = $this->hrpids
;
335 // {{{ class UFC_HasEmailRedirect
336 /** Filters users, keeping only those with a valid email redirection (only X.org accounts).
338 class UFC_HasEmailRedirect
extends UserFilterCondition
340 public function buildCondition(PlFilter
$uf)
342 $sub_redirect = $uf->addActiveEmailRedirectFilter();
343 return 'rf.redirect IS NOT NULL';
346 public function export()
348 $export = $this->buildExport('has_email_redirect');
353 // {{{ class UFC_HasValidEmail
354 /** Filters users, keeping only those with a valid email address (all accounts).
356 class UFC_HasValidEmail
extends UserFilterCondition
358 public function buildCondition(PlFilter
$uf)
360 $sub_redirect = $uf->addEmailRedirectFilter();
361 $uf->requireAccounts();
362 return 'ra' . $sub_redirect . '.flags = \'active\' OR a.email IS NOT NULL';
365 public function export()
367 $export = $this->buildExport('has_valid_email');
373 /** Filters users based on one of their last IPs
374 * @param $ip IP from which connection are checked
376 class UFC_Ip
extends UserFilterCondition
380 public function __construct($ip)
385 public function buildCondition(PlFilter
$uf)
387 $sub = $uf->addLoggerFilter();
388 $ip = ip_to_uint($this->ip
);
389 return XDB
::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
392 public function export()
394 $export = $this->buildExport('host');
395 $export['ip'] = $this->ip
;
400 // {{{ class UFC_Comment
401 class UFC_Comment
extends UserFilterCondition
405 public function __construct($text)
410 public function buildCondition(PlFilter
$uf)
412 $uf->requireProfiles();
413 return $uf->getVisibilityConditionForField('p.freetext_pub') . ' AND p.freetext ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->text
);
416 public function export()
418 $export = $this->buildExport('comment');
419 $export['comparison'] = self
::OP_CONTAINS
;
420 $export['text'] = $this->text
;
425 // {{{ class UFC_Promo
426 /** Filters users based on promotion
427 * @param $comparison Comparison operator (>, =, ...)
428 * @param $grade Formation on which to restrict, UserFilter::DISPLAY for "any formation"
429 * @param $promo Promotion on which the filter is based
431 class UFC_Promo
extends UserFilterCondition
438 public function __construct($comparison, $grade, $promo)
440 $this->grade
= $grade;
441 $this->comparison
= $comparison;
442 $this->promo
= $promo;
443 if ($this->grade
!= UserFilter
::DISPLAY
) {
444 UserFilter
::assertGrade($this->grade
);
446 if ($this->grade
== UserFilter
::DISPLAY
&& $this->comparison
!= '=') {
447 // XXX: we might try to guess the grade from the first char of the promo and forbid only '<= 2004', but allow '<= X2004'
448 Platal
::page()->killError("Il n'est pas possible d'appliquer la comparaison '" . $this->comparison
. "' aux promotions sans spécifier de formation (X/M/D)");
452 public function buildCondition(PlFilter
$uf)
454 if ($this->grade
== UserFilter
::DISPLAY
) {
455 $sub = $uf->addDisplayFilter();
456 return XDB
::format('pd' . $sub . '.promo ' . $this->comparison
. ' {?}', $this->promo
);
458 $sub = $uf->addEducationFilter(true
, $this->grade
);
459 $field = 'pe' . $sub . '.' . UserFilter
::promoYear($this->grade
);
460 return $field . ' IS NOT NULL AND ' . $field . ' ' . $this->comparison
. ' ' . XDB
::format('{?}', $this->promo
);
464 public function export()
466 $export = $this->buildExport('promo');
467 $export['comparison'] = $this->comparison
;
468 if ($this->grade
!= UserFilter
::DISPLAY
) {
469 $export['grade'] = $this->grade
;
471 $export['promo'] = $this->promo
;
476 // {{{ class UFC_SchoolId
477 /** Filters users based on their shoold identifier
478 * @param type Parameter type (Xorg, AX, School)
479 * @param value Array of school ids
481 class UFC_SchoolId
extends UserFilterCondition
485 const School
= 'school';
490 static public function assertType($type)
492 if ($type != self
::AX
&& $type != self
::Xorg
&& $type != self
::School
) {
493 Platal
::page()->killError("Type de matricule invalide: $type");
497 /** Construct a UFC_SchoolId
498 * The first argument is the type, all following arguments can be either ids
499 * or arrays of ids to use:
500 * $ufc = new UFC_SchoolId(UFC_SchoolId::AX, $id1, $id2, array($id3, $id4));
502 public function __construct($type)
505 $ids = func_get_args();
507 $this->ids
= pl_flatten($ids);
508 self
::assertType($type);
511 public function buildCondition(PlFilter
$uf)
513 $uf->requireProfiles();
516 if ($type == self
::School
) {
518 $ids = array_map(array('Profile', 'getXorgId'), $ids);
520 return XDB
::format('p.' . $type . '_id IN {?}', $ids);
523 public function export()
525 $export = $this->buildExport('school_id');
526 $export['school_type'] = $this->type
;
527 $export['values'] = $this->ids
;
532 // {{{ class UFC_EducationSchool
533 /** Filters users by formation
534 * @param $val The formation to search (either ID or array of IDs)
536 class UFC_EducationSchool
extends UserFilterCondition
540 public function __construct()
542 $this->val
= pl_flatten(func_get_args());
545 public function buildCondition(PlFilter
$uf)
547 $sub = $uf->addEducationFilter();
548 return XDB
::format('pe' . $sub . '.eduid IN {?}', $this->val
);
552 // {{{ class UFC_EducationDegree
553 class UFC_EducationDegree
extends UserFilterCondition
557 public function __construct()
559 $this->diploma
= pl_flatten(func_get_args());
562 public function buildCondition(PlFilter
$uf)
564 $sub = $uf->addEducationFilter();
565 return XDB
::format('pe' . $sub . '.degreeid IN {?}', $this->diploma
);
569 // {{{ class UFC_EducationField
570 class UFC_EducationField
extends UserFilterCondition
574 public function __construct()
576 $this->val
= pl_flatten(func_get_args());
579 public function buildCondition(PlFilter
$uf)
581 $sub = $uf->addEducationFilter();
582 return XDB
::format('pe' . $sub . '.fieldid IN {?}', $this->val
);
586 // {{{ class UFC_NameInitial
587 /** Filters users based on sort_name
588 * @param $initial Initial on which to filter
590 class UFC_NameInitial
extends UserFilterCondition
594 public function __construct($initial)
596 $this->initial
= $initial;
599 public function buildCondition(PlFilter
$uf)
601 $table = 'sort_name';
602 if ($uf->accountsRequired()) {
603 $table = Profile
::getAccountEquivalentName($table);
606 $uf->addDisplayFilter();
609 return 'SUBSTRING(' . $sub . '.' . $table . ', 1, 1) ' . XDB
::formatWildcards(XDB
::WILDCARD_PREFIX
, $this->initial
);
612 public function export()
614 $export = $this->buildExport($this->initial
);
619 // {{{ class UFC_NameTokens
620 /** Selects users based on tokens in their name (for quicksearch)
621 * @param $tokens An array of tokens to search
622 * @param $flags Flags the tokens must have (e.g 'public' for public search)
623 * @param $soundex (bool) Whether those tokens are fulltext or soundex
625 class UFC_NameTokens
extends UserFilterCondition
628 const FLAG_PUBLIC
= 'public';
634 private $general_type;
636 public function __construct($tokens, $flags = array(), $soundex = false
, $exact = false
, $general_type = '')
638 if (is_array($tokens)) {
639 $this->tokens
= $tokens;
641 $this->tokens
= array($tokens);
643 if (is_array($flags)) {
644 $this->flags
= $flags;
646 $this->flags
= array($flags);
648 $this->soundex
= $soundex;
649 $this->exact
= $exact;
650 $this->general_type
= $general_type;
653 public function buildCondition(PlFilter
$uf)
656 foreach ($this->tokens
as $i => $token) {
657 $sub = $uf->addNameTokensFilter($token);
658 if ($this->soundex
) {
659 $c = XDB
::format($sub . '.soundex = {?}', soundex_fr($token));
660 } else if ($this->exact
) {
661 $c = XDB
::format($sub . '.token = {?}', $token);
663 $c = $sub . '.token ' . XDB
::formatWildcards(XDB
::WILDCARD_PREFIX
, $token);
665 if ($this->flags
!= null
) {
666 $c .= XDB
::format(' AND ' . $sub . '.flags IN {?}', $this->flags
);
668 if ($this->general_type
) {
669 $c .= XDB
::format(' AND ' . $sub . '.general_type = {?}', $this->general_type
);
671 $c .= ' AND (' . $uf->getVisibilityConditionAbsolute(Visibility
::EXPORT_PRIVATE
) . ' OR ' . $sub . '.general_type != \'nickname\')';
675 return implode(' AND ', $conds);
679 // {{{ class UFC_Nationality
680 class UFC_Nationality
extends UserFilterCondition
684 public function __construct()
686 $this->val
= pl_flatten(func_get_args());
689 public function buildCondition(PlFilter
$uf)
691 $uf->requireProfiles();
692 $nat = XDB
::formatArray($this->val
);
694 'p.nationality1 IN ' . $nat,
695 'p.nationality2 IN ' . $nat,
696 'p.nationality3 IN ' . $nat,
698 return implode(' OR ', $conds);
702 // {{{ class UFC_Dead
703 /** Filters users based on death date
704 * @param $comparison Comparison operator
705 * @param $date Date to which death date should be compared (DateTime object, string or timestamp)
707 class UFC_Dead
extends UserFilterCondition
712 public function __construct($comparison = null
, $date = null
)
714 $this->comparison
= $comparison;
715 $this->date
= make_datetime($date);
718 public function buildCondition(PlFilter
$uf)
720 $uf->requireProfiles();
721 $str = 'p.deathdate IS NOT NULL';
722 if (!is_null($this->comparison
)) {
723 $str .= ' AND p.deathdate ' . $this->comparison
. ' ' . XDB
::format('{?}', $this->date
->format('Y-m-d'));
729 // {{{ class UFC_Registered
730 /** Filters users based on registration state
731 * @param $active Whether we want to use only "active" users (i.e with a valid redirection)
732 * @param $comparison Comparison operator
733 * @param $date Date to which users registration date should be compared
735 class UFC_Registered
extends UserFilterCondition
741 public function __construct($active = false
, $comparison = null
, $date = null
)
743 $this->active
= $active;
744 $this->comparison
= $comparison;
745 $this->date
= make_datetime($date);
748 public function buildCondition(PlFilter
$uf)
750 $uf->requireAccounts();
752 $date = '$UID IS NOT NULL AND a.state = \'active\'';
754 $date = '$UID IS NOT NULL AND a.state != \'pending\'';
756 if (!is_null($this->comparison
)) {
757 $date .= ' AND a.registration_date != \'0000-00-00 00:00:00\' AND a.registration_date ' . $this->comparison
. ' ' . XDB
::format('{?}', $this->date
->format('Y-m-d'));
763 // {{{ class UFC_ProfileUpdated
764 /** Filters users based on profile update date
765 * @param $comparison Comparison operator
766 * @param $date Date to which profile update date must be compared
768 class UFC_ProfileUpdated
extends UserFilterCondition
773 public function __construct($comparison = null
, $date = null
)
775 $this->comparison
= $comparison;
779 public function buildCondition(PlFilter
$uf)
781 $uf->requireProfiles();
782 return 'p.last_change ' . $this->comparison
. XDB
::format(' {?}', date('Y-m-d H:i:s', $this->date
));
786 // {{{ class UFC_Birthday
787 /** Filters users based on next birthday date
788 * @param $comparison Comparison operator
789 * @param $date Date to which users next birthday date should be compared
791 class UFC_Birthday
extends UserFilterCondition
796 public function __construct($comparison = null
, $date = null
)
798 $this->comparison
= $comparison;
802 public function buildCondition(PlFilter
$uf)
804 $uf->requireProfiles();
805 return 'p.next_birthday ' . $this->comparison
. XDB
::format(' {?}', date('Y-m-d', $this->date
));
810 /** Filters users based on sex
811 * @parm $sex One of User::GENDER_MALE or User::GENDER_FEMALE, for selecting users
813 class UFC_Sex
extends UserFilterCondition
816 public function __construct($sex)
821 public function buildCondition(PlFilter
$uf)
823 if ($this->sex
!= User
::GENDER_MALE
&& $this->sex
!= User
::GENDER_FEMALE
) {
824 return self
::COND_FALSE
;
826 $uf->requireProfiles();
827 return XDB
::format('p.sex = {?}', $this->sex
== User
::GENDER_FEMALE ?
'female' : 'male');
832 // {{{ class UFC_NLSubscribed
833 /** Filters users based on NL subscription
834 * @param $nlid NL whose subscribers we are selecting
835 * @param $issue Select only subscribers who have not yet received that issue
837 class UFC_NLSubscribed
extends UserFilterCondition
841 public function __construct($nlid, $issue_id = null
)
844 $this->issue_id
= $issue_id;
847 public function buildCondition(PlFilter
$uf)
849 $sub = $uf->addNewsLetterFilter($this->nlid
);
850 $cond = $sub . '.nlid IS NOT NULL';
851 if (!is_null($this->issue_id
)) {
852 $cond = XDB
::format($cond . ' AND ( ' . $sub . '.last IS NULL OR ' . $sub . '.last < {?})', $this->issue_id
);
858 // {{{ class UFC_Group
859 /** Filters users based on group membership
860 * @param $group Group whose members we are selecting
861 * @param $anim Whether to restrict selection to animators of that group
863 class UFC_Group
extends UserFilterCondition
867 const UNNOTIFIED
= 2;
873 public function __construct($group, $anim = false
, $notified = self
::BOTH
)
875 $this->group
= $group;
877 $this->notified
= $notified;
880 public function buildCondition(PlFilter
$uf)
882 // Groups are only visible for users with perm 'groups'.
883 if (!S
::user()->checkPerms(User
::PERM_GROUPS
)) {
884 return self
::COND_FALSE
;
886 $sub = $uf->addGroupFilter($this->group
);
887 $where = 'gpm' . $sub . '.perms IS NOT NULL';
889 $where .= ' AND gpm' . $sub . '.perms = \'admin\'';
891 if ($this->notified
!= self
::BOTH
) {
892 $where .= ' AND ' . ($this->notified
== self
::UNNOTIFIED ?
'NOT ' : '')
893 . "FIND_IN_SET('notify', gpm" . $sub . '.flags)';
899 // {{{ class UFC_GroupFormerMember
900 /** Filters users based on group former membership
901 * @param $group Group whose former members we are selecting
903 class UFC_GroupFormerMember
extends UserFilterCondition
907 public function __construct($group)
909 $this->group
= $group;
912 public function buildCondition(PlFilter
$uf)
914 // Groups are only visible for users with perm 'groups'.
915 if (!S
::user()->checkPerms(User
::PERM_GROUPS
)) {
916 return self
::COND_FALSE
;
918 $sub = $uf->addGroupFormerMemberFilter();
919 return XDB
::format('gpfm' . $sub . '.asso_id = {?}', $this->group
);
923 // {{{ class UFC_Binet
924 /** Selects users based on their belonging to a given (list of) binet
925 * @param $binet either a binet_id or an array of binet_ids
927 class UFC_Binet
extends UserFilterCondition
931 public function __construct()
933 $this->val
= pl_flatten(func_get_args());
936 public function buildCondition(PlFilter
$uf)
938 $sub = $uf->addBinetsFilter();
939 // Binets are private.
940 return XDB
::format($uf->getVisibilityConditionAbsolute(Visibility
::EXPORT_PRIVATE
) . ' AND ' . $sub . '.binet_id IN {?}', $this->val
);
944 // {{{ class UFC_Section
945 /** Selects users based on section
946 * @param $section ID of the section
948 class UFC_Section
extends UserFilterCondition
952 public function __construct()
954 $this->section
= pl_flatten(func_get_args());
957 public function buildCondition(PlFilter
$uf)
959 // Sections are private.
960 $uf->requireProfiles();
961 return XDB
::format($uf->getVisibilityConditionAbsolute(Visibility
::EXPORT_PRIVATE
) . ' AND p.section IN {?}', $this->section
);
965 // {{{ class UFC_Email
966 /** Filters users based on an email or a list of emails
967 * @param $emails List of emails whose owner must be selected
969 class UFC_Email
extends UserFilterCondition
972 public function __construct()
974 $this->emails
= pl_flatten(func_get_args());
977 public function buildCondition(PlFilter
$uf)
983 if (count($this->emails
) == 0) {
984 return PlFilterCondition
::COND_FALSE
;
987 foreach ($this->emails
as $entry) {
988 if (User
::isForeignEmailAddress($entry)) {
991 list($local_part, ) = explode('@', $entry);
992 $local[] = $local_part;
996 if (count($foreign) > 0) {
997 $sub = $uf->addEmailRedirectFilter($foreign);
998 $cond[] = XDB
::format('ra' . $sub . '.redirect IS NOT NULL OR ra' . $sub . '.redirect IN {?} OR a.email IN {?}', $foreign, $foreign);
1000 if (count($local) > 0) {
1001 $sub = $uf->addAliasFilter($local);
1002 $cond[] = 'sa' . $sub . '.email IS NOT NULL';
1004 return '(' . implode(') OR (', $cond) . ')';
1008 // {{{ class UFC_Address
1009 abstract class UFC_Address
extends UserFilterCondition
1011 /** Valid address type
1013 const TYPE_HOME
= 1;
1015 const TYPE_NON_HQ
= 3;
1019 /** Text for these types
1021 protected static $typetexts = array(
1022 self
::TYPE_HOME
=> 'home',
1023 self
::TYPE_PRO
=> 'pro',
1024 self
::TYPE_HQ
=> 'hq',
1029 /** Flags for addresses
1031 const FLAG_NONE
= 0x0000;
1032 const FLAG_CURRENT
= 0x0001;
1033 const FLAG_TEMP
= 0x0002;
1034 const FLAG_SECOND
= 0x0004;
1035 const FLAG_MAIL
= 0x0008;
1036 const FLAG_CEDEX
= 0x0010;
1037 const FLAG_BEST_MAIL
= 0x0020;
1039 // Binary OR of those flags
1040 const FLAG_ANY
= 0x003F;
1042 /** Text of these flags
1043 * "Best mail" is a denormalized flag, hence the dn_ prefix
1045 protected static $flagtexts = array(
1046 self
::FLAG_CURRENT
=> 'current',
1047 self
::FLAG_TEMP
=> 'temporary',
1048 self
::FLAG_SECOND
=> 'secondary',
1049 self
::FLAG_MAIL
=> 'mail',
1050 self
::FLAG_CEDEX
=> 'cedex',
1051 self
::FLAG_BEST_MAIL
=> 'dn_best_mail',
1056 public function __construct($type = null
, $flags = null
)
1058 $this->type
= $type;
1059 $this->flags
= $flags;
1062 protected function initConds($sub, $vis_cond)
1064 $conds = array($vis_cond);
1067 foreach (self
::$typetexts as $flag => $type) {
1068 if ($flag & $this->type
) {
1072 if (count($types)) {
1073 $conds[] = XDB
::format('pa' . $sub . '.type IN {?}', $types);
1076 if ($this->flags
!= self
::FLAG_ANY
) {
1077 foreach(self
::$flagtexts as $flag => $text) {
1078 if ($flag & $this->flags
) {
1079 $conds[] = 'FIND_IN_SET(' . XDB
::format('{?}', $text) . ', pa' . $sub . '.flags)';
1088 // {{{ class UFC_AddressField
1089 /** Filters users based on their address,
1090 * @param $val Either a code for one of the fields, or an array of such codes
1091 * @param $fieldtype The type of field to look for
1092 * @param $type Filter on address type
1093 * @param $flags Filter on address flags
1095 class UFC_AddressComponent
extends UFC_Address
1097 static $components = array('postal_code', 'locality', 'administrative_area_level_3', 'administrative_area_level_2', 'administrative_area_level_1', 'country');
1099 /** Data of the filter
1105 public function __construct($val, $fieldtype, $type = null
, $flags = self
::FLAG_ANY
)
1107 if (!in_array($fieldtype, self
::$components)) {
1108 Platal
::page()->killError('Invalid address field type: ' . $this->fieldtype
);
1111 parent
::__construct($type, $flags);
1112 if (!is_array($val)) {
1116 $this->fieldtype
= $fieldtype;
1119 public function buildCondition(PlFilter
$uf)
1121 $sub = $uf->addAddressFilter($this->fieldtype
);
1122 $conds = $this->initConds($sub, $uf->getVisibilityConditionForField('pa' . $sub . '.pub'));
1123 $conds[] = XDB
::format('pace' . $sub . '.id IN {?}', $this->val
);
1125 return implode(' AND ', $conds);
1129 // {{{ class UFC_Corps
1130 /** Filters users based on the corps they belong to
1131 * @param $corps Corps we are looking for (abbreviation)
1132 * @param $type Whether we search for original or current corps
1134 class UFC_Corps
extends UserFilterCondition
1143 public function __construct($corps, $id = null
, $type = self
::CURRENT
)
1145 $this->corps
= $corps;
1147 $this->type
= $type;
1150 public function buildCondition(PlFilter
$uf)
1152 /** Tables shortcuts:
1153 * pc for profile_corps,
1154 * pceo for profile_corps_enum - orginal
1155 * pcec for profile_corps_enum - current
1157 $sub = $uf->addCorpsFilter($this->type
);
1158 if (is_null($this->id
)) {
1159 $cond = $sub . '.abbreviation = ' . $this->corps
;
1161 $cond = $sub . '.id = ' . $this->id
;
1163 // XXX(x2006barrois): find a way to get rid of that hardcoded
1164 // reference to 'pc'.
1165 $cond .= ' AND ' . $uf->getVisibilityConditionForField('pc.corps_pub');
1170 // {{{ class UFC_Corps_Rank
1171 /** Filters users based on their rank in the corps
1172 * @param $rank Rank we are looking for (abbreviation)
1174 class UFC_Corps_Rank
extends UserFilterCondition
1179 public function __construct($rank, $id = null
)
1181 $this->rank
= $rank;
1185 public function buildCondition(PlFilter
$uf)
1187 /** Tables shortcuts:
1188 * pc for profile_corps
1189 * pcr for profile_corps_rank
1191 $sub = $uf->addCorpsRankFilter();
1192 if (is_null($this->id
)) {
1193 $cond = $sub . '.abbreviation = ' . $this->rank
;
1195 $cond = $sub . '.id = ' . $this->id
;
1197 // XXX(x2006barrois): find a way to get rid of that hardcoded
1198 // reference to 'pc'.
1199 $cond .= ' AND ' . $uf->getVisibilityConditionForField('pc.corps_pub');
1204 // {{{ class UFC_Job_Company
1205 /** Filters users based on the company they belong to
1206 * @param $type The field being searched (self::JOBID, self::JOBNAME or self::JOBACRONYM)
1207 * @param $value The searched value
1209 class UFC_Job_Company
extends UserFilterCondition
1212 const JOBNAME
= 'name';
1213 const JOBACRONYM
= 'acronym';
1218 public function __construct($type, $value)
1220 $this->assertType($type);
1221 $this->type
= $type;
1222 $this->value
= $value;
1225 private function assertType($type)
1227 if ($type != self
::JOBID
&& $type != self
::JOBNAME
&& $type != self
::JOBACRONYM
) {
1228 Platal
::page()->killError("Type de recherche non valide.");
1232 public function buildCondition(PlFilter
$uf)
1234 $sub = $uf->addJobCompanyFilter();
1235 $cond = $sub . '.' . $this->type
. XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->value
);
1236 $jsub = $uf->addJobFilter();
1237 $cond .= ' AND ' . $uf->getVisibilityConditionForField($jsub . '.pub');
1242 // {{{ class UFC_Job_Terms
1243 /** Filters users based on the job terms they assigned to one of their
1245 * @param $val The ID of the job term, or an array of such IDs
1247 class UFC_Job_Terms
extends UserFilterCondition
1251 public function __construct($val)
1253 if (!is_array($val)) {
1259 public function buildCondition(PlFilter
$uf)
1261 $sub = $uf->addJobTermsFilter(count($this->val
));
1262 $conditions = array();
1263 foreach ($this->val
as $i => $jtid) {
1264 $conditions[] = $sub[$i] . '.jtid_1 = ' . XDB
::escape($jtid);
1266 $jsub = $uf->addJobFilter();
1267 $conditions[] = $uf->getVisibilityConditionForField($jsub . '.pub');
1268 return implode(' AND ', $conditions);
1272 // {{{ class UFC_Job_Description
1273 /** Filters users based on their job description
1274 * @param $description The text being searched for
1275 * @param $fields The fields to search for (CV, user-defined)
1277 class UFC_Job_Description
extends UserFilterCondition
1280 private $description;
1283 public function __construct($description, $fields)
1285 $this->fields
= $fields;
1286 $this->description
= $description;
1289 public function buildCondition(PlFilter
$uf)
1293 $jsub = $uf->addJobFilter();
1294 if ($this->fields
& UserFilter
::JOB_USERDEFINED
) {
1295 $conds[] = $jsub . '.description ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->description
);
1297 if ($this->fields
& UserFilter
::JOB_CV
) {
1298 $uf->requireProfiles();
1300 $conds[] = '( ' . $uf->getVisibilityConditionAbsolute(Visibility
::EXPORT_PRIVATE
) . ' AND p.cv ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->description
) . ')';
1302 if (count($conds) == 0) {
1303 return self
::COND_TRUE
;
1305 return $uf->getVisibilityConditionForField($jsub . '.pub') . ' AND ( ' . implode(' OR ', $conds) . ' )';
1309 // {{{ class UFC_Networking
1310 /** Filters users based on network identity (IRC, ...)
1311 * @param $type Type of network (-1 for any)
1312 * @param $value Value to search
1314 class UFC_Networking
extends UserFilterCondition
1319 public function __construct($type, $value)
1321 $this->type
= $type;
1322 $this->value
= $value;
1325 public function buildCondition(PlFilter
$uf)
1327 $sub = $uf->addNetworkingFilter();
1329 $conds[] = $uf->getVisibilityConditionForField($sub . '.pub');
1330 $conds[] = $sub . '.address ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->value
);
1331 if ($this->type
!= -1) {
1332 $conds[] = $sub . '.nwid = ' . XDB
::format('{?}', $this->type
);
1334 return implode(' AND ', $conds);
1338 // {{{ class UFC_Phone
1339 /** Filters users based on their phone number
1340 * @param $num_type Type of number (pro/user/home)
1341 * @param $phone_type Type of phone (fixed/mobile/fax)
1342 * @param $number Phone number
1344 class UFC_Phone
extends UserFilterCondition
1346 const NUM_PRO
= 'pro';
1347 const NUM_USER
= 'user';
1348 const NUM_HOME
= 'address';
1349 const NUM_ANY
= 'any';
1351 const PHONE_FIXED
= 'fixed';
1352 const PHONE_MOBILE
= 'mobile';
1353 const PHONE_FAX
= 'fax';
1354 const PHONE_ANY
= 'any';
1357 private $phone_type;
1360 public function __construct($number, $num_type = self
::NUM_ANY
, $phone_type = self
::PHONE_ANY
)
1362 $phone = new Phone(array('display' => $number));
1364 $this->number
= $phone->search
;
1365 $this->num_type
= $num_type;
1366 $this->phone_type
= $phone_type;
1369 public function buildCondition(PlFilter
$uf)
1371 $sub = $uf->addPhoneFilter();
1374 $conds[] = $uf->getVisibilityConditionForField($sub . '.pub');
1376 $conds[] = $sub . '.search_tel = ' . XDB
::format('{?}', $this->number
);
1377 if ($this->num_type
!= self
::NUM_ANY
) {
1378 $conds[] = $sub . '.link_type = ' . XDB
::format('{?}', $this->num_type
);
1380 if ($this->phone_type
!= self
::PHONE_ANY
) {
1381 $conds[] = $sub . '.tel_type = ' . XDB
::format('{?}', $this->phone_type
);
1383 return implode(' AND ', $conds);
1387 // {{{ class UFC_Medal
1388 /** Filters users based on their medals
1389 * @param $medal ID of the medal
1390 * @param $grade Grade of the medal (null for 'any')
1392 class UFC_Medal
extends UserFilterCondition
1397 public function __construct($medal, $grade = null
)
1399 $this->medal
= $medal;
1400 $this->grade
= $grade;
1403 public function buildCondition(PlFilter
$uf)
1407 // This will require profiles => table 'p' will be available.
1408 $sub = $uf->addMedalFilter();
1410 $conds[] = $uf->getVisibilityConditionForField('p.medals_pub');
1412 $conds[] = $sub . '.mid = ' . XDB
::format('{?}', $this->medal
);
1413 if ($this->grade
!= null
) {
1414 $conds[] = $sub . '.gid = ' . XDB
::format('{?}', $this->grade
);
1416 return implode(' AND ', $conds);
1420 // {{{ class UFC_Photo
1421 /** Filters profiles with photo
1423 class UFC_Photo
extends UserFilterCondition
1425 public function buildCondition(PlFilter
$uf)
1427 $sub = $uf->addPhotoFilter();
1428 return $sub . '.attach IS NOT NULL AND ' . $uf->getVisibilityConditionForField($sub . '.pub');
1432 // {{{ class UFC_Mentor
1433 class UFC_Mentor
extends UserFilterCondition
1435 public function buildCondition(PlFilter
$uf)
1437 $sub = $uf->addMentorFilter(UserFilter
::MENTOR
);
1438 return $sub . '.expertise IS NOT NULL';
1442 // {{{ class UFC_Mentor_Expertise
1443 /** Filters users by mentoring expertise
1444 * @param $expertise Domain of expertise
1446 class UFC_Mentor_Expertise
extends UserFilterCondition
1450 public function __construct($expertise)
1452 $this->expertise
= $expertise;
1455 public function buildCondition(PlFilter
$uf)
1457 $sub = $uf->addMentorFilter(UserFilter
::MENTOR_EXPERTISE
);
1458 return $sub . '.expertise ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->expertise
);
1462 // {{{ class UFC_Mentor_Country
1463 /** Filters users by mentoring country
1464 * @param $country Two-letters code of country being searched
1466 class UFC_Mentor_Country
extends UserFilterCondition
1470 public function __construct()
1472 $this->country
= pl_flatten(func_get_args());
1475 public function buildCondition(PlFilter
$uf)
1477 $sub = $uf->addMentorFilter(UserFilter
::MENTOR_COUNTRY
);
1478 return $sub . '.country IN ' . XDB
::format('{?}', $this->country
);
1482 // {{{ class UFC_Mentor_Terms
1483 /** Filters users based on the job terms they used in mentoring.
1484 * @param $val The ID of the job term, or an array of such IDs
1486 class UFC_Mentor_Terms
extends UserFilterCondition
1490 public function __construct($val)
1495 public function buildCondition(PlFilter
$uf)
1497 $sub = $uf->addMentorFilter(UserFilter
::MENTOR_TERM
);
1498 return $sub . '.jtid_1 = ' . XDB
::escape($this->val
);
1502 // {{{ class UFC_UserRelated
1503 /** Filters users based on a relation toward a user
1504 * @param $user User to which searched users are related
1506 abstract class UFC_UserRelated
extends UserFilterCondition
1509 public function __construct(PlUser
$user)
1511 $this->user
=& $user;
1515 // {{{ class UFC_DeltaTen
1516 class UFC_DeltaTen
extends UserFilterCondition
1518 public function buildCondition(PlFilter
$uf)
1520 $sub = $uf->addDeltaTenFilter(UserFilter
::DELTATEN
);
1521 return $sub . '.message IS NOT NULL';
1525 // {{{ class UFC_DeltaTen_Message
1526 /** Filters users by deltaten message
1527 * @param $message Message for the DeltaTen program
1529 class UFC_DeltaTen_Message
extends UserFilterCondition
1533 public function __construct($message)
1535 $this->message
= $message;
1538 public function buildCondition(PlFilter
$uf)
1540 $sub = $uf->addDeltaTenFilter(UserFilter
::DELTATEN_MESSAGE
);
1541 return $sub . '.message ' . XDB
::formatWildcards(XDB
::WILDCARD_CONTAINS
, $this->message
);
1545 // {{{ class UFC_Contact
1546 /** Filters users who belong to selected user's contacts
1548 class UFC_Contact
extends UFC_UserRelated
1550 public function buildCondition(PlFilter
$uf)
1552 $sub = $uf->addContactFilter($this->user
->id());
1553 return 'c' . $sub . '.contact IS NOT NULL';
1557 // {{{ class UFC_WatchRegistration
1558 /** Filters users being watched by selected user
1560 class UFC_WatchRegistration
extends UFC_UserRelated
1562 public function buildCondition(PlFilter
$uf)
1564 if (!$this->user
->watchType('registration')) {
1565 return PlFilterCondition
::COND_FALSE
;
1567 $uids = $this->user
->watchUsers();
1568 if (count($uids) == 0) {
1569 return PlFilterCondition
::COND_FALSE
;
1571 return XDB
::format('$UID IN {?}', $uids);
1576 // {{{ class UFC_WatchPromo
1577 /** Filters users belonging to a promo watched by selected user
1578 * @param $user Selected user (the one watching promo)
1579 * @param $grade Formation the user is watching
1581 class UFC_WatchPromo
extends UFC_UserRelated
1584 public function __construct(PlUser
$user, $grade = UserFilter
::GRADE_ING
)
1586 parent
::__construct($user);
1587 $this->grade
= $grade;
1590 public function buildCondition(PlFilter
$uf)
1592 $promos = $this->user
->watchPromos();
1593 if (count($promos) == 0) {
1594 return PlFilterCondition
::COND_FALSE
;
1596 $sube = $uf->addEducationFilter(true
, $this->grade
);
1597 $field = 'pe' . $sube . '.' . UserFilter
::promoYear($this->grade
);
1598 return XDB
::format($field . ' IN {?}', $promos);
1603 // {{{ class UFC_WatchGroup
1604 /** Filters users belonging to a group watched by selected user
1605 * @param $user Selected user (the one watching group)
1607 class UFC_WatchGroup
extends UFC_UserRelated
1609 public function buildCondition(PlFilter
$uf)
1611 $groups = $this->user
->watchGroups();
1612 if (count($groups) == 0) {
1613 return PlFilterCondition
::COND_FALSE
;
1615 $conditions = array();
1616 foreach ($groups as $group) {
1617 $sub = $uf->addGroupFilter($group);
1618 $conditions[] = 'gpm' . $sub . '.perms IS NOT NULL';
1620 return implode(' OR ', $conditions);
1624 // {{{ class UFC_WatchContact
1625 /** Filters users watched by selected user
1627 class UFC_WatchContact
extends UFC_Contact
1629 public function buildCondition(PlFilter
$uf)
1631 if (!$this->user
->watchContacts()) {
1632 return PlFilterCondition
::COND_FALSE
;
1634 return parent
::buildCondition($uf);
1638 // {{{ class UFC_MarketingHash
1639 /** Filters users using the hash generated
1640 * to send marketing emails to him.
1642 class UFC_MarketingHash
extends UserFilterCondition
1646 public function __construct($hash)
1648 $this->hash
= $hash;
1651 public function buildCondition(PlFilter
$uf)
1653 $table = $uf->addMarketingHash();
1654 return XDB
::format('rm.hash = {?}', $this->hash
);
1658 // {{{ class UFC_PartnerSharing
1659 /** Filters users, keeping only those sharing data with a given partner.
1661 class UFC_PartnerSharing
extends UserFilterCondition
1665 private $partner_id;
1667 public function __construct($partner_id)
1669 $this->partner_id
= $partner_id;
1672 public function buildCondition(PlFilter
$uf)
1674 $sub = $uf->addPartnerSharingFilter($this->partner_id
);
1675 return XDB
::format("$sub.exposed_uid IS NOT NULL");
1679 // {{{ class UFC_PartnerSharingEmail
1680 /** Filters users, keeping only those allowing emails to be sent by
1683 class UFC_PartnerSharingEmail
extends UserFilterCondition
1685 private $partner_id;
1687 public function __construct($partner_id)
1689 $this->partner_id
= $partner_id;
1692 public function buildCondition(PlFilter
$uf)
1694 $sub = $uf->addPartnerSharingFilter($this->partner_id
);
1695 return XDB
::format("$sub.allow_email IN ('digest', 'direct')");
1699 // {{{ class UFC_PartnerSharingID
1700 /** Filters users according to a list of partner-known IDs
1702 class UFC_PartnerSharingID
extends UserFilterCondition
1704 private $partner_id;
1707 public function __construct($partner_id)
1709 $this->partner_id
= $partner_id;
1710 $ids = func_get_args();
1712 $this->ids
= pl_flatten($ids);
1715 public function buildCondition(PlFilter
$uf)
1717 $uf->requireProfiles();
1719 $sub = $uf->addPartnerSharingFilter($this->partner_id
);
1720 return XDB
::format("$sub.exposed_uid IN {?}", $ids);
1725 // vim:set et sw=4 sts=4 sws=4 foldmethod=marker fenc=utf-8: