Renames uid to pid in watch_profile table.
[platal.git] / classes / userfilter.php
CommitLineData
a087cc8d
FB
1<?php
2/***************************************************************************
d4c08d89 3 * Copyright (C) 2003-2010 Polytechnique.org *
a087cc8d
FB
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
d865c296
FB
22
23/******************
24 * CONDITIONS
25 ******************/
26
8363588b 27// {{{ interface UserFilterCondition
2d83cac9
RB
28/** This interface describe objects which filter users based
29 * on various parameters.
30 * The parameters of the filter must be given to the constructor.
31 * The buildCondition function is called by UserFilter when
32 * actually building the query. That function must call
33 * $uf->addWheteverFilter so that the UserFilter makes
34 * adequate joins. It must return the 'WHERE' condition to use
35 * with the filter.
36 */
dcc63ed5 37interface UserFilterCondition extends PlFilterCondition
a087cc8d 38{
a087cc8d 39}
8363588b 40// }}}
a087cc8d 41
8363588b 42// {{{ class UFC_Profile
53eae167
RB
43/** Filters users who have a profile
44 */
eb1449b8
FB
45class UFC_Profile implements UserFilterCondition
46{
dcc63ed5 47 public function buildCondition(PlFilter &$uf)
eb1449b8
FB
48 {
49 return '$PID IS NOT NULL';
50 }
51}
8363588b 52// }}}
eb1449b8 53
ddba9d4f
RB
54// {{{ class UFC_Hruid
55/** Filters users based on their hruid
56 * @param $val Either an hruid, or a list of those
57 */
58class UFC_Hruid implements UserFilterCondition
59{
60 private $hruids;
61
62 public function __construct($val)
63 {
64 if (!is_array($val)) {
65 $val = array($val);
66 }
67 $this->hruids = $val;
68 }
69
70 public function buildCondition(PlFilter &$uf)
71 {
72 $ufc->requireAccounts();
73
74 return 'a.hruid IN ' . XDB::formatArray($this->hruids);
75 }
76}
77// }}}
78
f73a4f1b
RB
79// {{{ class UFC_Ip
80/** Filters users based on one of their last IPs
81 * @param $ip IP from which connection are checked
82 */
83class UFC_Ip implements UserFilterCondition
84{
85 private $ip;
86
87 public function __construct($ip)
88 {
89 $this->ip = $ip;
90 }
91
92 public function buildCondition(PlFilter &$uf)
93 {
94 $sub = $uf->addLoggerFilter();
95 $ip = ip_to_uint($this->ip);
96 return XDB::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
97 }
98}
99// }}}
100
d7ddf29b
RB
101// {{{ class UFC_Comment
102class UFC_Comment implements UserFilterCondition
103{
104 private $text;
105
106 public function __construct($text)
107 {
108 $this->text = $text;
109 }
110
111 public function buildCondition(PlFilter &$uf)
112 {
113 $uf->requireProfiles();
658b4c83 114 return 'p.freetext ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->text);
d7ddf29b
RB
115 }
116}
117// }}}
118
8363588b 119// {{{ class UFC_Promo
5d2e55c7 120/** Filters users based on promotion
53eae167
RB
121 * @param $comparison Comparison operator (>, =, ...)
122 * @param $grade Formation on which to restrict, UserFilter::DISPLAY for "any formation"
5d2e55c7 123 * @param $promo Promotion on which the filter is based
53eae167 124 */
a087cc8d
FB
125class UFC_Promo implements UserFilterCondition
126{
a087cc8d
FB
127
128 private $grade;
129 private $promo;
130 private $comparison;
131
132 public function __construct($comparison, $grade, $promo)
133 {
134 $this->grade = $grade;
135 $this->comparison = $comparison;
136 $this->promo = $promo;
38c6fe96
FB
137 if ($this->grade != UserFilter::DISPLAY) {
138 UserFilter::assertGrade($this->grade);
139 }
a087cc8d
FB
140 }
141
dcc63ed5 142 public function buildCondition(PlFilter &$uf)
a087cc8d 143 {
38c6fe96
FB
144 if ($this->grade == UserFilter::DISPLAY) {
145 $sub = $uf->addDisplayFilter();
1a23a02b 146 return XDB::format('pd' . $sub . '.promo ' . $this->comparison . ' {?}', $this->promo);
38c6fe96
FB
147 } else {
148 $sub = $uf->addEducationFilter(true, $this->grade);
149 $field = 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
150 return $field . ' IS NOT NULL AND ' . $field . ' ' . $this->comparison . ' ' . XDB::format('{?}', $this->promo);
151 }
784745ce
FB
152 }
153}
8363588b 154// }}}
784745ce 155
9e8bacfb
FB
156// {{{ class UFC_SchoolId
157/** Filters users based on their shoold identifier
158 * @param type Parameter type (Xorg, AX, School)
159 * @param value School id value
160 */
161class UFC_SchooldId implements UserFilterCondition
162{
163 const AX = 'ax';
164 const Xorg = 'xorg';
165 const School = 'school';
166
167 private $type;
168 private $id;
169
170 static public function assertType($type)
171 {
172 if ($type != self::AX && $type != self::Xorg && $type != self::School) {
173 Platal::page()->killError("Type de matricule invalide: $type");
174 }
175 }
176
177 public function __construct($type, $id)
178 {
179 $this->type = $type;
180 $this->id = $id;
181 self::assertType($type);
182 }
183
184 public function buildCondition(PlFilter &$uf)
185 {
186 $uf->requireProfiles();
187 $id = $this->id;
188 $type = $this->type;
189 if ($type == self::School) {
190 $type = self::Xorg;
191 $id = Profile::getXorgId($id);
192 }
193 return XDB::format('p.' . $type . '_id = {?}', $id);
194 }
195}
196// }}}
197
fb3b6547 198// {{{ class UFC_EducationSchool
d7ddf29b
RB
199/** Filters users by formation
200 * @param $val The formation to search (either ID or array of IDs)
201 */
fb3b6547 202class UFC_EducationSchool implements UserFilterCondition
a7f8e48a 203{
d7ddf29b 204 private $val;
a7f8e48a 205
d7ddf29b 206 public function __construct($val)
a7f8e48a 207 {
d7ddf29b
RB
208 if (!is_array($val)) {
209 $val = array($val);
210 }
211 $this->val = $val;
a7f8e48a
RB
212 }
213
214 public function buildCondition(PlFilter &$uf)
215 {
216 $sub = $uf->addEducationFilter();
d7ddf29b 217 return 'pe' . $sub . '.eduid IN ' . XDB::formatArray($this->val);
a7f8e48a
RB
218 }
219}
220// }}}
221
fb3b6547
RB
222// {{{ class UFC_EducationDegree
223class UFC_EducationDegree implements UserFilterCondition
d7ddf29b
RB
224{
225 private $diploma;
226
227 public function __construct($diploma)
228 {
229 if (! is_array($diploma)) {
230 $diploma = array($diploma);
231 }
232 $this->diploma = $diploma;
233 }
234
235 public function buildCondition(PlFilter &$uf)
236 {
237 $sub = $uf->addEducationFilter();
238 return 'pee' . $sub . '.degreeid IN ' . XDB::formatArray($this->val);
239 }
240}
241// }}}
242
fb3b6547
RB
243// {{{ class UFC_EducationField
244class UFC_EducationField implements UserFilterCondition
d7ddf29b
RB
245{
246 private $val;
247
248 public function __construct($val)
249 {
46e88fe3
RB
250 if (!is_array($val)) {
251 $val = array($val);
252 }
d7ddf29b
RB
253 $this->val = $val;
254 }
255
256 public function buildCondition(PlFilter &$uf)
257 {
258 $sub = $uf->addEducationFilter();
259 return 'pee' . $sub . '.fieldid IN ' . XDB::formatArray($this->val);
260 }
261}
262// }}}
263
8363588b 264// {{{ class UFC_Name
53eae167 265/** Filters users based on name
5d2e55c7 266 * @param $type Type of name field on which filtering is done (firstname, lastname...)
53eae167 267 * @param $text Text on which to filter
5d2e55c7 268 * @param $mode Flag indicating search type (prefix, suffix, with particule...)
53eae167 269 */
784745ce
FB
270class UFC_Name implements UserFilterCondition
271{
658b4c83
RB
272 const PREFIX = XDB::WILDCARD_PREFIX; // 0x001
273 const SUFFIX = XDB::WILDCARD_SUFFIX; // 0x002
274 const CONTAINS = XDB::WILDCARD_CONTAINS; // 0x003
275 const PARTICLE = 0x007; // self::CONTAINS | 0x004
276 const VARIANTS = 0x008;
784745ce
FB
277
278 private $type;
279 private $text;
280 private $mode;
281
282 public function __construct($type, $text, $mode)
283 {
284 $this->type = $type;
285 $this->text = $text;
286 $this->mode = $mode;
287 }
288
289 private function buildNameQuery($type, $variant, $where, UserFilter &$uf)
290 {
291 $sub = $uf->addNameFilter($type, $variant);
292 return str_replace('$ME', 'pn' . $sub, $where);
293 }
294
dcc63ed5 295 public function buildCondition(PlFilter &$uf)
784745ce
FB
296 {
297 $left = '$ME.name';
784745ce
FB
298 if (($this->mode & self::PARTICLE) == self::PARTICLE) {
299 $left = 'CONCAT($ME.particle, \' \', $ME.name)';
300 }
658b4c83
RB
301 $right = XDB::formatWildcards($this->mode & self::CONTAINS, $this->text);
302
303 $cond = $left . $right;
784745ce 304 $conds = array($this->buildNameQuery($this->type, null, $cond, $uf));
913a4e90
RB
305 if (($this->mode & self::VARIANTS) != 0 && isset(Profile::$name_variants[$this->type])) {
306 foreach (Profile::$name_variants[$this->type] as $var) {
784745ce
FB
307 $conds[] = $this->buildNameQuery($this->type, $var, $cond, $uf);
308 }
309 }
310 return implode(' OR ', $conds);
a087cc8d
FB
311 }
312}
8363588b 313// }}}
a087cc8d 314
40585144
RB
315// {{{ class UFC_NameTokens
316/** Selects users based on tokens in their name (for quicksearch)
317 * @param $tokens An array of tokens to search
318 * @param $flags Flags the tokens must have (e.g 'public' for public search)
319 * @param $soundex (bool) Whether those tokens are fulltext or soundex
320 */
321class UFC_NameTokens implements UserFilterCondition
322{
323 /* Flags */
324 const FLAG_PUBLIC = 'public';
325
326 private $tokens;
327 private $flags;
328 private $soundex;
79a0b464 329 private $exact;
40585144 330
79a0b464 331 public function __construct($tokens, $flags = array(), $soundex = false, $exact = false)
40585144
RB
332 {
333 $this->tokens = $tokens;
334 if (is_array($flags)) {
335 $this->flags = $flags;
336 } else {
337 $this->flags = array($flags);
338 }
339 $this->soundex = $soundex;
79a0b464 340 $this->exact = $exact;
40585144
RB
341 }
342
dcc63ed5 343 public function buildCondition(PlFilter &$uf)
40585144 344 {
79a0b464 345 $sub = $uf->addNameTokensFilter(!($this->exact || $this->soundex));
40585144
RB
346 $conds = array();
347 if ($this->soundex) {
348 $conds[] = $sub . '.soundex IN ' . XDB::formatArray($this->tokens);
79a0b464
RB
349 } else if ($this->exact) {
350 $conds[] = $sub . '.token IN ' . XDB::formatArray($this->tokens);
40585144
RB
351 } else {
352 $tokconds = array();
353 foreach ($this->tokens as $token) {
658b4c83 354 $tokconds[] = $sub . '.token ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $token);
40585144
RB
355 }
356 $conds[] = implode(' OR ', $tokconds);
357 }
358
359 if ($this->flags != null) {
360 $conds[] = $sub . '.flags IN ' . XDB::formatArray($this->flags);
361 }
362
363 return implode(' AND ', $conds);
364 }
365}
366// }}}
367
0fb3713c
RB
368// {{{ class UFC_Nationality
369class UFC_Nationality implements UserFilterCondition
370{
d7ddf29b 371 private $val;
0fb3713c 372
d7ddf29b 373 public function __construct($val)
0fb3713c 374 {
d7ddf29b
RB
375 if (!is_array($val)) {
376 $val = array($val);
377 }
378 $this->val = $val;
0fb3713c
RB
379 }
380
381 public function buildCondition(PlFilter &$uf)
382 {
d7ddf29b
RB
383 $uf->requireProfiles();
384 $nat = XDB::formatArray($this->val);
385 $conds = array(
386 'p.nationality1 IN ' . $nat,
387 'p.nationality2 IN ' . $nat,
388 'p.nationality3 IN ' . $nat,
389 );
390 return implode(' OR ', $conds);
0fb3713c
RB
391 }
392}
393// }}}
394
8363588b 395// {{{ class UFC_Dead
53eae167
RB
396/** Filters users based on death date
397 * @param $comparison Comparison operator
398 * @param $date Date to which death date should be compared
399 */
4927ee54
FB
400class UFC_Dead implements UserFilterCondition
401{
38c6fe96
FB
402 private $comparison;
403 private $date;
404
405 public function __construct($comparison = null, $date = null)
4927ee54 406 {
38c6fe96
FB
407 $this->comparison = $comparison;
408 $this->date = $date;
4927ee54
FB
409 }
410
dcc63ed5 411 public function buildCondition(PlFilter &$uf)
4927ee54 412 {
d7ddf29b 413 $uf->requireProfiles();
38c6fe96
FB
414 $str = 'p.deathdate IS NOT NULL';
415 if (!is_null($this->comparison)) {
416 $str .= ' AND p.deathdate ' . $this->comparison . ' ' . XDB::format('{?}', date('Y-m-d', $this->date));
4927ee54 417 }
38c6fe96 418 return $str;
4927ee54
FB
419 }
420}
8363588b 421// }}}
4927ee54 422
8363588b 423// {{{ class UFC_Registered
53eae167
RB
424/** Filters users based on registration state
425 * @param $active Whether we want to use only "active" users (i.e with a valid redirection)
426 * @param $comparison Comparison operator
427 * @param $date Date to which users registration date should be compared
428 */
4927ee54
FB
429class UFC_Registered implements UserFilterCondition
430{
431 private $active;
38c6fe96
FB
432 private $comparison;
433 private $date;
434
435 public function __construct($active = false, $comparison = null, $date = null)
4927ee54 436 {
b2e8fc54 437 $this->active = $active;
38c6fe96
FB
438 $this->comparison = $comparison;
439 $this->date = $date;
4927ee54
FB
440 }
441
dcc63ed5 442 public function buildCondition(PlFilter &$uf)
4927ee54 443 {
d7ddf29b 444 $uf->requireAccounts();
4927ee54 445 if ($this->active) {
38c6fe96 446 $date = 'a.uid IS NOT NULL AND a.state = \'active\'';
4927ee54 447 } else {
38c6fe96
FB
448 $date = 'a.uid IS NOT NULL AND a.state != \'pending\'';
449 }
450 if (!is_null($this->comparison)) {
451 $date .= ' AND a.registration_date ' . $this->comparison . ' ' . XDB::format('{?}', date('Y-m-d', $this->date));
4927ee54 452 }
38c6fe96 453 return $date;
4927ee54
FB
454 }
455}
8363588b 456// }}}
4927ee54 457
8363588b 458// {{{ class UFC_ProfileUpdated
53eae167
RB
459/** Filters users based on profile update date
460 * @param $comparison Comparison operator
461 * @param $date Date to which profile update date must be compared
462 */
7e735012
FB
463class UFC_ProfileUpdated implements UserFilterCondition
464{
465 private $comparison;
466 private $date;
467
468 public function __construct($comparison = null, $date = null)
469 {
470 $this->comparison = $comparison;
471 $this->date = $date;
472 }
473
dcc63ed5 474 public function buildCondition(PlFilter &$uf)
7e735012 475 {
d7ddf29b 476 $uf->requireProfiles();
7e735012
FB
477 return 'p.last_change ' . $this->comparison . XDB::format(' {?}', date('Y-m-d H:i:s', $this->date));
478 }
479}
8363588b 480// }}}
7e735012 481
8363588b 482// {{{ class UFC_Birthday
53eae167
RB
483/** Filters users based on next birthday date
484 * @param $comparison Comparison operator
485 * @param $date Date to which users next birthday date should be compared
486 */
7e735012
FB
487class UFC_Birthday implements UserFilterCondition
488{
489 private $comparison;
490 private $date;
491
492 public function __construct($comparison = null, $date = null)
493 {
494 $this->comparison = $comparison;
495 $this->date = $date;
496 }
497
dcc63ed5 498 public function buildCondition(PlFilter &$uf)
7e735012 499 {
d7ddf29b 500 $uf->requireProfiles();
7e735012
FB
501 return 'p.next_birthday ' . $this->comparison . XDB::format(' {?}', date('Y-m-d', $this->date));
502 }
503}
8363588b 504// }}}
7e735012 505
8363588b 506// {{{ class UFC_Sex
53eae167
RB
507/** Filters users based on sex
508 * @parm $sex One of User::GENDER_MALE or User::GENDER_FEMALE, for selecting users
509 */
4927ee54
FB
510class UFC_Sex implements UserFilterCondition
511{
512 private $sex;
513 public function __construct($sex)
514 {
515 $this->sex = $sex;
516 }
517
dcc63ed5 518 public function buildCondition(PlFilter &$uf)
4927ee54
FB
519 {
520 if ($this->sex != User::GENDER_MALE && $this->sex != User::GENDER_FEMALE) {
521 return self::COND_FALSE;
522 } else {
d7ddf29b 523 $uf->requireProfiles();
24e08e33 524 return XDB::format('p.sex = {?}', $this->sex == User::GENDER_FEMALE ? 'female' : 'male');
4927ee54
FB
525 }
526 }
527}
8363588b 528// }}}
4927ee54 529
8363588b 530// {{{ class UFC_Group
53eae167 531/** Filters users based on group membership
5d2e55c7
RB
532 * @param $group Group whose members we are selecting
533 * @param $anim Whether to restrict selection to animators of that group
53eae167 534 */
4927ee54
FB
535class UFC_Group implements UserFilterCondition
536{
537 private $group;
5d2e55c7
RB
538 private $anim;
539 public function __construct($group, $anim = false)
4927ee54
FB
540 {
541 $this->group = $group;
5d2e55c7 542 $this->anim = $anim;
4927ee54
FB
543 }
544
dcc63ed5 545 public function buildCondition(PlFilter &$uf)
4927ee54
FB
546 {
547 $sub = $uf->addGroupFilter($this->group);
548 $where = 'gpm' . $sub . '.perms IS NOT NULL';
5d2e55c7 549 if ($this->anim) {
4927ee54
FB
550 $where .= ' AND gpm' . $sub . '.perms = \'admin\'';
551 }
552 return $where;
553 }
554}
8363588b 555// }}}
4927ee54 556
0fb3713c 557// {{{ class UFC_Binet
d7ddf29b
RB
558/** Selects users based on their belonging to a given (list of) binet
559 * @param $binet either a binet_id or an array of binet_ids
560 */
0fb3713c
RB
561class UFC_Binet implements UserFilterCondition
562{
d7ddf29b 563 private $val;
0fb3713c 564
d7ddf29b 565 public function __construct($val)
0fb3713c 566 {
d7ddf29b
RB
567 if (!is_array($val)) {
568 $val = array($val);
569 }
570 $this->val = $val;
0fb3713c
RB
571 }
572
573 public function buildCondition(PlFilter &$uf)
574 {
d7ddf29b
RB
575 $sub = $uf->addBinetsFilter();
576 return $sub . '.binet_id IN ' . XDB::formatArray($this->val);
a7f8e48a
RB
577 }
578}
579// }}}
580
581// {{{ class UFC_Section
46e88fe3
RB
582/** Selects users based on section
583 * @param $section ID of the section
584 */
a7f8e48a
RB
585class UFC_Section implements UserFilterCondition
586{
587 private $section;
588
589 public function __construct($section)
590 {
591 $this->section = $section;
592 }
593
594 public function buildCondition(PlFilter &$uf)
595 {
596 $uf->requireProfiles();
597 return 'p.section = ' . XDB::format('{?}', $this->section);
0fb3713c
RB
598 }
599}
600// }}}
601
8363588b 602// {{{ class UFC_Email
53eae167
RB
603/** Filters users based on email address
604 * @param $email Email whose owner we are looking for
605 */
aa21c568
FB
606class UFC_Email implements UserFilterCondition
607{
608 private $email;
609 public function __construct($email)
610 {
611 $this->email = $email;
612 }
613
dcc63ed5 614 public function buildCondition(PlFilter &$uf)
aa21c568
FB
615 {
616 if (User::isForeignEmailAddress($this->email)) {
617 $sub = $uf->addEmailRedirectFilter($this->email);
618 return XDB::format('e' . $sub . '.email IS NOT NULL OR a.email = {?}', $this->email);
21401768
FB
619 } else if (User::isVirtualEmailAddress($this->email)) {
620 $sub = $uf->addVirtualEmailFilter($this->email);
621 return 'vr' . $sub . '.redirect IS NOT NULL';
aa21c568 622 } else {
21401768
FB
623 @list($user, $domain) = explode('@', $this->email);
624 $sub = $uf->addAliasFilter($user);
aa21c568
FB
625 return 'al' . $sub . '.alias IS NOT NULL';
626 }
627 }
628}
8363588b 629// }}}
d865c296 630
8363588b 631// {{{ class UFC_EmailList
5d2e55c7 632/** Filters users based on an email list
53eae167
RB
633 * @param $emails List of emails whose owner must be selected
634 */
21401768
FB
635class UFC_EmailList implements UserFilterCondition
636{
637 private $emails;
638 public function __construct($emails)
639 {
640 $this->emails = $emails;
641 }
642
dcc63ed5 643 public function buildCondition(PlFilter &$uf)
21401768
FB
644 {
645 $email = null;
646 $virtual = null;
647 $alias = null;
648 $cond = array();
649
650 if (count($this->emails) == 0) {
dcc63ed5 651 return PlFilterCondition::COND_TRUE;
21401768
FB
652 }
653
654 foreach ($this->emails as $entry) {
655 if (User::isForeignEmailAddress($entry)) {
656 if (is_null($email)) {
657 $email = $uf->addEmailRedirectFilter();
658 }
659 $cond[] = XDB::format('e' . $email . '.email = {?} OR a.email = {?}', $entry, $entry);
660 } else if (User::isVirtualEmailAddress($entry)) {
661 if (is_null($virtual)) {
662 $virtual = $uf->addVirtualEmailFilter();
663 }
664 $cond[] = XDB::format('vr' . $virtual . '.redirect IS NOT NULL AND v' . $virtual . '.alias = {?}', $entry);
665 } else {
666 if (is_null($alias)) {
667 $alias = $uf->addAliasFilter();
668 }
669 @list($user, $domain) = explode('@', $entry);
670 $cond[] = XDB::format('al' . $alias . '.alias = {?}', $user);
671 }
672 }
673 return '(' . implode(') OR (', $cond) . ')';
674 }
675}
8363588b 676// }}}
d865c296 677
8363588b 678// {{{ class UFC_Address
2b9ca54d 679abstract class UFC_Address implements UserFilterCondition
c4b24511 680{
2b9ca54d 681 /** Valid address type ('hq' is reserved for company addresses)
036d1637 682 */
2b9ca54d
RB
683 const TYPE_HOME = 1;
684 const TYPE_PRO = 2;
685 const TYPE_ANY = 3;
c4b24511 686
2b9ca54d 687 /** Text for these types
036d1637 688 */
2b9ca54d
RB
689 protected static $typetexts = array(
690 self::TYPE_HOME => 'home',
691 self::TYPE_PRO => 'pro',
692 );
693
694 protected $type;
c4b24511 695
036d1637
RB
696 /** Flags for addresses
697 */
698 const FLAG_CURRENT = 0x0001;
699 const FLAG_TEMP = 0x0002;
700 const FLAG_SECOND = 0x0004;
701 const FLAG_MAIL = 0x0008;
702 const FLAG_CEDEX = 0x0010;
703
704 // Binary OR of those flags
705 const FLAG_ANY = 0x001F;
706
707 /** Text of these flags
708 */
2b9ca54d 709 protected static $flagtexts = array(
036d1637
RB
710 self::FLAG_CURRENT => 'current',
711 self::FLAG_TEMP => 'temporary',
712 self::FLAG_SECOND => 'secondary',
713 self::FLAG_MAIL => 'mail',
714 self::FLAG_CEDEX => 'cedex',
715 );
716
2b9ca54d
RB
717 protected $flags;
718
719 public function __construct($type = null, $flags = null)
720 {
721 $this->type = $type;
722 $this->flags = $flags;
723 }
724
725 protected function initConds($sub)
726 {
727 $conds = array();
728 $types = array();
729 foreach (self::$typetexts as $flag => $type) {
730 if ($flag & $this->type) {
731 $types[] = $type;
732 }
733 }
734 if (count($types)) {
735 $conds[] = $sub . '.type IN ' . XDB::formatArray($types);
736 }
737
738 if ($this->flags != self::FLAG_ANY) {
739 foreach(self::$flagtexts as $flag => $text) {
740 if ($flag & $this->flags) {
741 $conds[] = 'FIND_IN_SET(' . XDB::format('{?}', $text) . ', ' . $sub . '.flags)';
742 }
743 }
744 }
745 return $conds;
746 }
747
748}
749// }}}
750
751// {{{ class UFC_AddressText
752/** Select users based on their address, using full text search
753 * @param $text Text for filter in fulltext search
658b4c83 754 * @param $textSearchMode Mode for search (one of XDB::WILDCARD_*)
2b9ca54d
RB
755 * @param $type Filter on address type
756 * @param $flags Filter on address flags
757 * @param $country Filter on address country
758 * @param $locality Filter on address locality
759 */
760class UFC_AddressText extends UFC_Address
761{
2b9ca54d 762
036d1637 763 private $text;
2b9ca54d
RB
764 private $textSearchMode;
765
658b4c83 766 public function __construct($text = null, $textSearchMode = XDB::WILDCARD_CONTAINS,
2b9ca54d
RB
767 $type = null, $flags = self::FLAG_ANY, $country = null, $locality = null)
768 {
769 parent::__construct($type, $flags);
770 $this->text = $text;
771 $this->textSearchMode = $textSearchMode;
772 $this->country = $country;
773 $this->locality = $locality;
774 }
775
776 private function mkMatch($txt)
777 {
658b4c83 778 return XDB::formatWildcards($this->textSearchMode, $txt);
2b9ca54d
RB
779 }
780
781 public function buildCondition(PlFilter &$uf)
782 {
783 $sub = $uf->addAddressFilter();
784 $conds = $this->initConds($sub);
785 if ($this->text != null) {
786 $conds[] = $sub . '.text' . $this->mkMatch($this->text);
787 }
788
789 if ($this->country != null) {
790 $subc = $uf->addAddressCountryFilter();
791 $subconds = array();
792 $subconds[] = $subc . '.country' . $this->mkMatch($this->country);
793 $subconds[] = $subc . '.countryFR' . $this->mkMatch($this->country);
794 $conds[] = implode(' OR ', $subconds);
795 }
796
797 if ($this->locality != null) {
798 $subl = $uf->addAddressLocalityFilter();
799 $conds[] = $subl . '.name' . $this->mkMatch($this->locality);
800 }
801
802 return implode(' AND ', $conds);
803 }
804}
805// }}}
806
46e88fe3 807// {{{ class UFC_AddressField
2b9ca54d 808/** Filters users based on their address,
46e88fe3
RB
809 * @param $val Either a code for one of the fields, or an array of such codes
810 * @param $fieldtype The type of field to look for
2b9ca54d
RB
811 * @param $type Filter on address type
812 * @param $flags Filter on address flags
2b9ca54d 813 */
46e88fe3 814class UFC_AddressField extends UFC_Address
2b9ca54d 815{
46e88fe3
RB
816 const FIELD_COUNTRY = 1;
817 const FIELD_ADMAREA = 2;
818 const FIELD_SUBADMAREA = 3;
819 const FIELD_LOCALITY = 4;
820 const FIELD_ZIPCODE = 5;
821
2b9ca54d
RB
822 /** Data of the filter
823 */
46e88fe3
RB
824 private $val;
825 private $fieldtype;
036d1637 826
46e88fe3 827 public function __construct($val, $fieldtype, $type = null, $flags = self::FLAG_ANY)
036d1637 828 {
2b9ca54d 829 parent::__construct($type, $flags);
46e88fe3
RB
830
831 if (!is_array($val)) {
832 $val = array($val);
833 }
834 $this->val = $val;
835 $this->fieldtype = $fieldtype;
c4b24511
RB
836 }
837
dcc63ed5 838 public function buildCondition(PlFilter &$uf)
c4b24511 839 {
036d1637 840 $sub = $uf->addAddressFilter();
d7ddf29b 841 $conds = $this->initConds($sub);
036d1637 842
46e88fe3
RB
843 switch ($this->fieldtype) {
844 case self::FIELD_COUNTRY:
845 $field = 'countryId';
846 break;
847 case self::FIELD_ADMAREA:
848 $field = 'administrativeAreaId';
849 break;
850 case self::FIELD_SUBADMAREA:
851 $field = 'subAdministrativeAreaId';
852 break;
853 case self::FIELD_LOCALITY:
854 $field = 'localityId';
855 break;
856 case self::FIELD_ZIPCODE:
857 $field = 'postalCode';
858 break;
859 default:
61f61261 860 Platal::page()->killError('Invalid address field type: ' . $this->fieldtype);
46e88fe3
RB
861 }
862 $conds[] = $sub . '.' . $field . ' IN ' . XDB::formatArray($this->val);
036d1637
RB
863
864 return implode(' AND ', $conds);
c4b24511
RB
865 }
866}
8363588b 867// }}}
c4b24511 868
8363588b 869// {{{ class UFC_Corps
4083b126
RB
870/** Filters users based on the corps they belong to
871 * @param $corps Corps we are looking for (abbreviation)
872 * @param $type Whether we search for original or current corps
873 */
874class UFC_Corps implements UserFilterCondition
875{
5d2e55c7
RB
876 const CURRENT = 1;
877 const ORIGIN = 2;
4083b126
RB
878
879 private $corps;
880 private $type;
881
882 public function __construct($corps, $type = self::CURRENT)
883 {
884 $this->corps = $corps;
885 $this->type = $type;
886 }
887
dcc63ed5 888 public function buildCondition(PlFilter &$uf)
4083b126 889 {
5d2e55c7
RB
890 /** Tables shortcuts:
891 * pc for profile_corps,
4083b126
RB
892 * pceo for profile_corps_enum - orginal
893 * pcec for profile_corps_enum - current
894 */
895 $sub = $uf->addCorpsFilter($this->type);
896 $cond = $sub . '.abbreviation = ' . $corps;
897 return $cond;
898 }
899}
8363588b 900// }}}
4083b126 901
8363588b 902// {{{ class UFC_Corps_Rank
4083b126
RB
903/** Filters users based on their rank in the corps
904 * @param $rank Rank we are looking for (abbreviation)
905 */
906class UFC_Corps_Rank implements UserFilterCondition
907{
908 private $rank;
909 public function __construct($rank)
910 {
911 $this->rank = $rank;
912 }
913
dcc63ed5 914 public function buildCondition(PlFilter &$uf)
4083b126 915 {
5d2e55c7 916 /** Tables shortcuts:
4083b126
RB
917 * pcr for profile_corps_rank
918 */
919 $sub = $uf->addCorpsRankFilter();
920 $cond = $sub . '.abbreviation = ' . $rank;
921 return $cond;
922 }
923}
8363588b 924// }}}
4083b126 925
6a99c3ac
RB
926// {{{ class UFC_Job_Company
927/** Filters users based on the company they belong to
928 * @param $type The field being searched (self::JOBID, self::JOBNAME or self::JOBACRONYM)
929 * @param $value The searched value
930 */
4e2f2ad2 931class UFC_Job_Company implements UserFilterCondition
6a99c3ac
RB
932{
933 const JOBID = 'id';
934 const JOBNAME = 'name';
935 const JOBACRONYM = 'acronym';
936
937 private $type;
938 private $value;
939
940 public function __construct($type, $value)
941 {
942 $this->assertType($type);
943 $this->type = $type;
944 $this->value = $value;
945 }
946
947 private function assertType($type)
948 {
949 if ($type != self::JOBID && $type != self::JOBNAME && $type != self::JOBACRONYM) {
5d2e55c7 950 Platal::page()->killError("Type de recherche non valide.");
6a99c3ac
RB
951 }
952 }
953
dcc63ed5 954 public function buildCondition(PlFilter &$uf)
6a99c3ac
RB
955 {
956 $sub = $uf->addJobCompanyFilter();
957 $cond = $sub . '.' . $this->type . ' = ' . XDB::format('{?}', $this->value);
958 return $cond;
959 }
960}
961// }}}
962
963// {{{ class UFC_Job_Sectorization
964/** Filters users based on the ((sub)sub)sector they work in
46e88fe3 965 * @param $val The ID of the sector, or an array of such IDs
d7ddf29b 966 * @param $type The kind of search (subsubsector/subsector/sector)
6a99c3ac 967 */
4e2f2ad2 968class UFC_Job_Sectorization implements UserFilterCondition
6a99c3ac 969{
d7ddf29b
RB
970 private $val;
971 private $type;
6a99c3ac 972
d7ddf29b
RB
973 public function __construct($val, $type = UserFilter::JOB_SECTOR)
974 {
975 self::assertType($type);
46e88fe3
RB
976 if (!is_array($val)) {
977 $val = array($val);
978 }
d7ddf29b
RB
979 $this->val = $val;
980 $this->type = $type;
981 }
6a99c3ac 982
d7ddf29b 983 private static function assertType($type)
6a99c3ac 984 {
d7ddf29b
RB
985 if ($type != UserFilter::JOB_SECTOR && $type != UserFilter::JOB_SUBSECTOR && $type != UserFilter::JOB_SUBSUBSECTOR) {
986 Platal::page()->killError("Type de secteur non valide.");
987 }
6a99c3ac
RB
988 }
989
dcc63ed5 990 public function buildCondition(PlFilter &$uf)
6a99c3ac 991 {
d7ddf29b
RB
992 $sub = $uf->addJobSectorizationFilter($this->type);
993 return $sub . '.id = ' . XDB::format('{?}', $this->val);
6a99c3ac
RB
994 }
995}
996// }}}
997
998// {{{ class UFC_Job_Description
999/** Filters users based on their job description
1000 * @param $description The text being searched for
1001 * @param $fields The fields to search for (user-defined, ((sub|)sub|)sector)
1002 */
4e2f2ad2 1003class UFC_Job_Description implements UserFilterCondition
6a99c3ac
RB
1004{
1005
6a99c3ac
RB
1006 private $description;
1007 private $fields;
1008
01cc5f9e 1009 public function __construct($description, $fields)
6a99c3ac
RB
1010 {
1011 $this->fields = $fields;
1012 $this->description = $description;
1013 }
1014
dcc63ed5 1015 public function buildCondition(PlFilter &$uf)
6a99c3ac
RB
1016 {
1017 $conds = array();
1018 if ($this->fields & UserFilter::JOB_USERDEFINED) {
1019 $sub = $uf->addJobFilter();
658b4c83 1020 $conds[] = $sub . '.description ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
6a99c3ac 1021 }
01cc5f9e
RB
1022 if ($this->fields & UserFilter::JOB_CV) {
1023 $uf->requireProfiles();
658b4c83 1024 $conds[] = 'p.cv ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
01cc5f9e 1025 }
6a99c3ac
RB
1026 if ($this->fields & UserFilter::JOB_SECTOR) {
1027 $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SECTOR);
658b4c83 1028 $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
6a99c3ac
RB
1029 }
1030 if ($this->fields & UserFilter::JOB_SUBSECTOR) {
1031 $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSECTOR);
658b4c83 1032 $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
6a99c3ac
RB
1033 }
1034 if ($this->fields & UserFilter::JOB_SUBSUBSECTOR) {
1035 $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSUBSECTOR);
658b4c83 1036 $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
6a99c3ac 1037 $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_ALTERNATES);
658b4c83 1038 $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
6a99c3ac
RB
1039 }
1040 return implode(' OR ', $conds);
1041 }
1042}
1043// }}}
1044
0a2e9c74
RB
1045// {{{ class UFC_Networking
1046/** Filters users based on network identity (IRC, ...)
1047 * @param $type Type of network (-1 for any)
1048 * @param $value Value to search
1049 */
4e2f2ad2 1050class UFC_Networking implements UserFilterCondition
0a2e9c74
RB
1051{
1052 private $type;
1053 private $value;
1054
1055 public function __construct($type, $value)
1056 {
1057 $this->type = $type;
1058 $this->value = $value;
1059 }
1060
dcc63ed5 1061 public function buildCondition(PlFilter &$uf)
0a2e9c74
RB
1062 {
1063 $sub = $uf->addNetworkingFilter();
1064 $conds = array();
658b4c83 1065 $conds[] = $sub . '.address ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
0a2e9c74
RB
1066 if ($this->type != -1) {
1067 $conds[] = $sub . '.network_type = ' . XDB::format('{?}', $this->type);
1068 }
1069 return implode(' AND ', $conds);
1070 }
1071}
1072// }}}
1073
6d62969e
RB
1074// {{{ class UFC_Phone
1075/** Filters users based on their phone number
1076 * @param $num_type Type of number (pro/user/home)
1077 * @param $phone_type Type of phone (fixed/mobile/fax)
1078 * @param $number Phone number
1079 */
4e2f2ad2 1080class UFC_Phone implements UserFilterCondition
6d62969e
RB
1081{
1082 const NUM_PRO = 'pro';
1083 const NUM_USER = 'user';
1084 const NUM_HOME = 'address';
1085 const NUM_ANY = 'any';
1086
1087 const PHONE_FIXED = 'fixed';
1088 const PHONE_MOBILE = 'mobile';
1089 const PHONE_FAX = 'fax';
1090 const PHONE_ANY = 'any';
1091
1092 private $num_type;
1093 private $phone_type;
1094 private $number;
1095
1096 public function __construct($number, $num_type = self::NUM_ANY, $phone_type = self::PHONE_ANY)
1097 {
9b8e5fb4 1098 require_once('profil.func.inc.php');
6d62969e
RB
1099 $this->number = $number;
1100 $this->num_type = $num_type;
1101 $this->phone_type = format_phone_number($phone_type);
1102 }
1103
dcc63ed5 1104 public function buildCondition(PlFilter &$uf)
6d62969e
RB
1105 {
1106 $sub = $uf->addPhoneFilter();
1107 $conds = array();
1108 $conds[] = $sub . '.search_tel = ' . XDB::format('{?}', $this->number);
1109 if ($this->num_type != self::NUM_ANY) {
1110 $conds[] = $sub . '.link_type = ' . XDB::format('{?}', $this->num_type);
1111 }
1112 if ($this->phone_type != self::PHONE_ANY) {
1113 $conds[] = $sub . '.tel_type = ' . XDB::format('{?}', $this->phone_type);
1114 }
1115 return implode(' AND ', $conds);
1116 }
1117}
1118// }}}
1119
ceb512d2
RB
1120// {{{ class UFC_Medal
1121/** Filters users based on their medals
1122 * @param $medal ID of the medal
1123 * @param $grade Grade of the medal (null for 'any')
1124 */
4e2f2ad2 1125class UFC_Medal implements UserFilterCondition
ceb512d2
RB
1126{
1127 private $medal;
1128 private $grade;
1129
1130 public function __construct($medal, $grade = null)
1131 {
1132 $this->medal = $medal;
1133 $this->grade = $grade;
1134 }
1135
dcc63ed5 1136 public function buildCondition(PlFilter &$uf)
ceb512d2
RB
1137 {
1138 $conds = array();
1139 $sub = $uf->addMedalFilter();
1140 $conds[] = $sub . '.mid = ' . XDB::format('{?}', $this->medal);
1141 if ($this->grade != null) {
1142 $conds[] = $sub . '.gid = ' . XDB::format('{?}', $this->grade);
1143 }
1144 return implode(' AND ', $conds);
1145 }
1146}
1147// }}}
1148
671b7073
RB
1149// {{{ class UFC_Mentor_Expertise
1150/** Filters users by mentoring expertise
1151 * @param $expertise Domain of expertise
1152 */
4e2f2ad2 1153class UFC_Mentor_Expertise implements UserFilterCondition
671b7073
RB
1154{
1155 private $expertise;
1156
1157 public function __construct($expertise)
1158 {
1159 $this->expertise = $expertise;
1160 }
1161
dcc63ed5 1162 public function buildCondition(PlFilter &$uf)
671b7073
RB
1163 {
1164 $sub = $uf->addMentorFilter(UserFilter::MENTOR_EXPERTISE);
658b4c83 1165 return $sub . '.expertise ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->expertise);
671b7073
RB
1166 }
1167}
1168// }}}
1169
1170// {{{ class UFC_Mentor_Country
1171/** Filters users by mentoring country
1172 * @param $country Two-letters code of country being searched
1173 */
4e2f2ad2 1174class UFC_Mentor_Country implements UserFilterCondition
671b7073
RB
1175{
1176 private $country;
1177
1178 public function __construct($country)
1179 {
1180 $this->country = $country;
1181 }
1182
dcc63ed5 1183 public function buildCondition(PlFilter &$uf)
671b7073
RB
1184 {
1185 $sub = $uf->addMentorFilter(UserFilter::MENTOR_COUNTRY);
1186 return $sub . '.country = ' . XDB::format('{?}', $this->country);
1187 }
1188}
1189// }}}
1190
1191// {{{ class UFC_Mentor_Sectorization
1192/** Filters users based on mentoring (sub|)sector
c5da8574
RB
1193 * @param $sector ID of (sub)sector
1194 * @param $type Whether we are looking for a sector or a subsector
671b7073 1195 */
4e2f2ad2 1196class UFC_Mentor_Sectorization implements UserFilterCondition
671b7073 1197{
c5da8574
RB
1198 const SECTOR = 1;
1199 const SUBSECTOR = 2;
671b7073 1200 private $sector;
c5da8574 1201 private $type;
671b7073 1202
c5da8574 1203 public function __construct($sector, $type = self::SECTOR)
671b7073
RB
1204 {
1205 $this->sector = $sector;
c5da8574 1206 $this->type = $type;
671b7073
RB
1207 }
1208
dcc63ed5 1209 public function buildCondition(PlFilter &$uf)
671b7073
RB
1210 {
1211 $sub = $uf->addMentorFilter(UserFilter::MENTOR_SECTOR);
c5da8574
RB
1212 if ($this->type == self::SECTOR) {
1213 $field = 'sectorid';
1214 } else {
1215 $field = 'subsectorid';
671b7073 1216 }
c5da8574 1217 return $sub . '.' . $field . ' = ' . XDB::format('{?}', $this->sector);
671b7073
RB
1218 }
1219}
1220// }}}
1221
8363588b 1222// {{{ class UFC_UserRelated
5d2e55c7 1223/** Filters users based on a relation toward a user
53eae167
RB
1224 * @param $user User to which searched users are related
1225 */
4e7bf1e0 1226abstract class UFC_UserRelated implements UserFilterCondition
3f42a6ad 1227{
009b8ab7
FB
1228 protected $user;
1229 public function __construct(PlUser &$user)
1230 {
1231 $this->user =& $user;
3f42a6ad 1232 }
4e7bf1e0 1233}
8363588b 1234// }}}
3f42a6ad 1235
8363588b 1236// {{{ class UFC_Contact
5d2e55c7 1237/** Filters users who belong to selected user's contacts
53eae167 1238 */
4e7bf1e0
FB
1239class UFC_Contact extends UFC_UserRelated
1240{
dcc63ed5 1241 public function buildCondition(PlFilter &$uf)
3f42a6ad 1242 {
009b8ab7 1243 $sub = $uf->addContactFilter($this->user->id());
3f42a6ad
FB
1244 return 'c' . $sub . '.contact IS NOT NULL';
1245 }
1246}
8363588b 1247// }}}
3f42a6ad 1248
8363588b 1249// {{{ class UFC_WatchRegistration
53eae167
RB
1250/** Filters users being watched by selected user
1251 */
4e7bf1e0
FB
1252class UFC_WatchRegistration extends UFC_UserRelated
1253{
dcc63ed5 1254 public function buildCondition(PlFilter &$uf)
4e7bf1e0 1255 {
a87530ea 1256 if (!$this->user->watchType('registration')) {
dcc63ed5 1257 return PlFilterCondition::COND_FALSE;
009b8ab7
FB
1258 }
1259 $uids = $this->user->watchUsers();
1260 if (count($uids) == 0) {
dcc63ed5 1261 return PlFilterCondition::COND_FALSE;
009b8ab7 1262 } else {
07eb5b0e 1263 return '$UID IN ' . XDB::formatArray($uids);
009b8ab7 1264 }
4e7bf1e0
FB
1265 }
1266}
8363588b 1267// }}}
4e7bf1e0 1268
8363588b 1269// {{{ class UFC_WatchPromo
53eae167
RB
1270/** Filters users belonging to a promo watched by selected user
1271 * @param $user Selected user (the one watching promo)
1272 * @param $grade Formation the user is watching
1273 */
4e7bf1e0
FB
1274class UFC_WatchPromo extends UFC_UserRelated
1275{
1276 private $grade;
009b8ab7 1277 public function __construct(PlUser &$user, $grade = UserFilter::GRADE_ING)
4e7bf1e0 1278 {
009b8ab7 1279 parent::__construct($user);
4e7bf1e0
FB
1280 $this->grade = $grade;
1281 }
1282
dcc63ed5 1283 public function buildCondition(PlFilter &$uf)
4e7bf1e0 1284 {
009b8ab7
FB
1285 $promos = $this->user->watchPromos();
1286 if (count($promos) == 0) {
dcc63ed5 1287 return PlFilterCondition::COND_FALSE;
009b8ab7
FB
1288 } else {
1289 $sube = $uf->addEducationFilter(true, $this->grade);
1290 $field = 'pe' . $sube . '.' . UserFilter::promoYear($this->grade);
07eb5b0e 1291 return $field . ' IN ' . XDB::formatArray($promos);
009b8ab7 1292 }
4e7bf1e0
FB
1293 }
1294}
8363588b 1295// }}}
4e7bf1e0 1296
8363588b 1297// {{{ class UFC_WatchContact
53eae167
RB
1298/** Filters users watched by selected user
1299 */
009b8ab7 1300class UFC_WatchContact extends UFC_Contact
4e7bf1e0 1301{
dcc63ed5 1302 public function buildCondition(PlFilter &$uf)
4e7bf1e0 1303 {
009b8ab7 1304 if (!$this->user->watchContacts()) {
dcc63ed5 1305 return PlFilterCondition::COND_FALSE;
009b8ab7
FB
1306 }
1307 return parent::buildCondition($uf);
4e7bf1e0
FB
1308 }
1309}
8363588b 1310// }}}
4e7bf1e0 1311
48885bbe
FB
1312// {{{ class UFC_MarketingHash
1313/** Filters users using the hash generated
1314 * to send marketing emails to him.
1315 */
1316class UFC_MarketingHash implements UserFilterCondition
1317{
1318 private $hash;
1319
1320 public function __construct($hash)
1321 {
1322 $this->hash = $hash;
1323 }
1324
1325 public function buildCondition(PlFilter &$uf)
1326 {
1327 $table = $uf->addMarketingHash();
1328 return XDB::format('rm.hash = {?}', $this->hash);
1329 }
1330}
4e7bf1e0 1331
d865c296
FB
1332/******************
1333 * ORDERS
1334 ******************/
1335
8363588b 1336// {{{ class UserFilterOrder
2d83cac9
RB
1337/** Base class for ordering results of a query.
1338 * Parameters for the ordering must be given to the constructor ($desc for a
1339 * descending order).
1340 * The getSortTokens function is used to get actual ordering part of the query.
1341 */
7ca75030 1342abstract class UserFilterOrder extends PlFilterOrder
d865c296 1343{
2d83cac9
RB
1344 /** This function must return the tokens to use for ordering
1345 * @param &$uf The UserFilter whose results must be ordered
1346 * @return The name of the field to use for ordering results
1347 */
61f61261 1348// abstract protected function getSortTokens(UserFilter &$uf);
d865c296 1349}
8363588b 1350// }}}
d865c296 1351
8363588b 1352// {{{ class UFO_Promo
5d2e55c7
RB
1353/** Orders users by promotion
1354 * @param $grade Formation whose promotion users should be sorted by (restricts results to users of that formation)
53eae167
RB
1355 * @param $desc Whether sort is descending
1356 */
d865c296
FB
1357class UFO_Promo extends UserFilterOrder
1358{
1359 private $grade;
1360
1361 public function __construct($grade = null, $desc = false)
1362 {
009b8ab7 1363 parent::__construct($desc);
d865c296 1364 $this->grade = $grade;
d865c296
FB
1365 }
1366
61f61261 1367 protected function getSortTokens(PlFilter &$uf)
d865c296
FB
1368 {
1369 if (UserFilter::isGrade($this->grade)) {
1370 $sub = $uf->addEducationFilter($this->grade);
1371 return 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
1372 } else {
1373 $sub = $uf->addDisplayFilter();
1374 return 'pd' . $sub . '.promo';
1375 }
1376 }
1377}
8363588b 1378// }}}
d865c296 1379
8363588b 1380// {{{ class UFO_Name
53eae167 1381/** Sorts users by name
5d2e55c7
RB
1382 * @param $type Type of name on which to sort (firstname...)
1383 * @param $variant Variant of that name to use (marital, ordinary...)
53eae167
RB
1384 * @param $particle Set to true if particles should be included in the sorting order
1385 * @param $desc If sort order should be descending
1386 */
d865c296
FB
1387class UFO_Name extends UserFilterOrder
1388{
1389 private $type;
1390 private $variant;
1391 private $particle;
1392
1393 public function __construct($type, $variant = null, $particle = false, $desc = false)
1394 {
009b8ab7 1395 parent::__construct($desc);
d865c296
FB
1396 $this->type = $type;
1397 $this->variant = $variant;
1398 $this->particle = $particle;
d865c296
FB
1399 }
1400
61f61261 1401 protected function getSortTokens(PlFilter &$uf)
d865c296 1402 {
913a4e90 1403 if (Profile::isDisplayName($this->type)) {
d865c296
FB
1404 $sub = $uf->addDisplayFilter();
1405 return 'pd' . $sub . '.' . $this->type;
1406 } else {
1407 $sub = $uf->addNameFilter($this->type, $this->variant);
1408 if ($this->particle) {
1409 return 'CONCAT(pn' . $sub . '.particle, \' \', pn' . $sub . '.name)';
1410 } else {
1411 return 'pn' . $sub . '.name';
1412 }
1413 }
1414 }
1415}
8363588b 1416// }}}
d865c296 1417
40585144
RB
1418// {{{ class UFO_Score
1419class UFO_Score extends UserFilterOrder
1420{
61f61261 1421 protected function getSortTokens(PlFilter &$uf)
40585144
RB
1422 {
1423 $sub = $uf->addNameTokensFilter();
1424 return 'SUM(' . $sub . '.score)';
1425 }
1426}
1427// }}}
1428
8363588b 1429// {{{ class UFO_Registration
53eae167
RB
1430/** Sorts users based on registration date
1431 */
38c6fe96
FB
1432class UFO_Registration extends UserFilterOrder
1433{
61f61261 1434 protected function getSortTokens(PlFilter &$uf)
38c6fe96 1435 {
009b8ab7 1436 return 'a.registration_date';
38c6fe96 1437 }
009b8ab7 1438}
8363588b 1439// }}}
38c6fe96 1440
8363588b 1441// {{{ class UFO_Birthday
53eae167
RB
1442/** Sorts users based on next birthday date
1443 */
009b8ab7
FB
1444class UFO_Birthday extends UserFilterOrder
1445{
61f61261 1446 protected function getSortTokens(PlFilter &$uf)
38c6fe96 1447 {
009b8ab7 1448 return 'p.next_birthday';
38c6fe96
FB
1449 }
1450}
8363588b 1451// }}}
38c6fe96 1452
8363588b 1453// {{{ class UFO_ProfileUpdate
53eae167
RB
1454/** Sorts users based on last profile update
1455 */
009b8ab7
FB
1456class UFO_ProfileUpdate extends UserFilterOrder
1457{
61f61261 1458 protected function getSortTokens(PlFilter &$uf)
009b8ab7
FB
1459 {
1460 return 'p.last_change';
1461 }
1462}
8363588b 1463// }}}
009b8ab7 1464
8363588b 1465// {{{ class UFO_Death
53eae167
RB
1466/** Sorts users based on death date
1467 */
009b8ab7
FB
1468class UFO_Death extends UserFilterOrder
1469{
61f61261 1470 protected function getSortTokens(PlFilter &$uf)
009b8ab7
FB
1471 {
1472 return 'p.deathdate';
1473 }
1474}
8363588b 1475// }}}
009b8ab7
FB
1476
1477
d865c296
FB
1478/***********************************
1479 *********************************
1480 USER FILTER CLASS
1481 *********************************
1482 ***********************************/
1483
8363588b 1484// {{{ class UserFilter
2d83cac9
RB
1485/** This class provides a convenient and centralized way of filtering users.
1486 *
1487 * Usage:
1488 * $uf = new UserFilter(new UFC_Blah($x, $y), new UFO_Coin($z, $t));
1489 *
1490 * Resulting UserFilter can be used to:
1491 * - get a list of User objects matching the filter
1492 * - get a list of UIDs matching the filter
1493 * - get the number of users matching the filter
1494 * - check whether a given User matches the filter
1495 * - filter a list of User objects depending on whether they match the filter
1496 *
1497 * Usage for UFC and UFO objects:
1498 * A UserFilter will call all private functions named XXXJoins.
1499 * These functions must return an array containing the list of join
1500 * required by the various UFC and UFO associated to the UserFilter.
1501 * Entries in those returned array are of the following form:
1502 * 'join_tablealias' => array('join_type', 'joined_table', 'join_criter')
1503 * which will be translated into :
1504 * join_type JOIN joined_table AS join_tablealias ON (join_criter)
1505 * in the final query.
1506 *
1507 * In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
913a4e90 1508 * profile.pid, and $UID with accounts.uid.
2d83cac9
RB
1509 *
1510 * For each kind of "JOIN" needed, a function named addXXXFilter() should be defined;
1511 * its parameter will be used to set various private vars of the UserFilter describing
1512 * the required joins ; such a function shall return the "join_tablealias" to use
1513 * when referring to the joined table.
1514 *
1515 * For example, if data from profile_job must be available to filter results,
1516 * the UFC object will call $uf-addJobFilter(), which will set the 'with_pj' var and
1517 * return 'pj', the short name to use when referring to profile_job; when building
1518 * the query, calling the jobJoins function will return an array containing a single
1519 * row:
1520 * 'pj' => array('left', 'profile_job', '$ME.pid = $UID');
1521 *
1522 * The 'register_optional' function can be used to generate unique table aliases when
1523 * the same table has to be joined several times with different aliases.
1524 */
9b8e5fb4 1525class UserFilter extends PlFilter
a087cc8d 1526{
9b8e5fb4 1527 protected $joinMethods = array();
7ca75030 1528
61f61261
RB
1529 protected $joinMetas = array(
1530 '$PID' => 'p.pid',
1531 '$UID' => 'a.uid',
9b8e5fb4 1532 );
d865c296 1533
a087cc8d 1534 private $root;
24e08e33 1535 private $sort = array();
784745ce 1536 private $query = null;
24e08e33 1537 private $orderby = null;
784745ce 1538
aa21c568 1539 private $lastcount = null;
d865c296 1540
24e08e33 1541 public function __construct($cond = null, $sort = null)
5dd9d823 1542 {
06598c13 1543 if (empty($this->joinMethods)) {
d865c296
FB
1544 $class = new ReflectionClass('UserFilter');
1545 foreach ($class->getMethods() as $method) {
1546 $name = $method->getName();
1547 if (substr($name, -5) == 'Joins' && $name != 'buildJoins') {
06598c13 1548 $this->joinMethods[] = $name;
d865c296
FB
1549 }
1550 }
1551 }
5dd9d823 1552 if (!is_null($cond)) {
06598c13 1553 if ($cond instanceof PlFilterCondition) {
5dd9d823
FB
1554 $this->setCondition($cond);
1555 }
1556 }
24e08e33
FB
1557 if (!is_null($sort)) {
1558 if ($sort instanceof UserFilterOrder) {
1559 $this->addSort($sort);
d865c296
FB
1560 } else if (is_array($sort)) {
1561 foreach ($sort as $s) {
1562 $this->addSort($s);
1563 }
24e08e33
FB
1564 }
1565 }
5dd9d823
FB
1566 }
1567
784745ce
FB
1568 private function buildQuery()
1569 {
d865c296
FB
1570 if (is_null($this->orderby)) {
1571 $orders = array();
1572 foreach ($this->sort as $sort) {
1573 $orders = array_merge($orders, $sort->buildSort($this));
1574 }
1575 if (count($orders) == 0) {
1576 $this->orderby = '';
1577 } else {
1578 $this->orderby = 'ORDER BY ' . implode(', ', $orders);
1579 }
1580 }
784745ce
FB
1581 if (is_null($this->query)) {
1582 $where = $this->root->buildCondition($this);
f7ea7450
RB
1583 if ($this->with_forced_sn) {
1584 $this->requireProfiles();
1585 $from = 'search_name AS sn';
1586 } else if ($this->with_accounts) {
b8dcf62d
RB
1587 $from = 'accounts AS a';
1588 } else {
1589 $this->requireProfiles();
1590 $from = 'profiles AS p';
1591 }
f7ea7450 1592 $joins = $this->buildJoins();
b8dcf62d 1593 $this->query = 'FROM ' . $from . '
784745ce
FB
1594 ' . $joins . '
1595 WHERE (' . $where . ')';
1596 }
1597 }
1598
7ca75030 1599 private function getUIDList($uids = null, PlLimit &$limit)
d865c296 1600 {
b8dcf62d 1601 $this->requireAccounts();
d865c296 1602 $this->buildQuery();
7ca75030 1603 $lim = $limit->getSql();
d865c296
FB
1604 $cond = '';
1605 if (!is_null($uids)) {
07eb5b0e 1606 $cond = ' AND a.uid IN ' . XDB::formatArray($uids);
d865c296
FB
1607 }
1608 $fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS a.uid
1609 ' . $this->query . $cond . '
1610 GROUP BY a.uid
1611 ' . $this->orderby . '
7ca75030 1612 ' . $lim);
d865c296
FB
1613 $this->lastcount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
1614 return $fetched;
1615 }
1616
043b104b
RB
1617 private function getPIDList($pids = null, PlLimit &$limit)
1618 {
1619 $this->requireProfiles();
1620 $this->buildQuery();
1621 $lim = $limit->getSql();
1622 $cond = '';
1623 if (!is_null($pids)) {
1624 $cond = ' AND p.pid IN ' . XDB::formatArray($pids);
1625 }
1626 $fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS p.pid
1627 ' . $this->query . $cond . '
1628 GROUP BY p.pid
1629 ' . $this->orderby . '
1630 ' . $lim);
1631 $this->lastcount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
1632 return $fetched;
1633 }
1634
434570c4
FB
1635 private static function defaultLimit($limit) {
1636 if ($limit == null) {
1637 return new PlLimit();
1638 } else {
1639 return $limit;
1640 }
1641 }
1642
a087cc8d
FB
1643 /** Check that the user match the given rule.
1644 */
1645 public function checkUser(PlUser &$user)
1646 {
b8dcf62d 1647 $this->requireAccounts();
784745ce
FB
1648 $this->buildQuery();
1649 $count = (int)XDB::fetchOneCell('SELECT COUNT(*)
1650 ' . $this->query . XDB::format(' AND a.uid = {?}', $user->id()));
1651 return $count == 1;
a087cc8d
FB
1652 }
1653
043b104b
RB
1654 /** Check that the profile match the given rule.
1655 */
1656 public function checkProfile(Profile &$profile)
1657 {
1658 $this->requireProfiles();
1659 $this->buildQuery();
1660 $count = (int)XDB::fetchOneCell('SELECT COUNT(*)
1661 ' . $this->query . XDB::format(' AND p.pid = {?}', $profile->id()));
1662 return $count == 1;
1663 }
1664
1665 /** Default filter is on users
a087cc8d 1666 */
434570c4 1667 public function filter(array $users, $limit = null)
a087cc8d 1668 {
434570c4 1669 return $this->filterUsers($users, self::defaultLimit($limit));
043b104b
RB
1670 }
1671
1672 /** Filter a list of users to extract the users matching the rule.
1673 */
434570c4 1674 public function filterUsers(array $users, $limit = null)
043b104b 1675 {
434570c4 1676 $limit = self::defaultLimit($limit);
b8dcf62d 1677 $this->requireAccounts();
4927ee54
FB
1678 $this->buildQuery();
1679 $table = array();
1680 $uids = array();
1681 foreach ($users as $user) {
07eb5b0e
FB
1682 if ($user instanceof PlUser) {
1683 $uid = $user->id();
1684 } else {
1685 $uid = $user;
1686 }
1687 $uids[] = $uid;
1688 $table[$uid] = $user;
4927ee54 1689 }
7ca75030 1690 $fetched = $this->getUIDList($uids, $limit);
a087cc8d 1691 $output = array();
4927ee54
FB
1692 foreach ($fetched as $uid) {
1693 $output[] = $table[$uid];
a087cc8d
FB
1694 }
1695 return $output;
1696 }
1697
043b104b
RB
1698 /** Filter a list of profiles to extract the users matching the rule.
1699 */
434570c4 1700 public function filterProfiles(array $profiles, $limit = null)
043b104b 1701 {
434570c4 1702 $limit = self::defaultLimit($limit);
043b104b
RB
1703 $this->requireProfiles();
1704 $this->buildQuery();
1705 $table = array();
1706 $pids = array();
1707 foreach ($profiles as $profile) {
1708 if ($profile instanceof Profile) {
1709 $pid = $profile->id();
1710 } else {
1711 $pid = $profile;
1712 }
1713 $pids[] = $pid;
1714 $table[$pid] = $profile;
1715 }
1716 $fetched = $this->getPIDList($pids, $limit);
1717 $output = array();
1718 foreach ($fetched as $pid) {
1719 $output[] = $table[$pid];
1720 }
1721 return $output;
1722 }
1723
434570c4 1724 public function getUIDs($limit = null)
7ca75030 1725 {
833a6e86
FB
1726 $limit = self::defaultLimit($limit);
1727 return $this->getUIDList(null, $limit);
7ca75030
RB
1728 }
1729
ad27b22e
FB
1730 public function getUID($pos = 0)
1731 {
1732 $uids =$this->getUIDList(null, new PlFilter(1, $pos));
1733 if (count($uids) == 0) {
1734 return null;
1735 } else {
1736 return $uids[0];
1737 }
1738 }
1739
434570c4 1740 public function getPIDs($limit = null)
043b104b 1741 {
833a6e86
FB
1742 $limit = self::defaultLimit($limit);
1743 return $this->getPIDList(null, $limit);
043b104b
RB
1744 }
1745
ad27b22e
FB
1746 public function getPID($pos = 0)
1747 {
1748 $pids =$this->getPIDList(null, new PlFilter(1, $pos));
1749 if (count($pids) == 0) {
1750 return null;
1751 } else {
1752 return $pids[0];
1753 }
1754 }
1755
434570c4 1756 public function getUsers($limit = null)
4927ee54 1757 {
7ca75030 1758 return User::getBulkUsersWithUIDs($this->getUIDs($limit));
d865c296
FB
1759 }
1760
ad27b22e
FB
1761 public function getUser($pos = 0)
1762 {
1763 $uid = $this->getUID($pos);
1764 if ($uid == null) {
1765 return null;
1766 } else {
1767 return User::getWithUID($uid);
1768 }
1769 }
1770
0d906109
RB
1771 public function iterUsers($limit = null)
1772 {
1773 return User::iterOverUIDs($this->getUIDs($limit));
1774 }
1775
434570c4 1776 public function getProfiles($limit = null)
043b104b
RB
1777 {
1778 return Profile::getBulkProfilesWithPIDs($this->getPIDs($limit));
1779 }
1780
ad27b22e
FB
1781 public function getProfile($pos = 0)
1782 {
1783 $pid = $this->getPID($pos);
1784 if ($pid == null) {
1785 return null;
1786 } else {
1787 return Profile::get($pid);
1788 }
1789 }
1790
0d906109
RB
1791 public function iterProfiles($limit = null)
1792 {
1793 return Profile::iterOverPIDs($this->getPIDs($limit));
1794 }
1795
434570c4 1796 public function get($limit = null)
d865c296 1797 {
7ca75030 1798 return $this->getUsers($limit);
4927ee54
FB
1799 }
1800
d865c296 1801 public function getTotalCount()
4927ee54 1802 {
38c6fe96 1803 if (is_null($this->lastcount)) {
aa21c568 1804 $this->buildQuery();
2b9ca54d 1805 if ($this->with_accounts) {
b8dcf62d
RB
1806 $field = 'a.uid';
1807 } else {
1808 $field = 'p.pid';
1809 }
1810 return (int)XDB::fetchOneCell('SELECT COUNT(DISTINCT ' . $field . ')
7e735012 1811 ' . $this->query);
38c6fe96
FB
1812 } else {
1813 return $this->lastcount;
1814 }
4927ee54
FB
1815 }
1816
9b8e5fb4 1817 public function setCondition(PlFilterCondition &$cond)
a087cc8d
FB
1818 {
1819 $this->root =& $cond;
784745ce 1820 $this->query = null;
a087cc8d
FB
1821 }
1822
9b8e5fb4 1823 public function addSort(PlFilterOrder &$sort)
24e08e33 1824 {
d865c296
FB
1825 $this->sort[] = $sort;
1826 $this->orderby = null;
24e08e33
FB
1827 }
1828
a087cc8d
FB
1829 static public function getLegacy($promo_min, $promo_max)
1830 {
a087cc8d 1831 if ($promo_min != 0) {
784745ce 1832 $min = new UFC_Promo('>=', self::GRADE_ING, intval($promo_min));
5dd9d823 1833 } else {
88c31faf 1834 $min = new PFC_True();
a087cc8d 1835 }
a087cc8d 1836 if ($promo_max != 0) {
784745ce 1837 $max = new UFC_Promo('<=', self::GRADE_ING, intval($promo_max));
a087cc8d 1838 } else {
88c31faf 1839 $max = new PFC_True();
a087cc8d 1840 }
9b8e5fb4 1841 return new UserFilter(new PFC_And($min, $max));
a087cc8d 1842 }
784745ce 1843
07eb5b0e
FB
1844 static public function sortByName()
1845 {
913a4e90 1846 return array(new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
07eb5b0e
FB
1847 }
1848
1849 static public function sortByPromo()
1850 {
913a4e90 1851 return array(new UFO_Promo(), new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
07eb5b0e
FB
1852 }
1853
aa21c568
FB
1854 static private function getDBSuffix($string)
1855 {
1856 return preg_replace('/[^a-z0-9]/i', '', $string);
1857 }
1858
1859
2d83cac9
RB
1860 /** Stores a new (and unique) table alias in the &$table table
1861 * @param &$table Array in which the table alias must be stored
1862 * @param $val Value which will then be used to build the join
1863 * @return Name of the newly created alias
1864 */
aa21c568
FB
1865 private $option = 0;
1866 private function register_optional(array &$table, $val)
1867 {
1868 if (is_null($val)) {
1869 $sub = $this->option++;
1870 $index = null;
1871 } else {
1872 $sub = self::getDBSuffix($val);
1873 $index = $val;
1874 }
1875 $sub = '_' . $sub;
1876 $table[$sub] = $index;
1877 return $sub;
1878 }
784745ce 1879
b8dcf62d
RB
1880 /** PROFILE VS ACCOUNT
1881 */
f7ea7450
RB
1882 private $with_profiles = false;
1883 private $with_accounts = false;
1884 private $with_forced_sn = false;
b8dcf62d
RB
1885 public function requireAccounts()
1886 {
1887 $this->with_accounts = true;
1888 }
1889
1890 public function requireProfiles()
1891 {
1892 $this->with_profiles = true;
1893 }
1894
f7ea7450
RB
1895 /** Forces the "FROM" to use search_name instead of accounts or profiles */
1896 public function forceSearchName()
1897 {
1898 $this->with_forced_sn = true;
1899 }
1900
b8dcf62d
RB
1901 protected function accountJoins()
1902 {
1903 $joins = array();
f7ea7450
RB
1904 /** Quick search is much more efficient with sn first and PID second */
1905 if ($this->with_forced_sn) {
1906 $joins['p'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profiles', '$PID = sn.uid');
1907 if ($this->with_accounts) {
1908 $joins['ap'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'account_profiles', '$ME.pid = $PID');
1909 $joins['a'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'accounts', '$UID = ap.uid');
1910 }
1911 } else if ($this->with_profiles && $this->with_accounts) {
b8dcf62d
RB
1912 $joins['ap'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'account_profiles', '$ME.uid = $UID AND FIND_IN_SET(\'owner\', ap.perms)');
1913 $joins['p'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profiles', '$PID = ap.pid');
1914 }
1915 return $joins;
1916 }
1917
d865c296
FB
1918 /** DISPLAY
1919 */
38c6fe96 1920 const DISPLAY = 'display';
d865c296
FB
1921 private $pd = false;
1922 public function addDisplayFilter()
1923 {
b8dcf62d 1924 $this->requireProfiles();
d865c296
FB
1925 $this->pd = true;
1926 return '';
1927 }
1928
9b8e5fb4 1929 protected function displayJoins()
d865c296
FB
1930 {
1931 if ($this->pd) {
7ca75030 1932 return array('pd' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_display', '$ME.pid = $PID'));
d865c296
FB
1933 } else {
1934 return array();
1935 }
1936 }
1937
f73a4f1b
RB
1938 /** LOGGER
1939 */
1940
1941 private $with_logger = false;
1942 public function addLoggerFilter()
1943 {
1944 $this->with_logger = true;
1945 $this->requireAccounts();
1946 return 'ls';
1947 }
1948 protected function loggerJoins()
1949 {
1950 $joins = array();
1951 if ($this->with_logger) {
1952 $joins['ls'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'log_sessions', '$ME.uid = $UID');
1953 }
1954 return $joins;
1955 }
1956
784745ce
FB
1957 /** NAMES
1958 */
784745ce
FB
1959
1960 static public function assertName($name)
1961 {
1962 if (!Profile::getNameTypeId($name)) {
9b8e5fb4 1963 Platal::page()->kill('Invalid name type: ' . $name);
784745ce
FB
1964 }
1965 }
1966
1967 private $pn = array();
784745ce
FB
1968 public function addNameFilter($type, $variant = null)
1969 {
b8dcf62d 1970 $this->requireProfiles();
784745ce
FB
1971 if (!is_null($variant)) {
1972 $ft = $type . '_' . $variant;
1973 } else {
1974 $ft = $type;
1975 }
1976 $sub = '_' . $ft;
1977 self::assertName($ft);
1978
1979 if (!is_null($variant) && $variant == 'other') {
aa21c568 1980 $sub .= $this->option++;
784745ce
FB
1981 }
1982 $this->pn[$sub] = Profile::getNameTypeId($ft);
1983 return $sub;
1984 }
1985
9b8e5fb4 1986 protected function nameJoins()
784745ce
FB
1987 {
1988 $joins = array();
1989 foreach ($this->pn as $sub => $type) {
7ca75030 1990 $joins['pn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_name', '$ME.pid = $PID AND $ME.typeid = ' . $type);
784745ce
FB
1991 }
1992 return $joins;
1993 }
1994
40585144
RB
1995 /** NAMETOKENS
1996 */
1997 private $with_sn = false;
f7ea7450
RB
1998 // Set $doingQuickSearch to true if you wish to optimize the query
1999 public function addNameTokensFilter($doingQuickSearch = false)
40585144
RB
2000 {
2001 $this->requireProfiles();
f7ea7450 2002 $this->with_forced_sn = ($this->with_forced_sn || $doingQuickSearch);
40585144
RB
2003 $this->with_sn = true;
2004 return 'sn';
2005 }
2006
2007 protected function nameTokensJoins()
2008 {
f7ea7450
RB
2009 /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
2010 if ($this->with_sn && !$this->with_forced_sn) {
2011 return array(
2012 'sn' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'search_name', '$ME.uid = $PID')
2013 );
2014 } else {
2015 return array();
40585144 2016 }
40585144
RB
2017 }
2018
a7f8e48a
RB
2019 /** NATIONALITY
2020 */
2021
2022 private $with_nat = false;
2023 public function addNationalityFilter()
2024 {
2025 $this->with_nat = true;
2026 return 'ngc';
2027 }
2028
2029 protected function nationalityJoins()
2030 {
2031 $joins = array();
2032 if ($this->with_nat) {
2033 $joins['ngc'] = new PlSqlJoin(PlSqlJoin::MODE_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');
2034 }
2035 return $joins;
2036 }
2037
784745ce
FB
2038 /** EDUCATION
2039 */
2040 const GRADE_ING = 'Ing.';
2041 const GRADE_PHD = 'PhD';
2042 const GRADE_MST = 'M%';
2043 static public function isGrade($grade)
2044 {
38c6fe96 2045 return $grade == self::GRADE_ING || $grade == self::GRADE_PHD || $grade == self::GRADE_MST;
784745ce
FB
2046 }
2047
2048 static public function assertGrade($grade)
2049 {
2050 if (!self::isGrade($grade)) {
ad27b22e 2051 Platal::page()->killError("Diplôme non valide: $grade");
784745ce
FB
2052 }
2053 }
2054
d865c296
FB
2055 static public function promoYear($grade)
2056 {
2057 // XXX: Definition of promotion for phds and masters might change in near future.
2058 return ($grade == UserFilter::GRADE_ING) ? 'entry_year' : 'grad_year';
2059 }
2060
784745ce
FB
2061 private $pepe = array();
2062 private $with_pee = false;
784745ce
FB
2063 public function addEducationFilter($x = false, $grade = null)
2064 {
b8dcf62d 2065 $this->requireProfiles();
784745ce 2066 if (!$x) {
aa21c568
FB
2067 $index = $this->option;
2068 $sub = $this->option++;
784745ce
FB
2069 } else {
2070 self::assertGrade($grade);
2071 $index = $grade;
2072 $sub = $grade[0];
2073 $this->with_pee = true;
2074 }
2075 $sub = '_' . $sub;
2076 $this->pepe[$index] = $sub;
2077 return $sub;
2078 }
2079
9b8e5fb4 2080 protected function educationJoins()
784745ce
FB
2081 {
2082 $joins = array();
2083 if ($this->with_pee) {
7ca75030 2084 $joins['pee'] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_enum', 'pee.abbreviation = \'X\'');
784745ce
FB
2085 }
2086 foreach ($this->pepe as $grade => $sub) {
2087 if ($this->isGrade($grade)) {
ce0b2c6f 2088 $joins['pe' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_education', '$ME.eduid = pee.id AND $ME.pid = $PID');
7ca75030 2089 $joins['pede' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.abbreviation LIKE ' .
784745ce
FB
2090 XDB::format('{?}', $grade));
2091 } else {
ce0b2c6f 2092 $joins['pe' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_education', '$ME.pid = $PID');
7ca75030
RB
2093 $joins['pee' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
2094 $joins['pede' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
784745ce
FB
2095 }
2096 }
2097 return $joins;
2098 }
4927ee54
FB
2099
2100
2101 /** GROUPS
2102 */
2103 private $gpm = array();
4927ee54
FB
2104 public function addGroupFilter($group = null)
2105 {
b8dcf62d 2106 $this->requireAccounts();
4927ee54
FB
2107 if (!is_null($group)) {
2108 if (ctype_digit($group)) {
2109 $index = $sub = $group;
2110 } else {
2111 $index = $group;
aa21c568 2112 $sub = self::getDBSuffix($group);
4927ee54
FB
2113 }
2114 } else {
aa21c568 2115 $sub = 'group_' . $this->option++;
4927ee54
FB
2116 $index = null;
2117 }
2118 $sub = '_' . $sub;
2119 $this->gpm[$sub] = $index;
2120 return $sub;
2121 }
2122
9b8e5fb4 2123 protected function groupJoins()
4927ee54
FB
2124 {
2125 $joins = array();
2126 foreach ($this->gpm as $sub => $key) {
2127 if (is_null($key)) {
eb41eda9
FB
2128 $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groups');
2129 $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
4927ee54 2130 } else if (ctype_digit($key)) {
eb41eda9 2131 $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
4927ee54 2132 } else {
eb41eda9
FB
2133 $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groups', XDB::format('$ME.diminutif = {?}', $key));
2134 $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
4927ee54
FB
2135 }
2136 }
2137 return $joins;
0fb3713c
RB
2138 }
2139
2140 /** BINETS
2141 */
2142
a7f8e48a
RB
2143 private $with_bi = false;
2144 private $with_bd = false;
d7ddf29b 2145 public function addBinetsFilter($with_enum = false)
0fb3713c
RB
2146 {
2147 $this->requireProfiles();
a7f8e48a
RB
2148 $this->with_bi = true;
2149 if ($with_enum) {
2150 $this->with_bd = true;
2151 return 'bd';
2152 } else {
2153 return 'bi';
2154 }
0fb3713c
RB
2155 }
2156
2157 protected function binetsJoins()
2158 {
2159 $joins = array();
a7f8e48a 2160 if ($this->with_bi) {
bdd977d7 2161 $joins['bi'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_binets', '$ME.pid = $PID');
0fb3713c 2162 }
a7f8e48a 2163 if ($this->with_bd) {
5c8a71f2 2164 $joins['bd'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_binet_enum', '$ME.id = bi.binet_id');
a7f8e48a 2165 }
0fb3713c 2166 return $joins;
4927ee54 2167 }
aa21c568
FB
2168
2169 /** EMAILS
2170 */
2171 private $e = array();
2172 public function addEmailRedirectFilter($email = null)
2173 {
b8dcf62d 2174 $this->requireAccounts();
aa21c568
FB
2175 return $this->register_optional($this->e, $email);
2176 }
2177
2178 private $ve = array();
2179 public function addVirtualEmailFilter($email = null)
2180 {
21401768 2181 $this->addAliasFilter(self::ALIAS_FORLIFE);
aa21c568
FB
2182 return $this->register_optional($this->ve, $email);
2183 }
2184
21401768
FB
2185 const ALIAS_BEST = 'bestalias';
2186 const ALIAS_FORLIFE = 'forlife';
aa21c568
FB
2187 private $al = array();
2188 public function addAliasFilter($alias = null)
2189 {
b8dcf62d 2190 $this->requireAccounts();
aa21c568
FB
2191 return $this->register_optional($this->al, $alias);
2192 }
2193
9b8e5fb4 2194 protected function emailJoins()
aa21c568
FB
2195 {
2196 global $globals;
2197 $joins = array();
2198 foreach ($this->e as $sub=>$key) {
2199 if (is_null($key)) {
7ca75030 2200 $joins['e' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'emails', '$ME.uid = $UID AND $ME.flags != \'filter\'');
aa21c568 2201 } else {
7ca75030 2202 $joins['e' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'emails', XDB::format('$ME.uid = $UID AND $ME.flags != \'filter\' AND $ME.email = {?}', $key));
aa21c568
FB
2203 }
2204 }
21401768 2205 foreach ($this->al as $sub=>$key) {
aa21c568 2206 if (is_null($key)) {
fe13bc1d 2207 $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\')');
21401768 2208 } else if ($key == self::ALIAS_BEST) {
fe13bc1d 2209 $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND FIND_IN_SET(\'bestalias\', $ME.flags)');
21401768 2210 } else if ($key == self::ALIAS_FORLIFE) {
fe13bc1d 2211 $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.uid = $UID AND $ME.type = \'a_vie\'');
aa21c568 2212 } else {
fe13bc1d 2213 $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', XDB::format('$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND $ME.alias = {?}', $key));
aa21c568 2214 }
aa21c568 2215 }
21401768 2216 foreach ($this->ve as $sub=>$key) {
aa21c568 2217 if (is_null($key)) {
7ca75030 2218 $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', '$ME.type = \'user\'');
aa21c568 2219 } else {
7ca75030 2220 $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', XDB::format('$ME.type = \'user\' AND $ME.alias = {?}', $key));
aa21c568 2221 }
7ca75030 2222 $joins['vr' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual_redirect', XDB::format('$ME.vid = v' . $sub . '.vid
21401768
FB
2223 AND ($ME.redirect IN (CONCAT(al_forlife.alias, \'@\', {?}),
2224 CONCAT(al_forlife.alias, \'@\', {?}),
2225 a.email))',
2226 $globals->mail->domain, $globals->mail->domain2));
aa21c568
FB
2227 }
2228 return $joins;
2229 }
3f42a6ad
FB
2230
2231
c4b24511
RB
2232 /** ADDRESSES
2233 */
036d1637 2234 private $with_pa = false;
c4b24511
RB
2235 public function addAddressFilter()
2236 {
b8dcf62d 2237 $this->requireProfiles();
036d1637
RB
2238 $this->with_pa = true;
2239 return 'pa';
c4b24511
RB
2240 }
2241
2b9ca54d
RB
2242 private $with_pac = false;
2243 public function addAddressCountryFilter()
2244 {
2245 $this->requireProfiles();
2246 $this->addAddressFilter();
2247 $this->with_pac = true;
2248 return 'gc';
2249 }
2250
d7ddf29b 2251 private $with_pal = false;
2b9ca54d
RB
2252 public function addAddressLocalityFilter()
2253 {
2254 $this->requireProfiles();
2255 $this->addAddressFilter();
2256 $this->with_pal = true;
2257 return 'gl';
2258 }
2259
9b8e5fb4 2260 protected function addressJoins()
c4b24511
RB
2261 {
2262 $joins = array();
036d1637 2263 if ($this->with_pa) {
d7ddf29b 2264 $joins['pa'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_addresses', '$ME.pid = $PID');
c4b24511 2265 }
2b9ca54d
RB
2266 if ($this->with_pac) {
2267 $joins['gc'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'geoloc_countries', '$ME.iso_3166_1_a2 = pa.countryID');
2268 }
2269 if ($this->with_pal) {
2270 $joins['gl'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'geoloc_localities', '$ME.id = pa.localityID');
2271 }
c4b24511
RB
2272 return $joins;
2273 }
2274
2275
4083b126
RB
2276 /** CORPS
2277 */
2278
2279 private $pc = false;
2280 private $pce = array();
2281 private $pcr = false;
2282 public function addCorpsFilter($type)
2283 {
b8dcf62d 2284 $this->requireProfiles();
4083b126
RB
2285 $this->pc = true;
2286 if ($type == UFC_Corps::CURRENT) {
2287 $pce['pcec'] = 'current_corpsid';
2288 return 'pcec';
2289 } else if ($type == UFC_Corps::ORIGIN) {
2290 $pce['pceo'] = 'original_corpsid';
2291 return 'pceo';
2292 }
2293 }
2294
2295 public function addCorpsRankFilter()
2296 {
b8dcf62d 2297 $this->requireProfiles();
4083b126
RB
2298 $this->pc = true;
2299 $this->pcr = true;
2300 return 'pcr';
2301 }
2302
9b8e5fb4 2303 protected function corpsJoins()
4083b126
RB
2304 {
2305 $joins = array();
2306 if ($this->pc) {
ce0b2c6f 2307 $joins['pc'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps', '$ME.pid = $PID');
4083b126
RB
2308 }
2309 if ($this->pcr) {
7ca75030 2310 $joins['pcr'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps_rank_enum', '$ME.id = pc.rankid');
4083b126
RB
2311 }
2312 foreach($this->pce as $sub => $field) {
7ca75030 2313 $joins[$sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps_enum', '$ME.id = pc.' . $field);
4083b126
RB
2314 }
2315 return $joins;
2316 }
2317
6a99c3ac
RB
2318 /** JOBS
2319 */
2320
61f61261
RB
2321 const JOB_SECTOR = 0x0001;
2322 const JOB_SUBSECTOR = 0x0002;
2323 const JOB_SUBSUBSECTOR = 0x0004;
2324 const JOB_ALTERNATES = 0x0008;
2325 const JOB_USERDEFINED = 0x0010;
2326 const JOB_CV = 0x0020;
2327
2328 const JOB_SECTORIZATION = 0x000F;
2329 const JOB_ANY = 0x003F;
6a99c3ac
RB
2330
2331 /** Joins :
2332 * pj => profile_job
2333 * pje => profile_job_enum
2334 * pjse => profile_job_sector_enum
2335 * pjsse => profile_job_subsector_enum
2336 * pjssse => profile_job_subsubsector_enum
2337 * pja => profile_job_alternates
2338 */
2339 private $with_pj = false;
2340 private $with_pje = false;
2341 private $with_pjse = false;
2342 private $with_pjsse = false;
2343 private $with_pjssse = false;
2344 private $with_pja = false;
2345
2346 public function addJobFilter()
2347 {
b8dcf62d 2348 $this->requireProfiles();
6a99c3ac
RB
2349 $this->with_pj = true;
2350 return 'pj';
2351 }
2352
2353 public function addJobCompanyFilter()
2354 {
2355 $this->addJobFilter();
2356 $this->with_pje = true;
2357 return 'pje';
2358 }
2359
2360 public function addJobSectorizationFilter($type)
2361 {
2362 $this->addJobFilter();
2363 if ($type == self::JOB_SECTOR) {
2364 $this->with_pjse = true;
2365 return 'pjse';
2366 } else if ($type == self::JOB_SUBSECTOR) {
2367 $this->with_pjsse = true;
2368 return 'pjsse';
2369 } else if ($type == self::JOB_SUBSUBSECTOR) {
2370 $this->with_pjssse = true;
2371 return 'pjssse';
2372 } else if ($type == self::JOB_ALTERNATES) {
2373 $this->with_pja = true;
2374 return 'pja';
2375 }
2376 }
2377
9b8e5fb4 2378 protected function jobJoins()
6a99c3ac
RB
2379 {
2380 $joins = array();
2381 if ($this->with_pj) {
ce0b2c6f 2382 $joins['pj'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job', '$ME.pid = $PID');
6a99c3ac
RB
2383 }
2384 if ($this->with_pje) {
7ca75030 2385 $joins['pje'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_enum', '$ME.id = pj.jobid');
6a99c3ac
RB
2386 }
2387 if ($this->with_pjse) {
7ca75030 2388 $joins['pjse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_sector_enum', '$ME.id = pj.sectorid');
6a99c3ac
RB
2389 }
2390 if ($this->with_pjsse) {
7ca75030 2391 $joins['pjsse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_subsector_enum', '$ME.id = pj.subsectorid');
6a99c3ac
RB
2392 }
2393 if ($this->with_pjssse) {
7ca75030 2394 $joins['pjssse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_subsubsector_enum', '$ME.id = pj.subsubsectorid');
6a99c3ac
RB
2395 }
2396 if ($this->with_pja) {
7ca75030 2397 $joins['pja'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_alternates', '$ME.subsubsectorid = pj.subsubsectorid');
6a99c3ac
RB
2398 }
2399 return $joins;
2400 }
2401
0a2e9c74
RB
2402 /** NETWORKING
2403 */
2404
2405 private $with_pnw = false;
2406 public function addNetworkingFilter()
2407 {
b8dcf62d 2408 $this->requireAccounts();
0a2e9c74
RB
2409 $this->with_pnw = true;
2410 return 'pnw';
2411 }
2412
9b8e5fb4 2413 protected function networkingJoins()
0a2e9c74
RB
2414 {
2415 $joins = array();
2416 if ($this->with_pnw) {
ce0b2c6f 2417 $joins['pnw'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_networking', '$ME.pid = $PID');
0a2e9c74
RB
2418 }
2419 return $joins;
2420 }
2421
6d62969e
RB
2422 /** PHONE
2423 */
2424
2d83cac9 2425 private $with_ptel = false;
6d62969e
RB
2426
2427 public function addPhoneFilter()
2428 {
b8dcf62d 2429 $this->requireAccounts();
2d83cac9 2430 $this->with_ptel = true;
6d62969e
RB
2431 return 'ptel';
2432 }
2433
9b8e5fb4 2434 protected function phoneJoins()
6d62969e
RB
2435 {
2436 $joins = array();
2d83cac9 2437 if ($this->with_ptel) {
ce0b2c6f 2438 $joins['ptel'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_phones', '$ME.pid = $PID');
6d62969e
RB
2439 }
2440 return $joins;
2441 }
2442
ceb512d2
RB
2443 /** MEDALS
2444 */
2445
2d83cac9 2446 private $with_pmed = false;
ceb512d2
RB
2447 public function addMedalFilter()
2448 {
b8dcf62d 2449 $this->requireProfiles();
2d83cac9 2450 $this->with_pmed = true;
ceb512d2
RB
2451 return 'pmed';
2452 }
2453
9b8e5fb4 2454 protected function medalJoins()
ceb512d2
RB
2455 {
2456 $joins = array();
2d83cac9 2457 if ($this->with_pmed) {
bdd977d7 2458 $joins['pmed'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_medals', '$ME.pid = $PID');
ceb512d2
RB
2459 }
2460 return $joins;
2461 }
2462
671b7073
RB
2463 /** MENTORING
2464 */
2465
2466 private $pms = array();
2467 const MENTOR_EXPERTISE = 1;
2468 const MENTOR_COUNTRY = 2;
2469 const MENTOR_SECTOR = 3;
2470
2471 public function addMentorFilter($type)
2472 {
b8dcf62d 2473 $this->requireAccounts();
671b7073 2474 switch($type) {
4a93c3a3
RB
2475 case self::MENTOR_EXPERTISE:
2476 $this->pms['pme'] = 'profile_mentor';
671b7073 2477 return 'pme';
4a93c3a3
RB
2478 case self::MENTOR_COUNTRY:
2479 $this->pms['pmc'] = 'profile_mentor_country';
671b7073 2480 return 'pmc';
4a93c3a3
RB
2481 case self::MENTOR_SECTOR:
2482 $this->pms['pms'] = 'profile_mentor_sector';
671b7073
RB
2483 return 'pms';
2484 default:
5d2e55c7 2485 Platal::page()->killError("Undefined mentor filter.");
671b7073
RB
2486 }
2487 }
2488
9b8e5fb4 2489 protected function mentorJoins()
671b7073
RB
2490 {
2491 $joins = array();
2492 foreach ($this->pms as $sub => $tab) {
ce0b2c6f 2493 $joins[$sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, $tab, '$ME.pid = $PID');
671b7073
RB
2494 }
2495 return $joins;
2496 }
2497
3f42a6ad
FB
2498 /** CONTACTS
2499 */
2500 private $cts = array();
2501 public function addContactFilter($uid = null)
2502 {
b8dcf62d 2503 $this->requireAccounts();
3f42a6ad
FB
2504 return $this->register_optional($this->cts, is_null($uid) ? null : 'user_' . $uid);
2505 }
2506
9b8e5fb4 2507 protected function contactJoins()
3f42a6ad
FB
2508 {
2509 $joins = array();
2510 foreach ($this->cts as $sub=>$key) {
2511 if (is_null($key)) {
7ca75030 2512 $joins['c' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'contacts', '$ME.contact = $UID');
3f42a6ad 2513 } else {
7ca75030 2514 $joins['c' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'contacts', XDB::format('$ME.uid = {?} AND $ME.contact = $UID', substr($key, 5)));
3f42a6ad
FB
2515 }
2516 }
2517 return $joins;
2518 }
4e7bf1e0
FB
2519
2520
2521 /** CARNET
2522 */
2523 private $wn = array();
2524 public function addWatchRegistrationFilter($uid = null)
2525 {
b8dcf62d 2526 $this->requireAccounts();
4e7bf1e0
FB
2527 return $this->register_optional($this->wn, is_null($uid) ? null : 'user_' . $uid);
2528 }
2529
2530 private $wp = array();
2531 public function addWatchPromoFilter($uid = null)
2532 {
b8dcf62d 2533 $this->requireAccounts();
4e7bf1e0
FB
2534 return $this->register_optional($this->wp, is_null($uid) ? null : 'user_' . $uid);
2535 }
2536
2537 private $w = array();
2538 public function addWatchFilter($uid = null)
2539 {
b8dcf62d 2540 $this->requireAccounts();
4e7bf1e0
FB
2541 return $this->register_optional($this->w, is_null($uid) ? null : 'user_' . $uid);
2542 }
2543
9b8e5fb4 2544 protected function watchJoins()
4e7bf1e0
FB
2545 {
2546 $joins = array();
2547 foreach ($this->w as $sub=>$key) {
2548 if (is_null($key)) {
7ca75030 2549 $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch');
4e7bf1e0 2550 } else {
7ca75030 2551 $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch', XDB::format('$ME.uid = {?}', substr($key, 5)));
4e7bf1e0
FB
2552 }
2553 }
2554 foreach ($this->wn as $sub=>$key) {
2555 if (is_null($key)) {
7ca75030 2556 $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', '$ME.ni_id = $UID');
4e7bf1e0 2557 } else {
7ca75030 2558 $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5)));
4e7bf1e0
FB
2559 }
2560 }
2561 foreach ($this->wn as $sub=>$key) {
2562 if (is_null($key)) {
7ca75030 2563 $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', '$ME.ni_id = $UID');
4e7bf1e0 2564 } else {
7ca75030 2565 $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5)));
4e7bf1e0
FB
2566 }
2567 }
2568 foreach ($this->wp as $sub=>$key) {
2569 if (is_null($key)) {
7ca75030 2570 $joins['wp' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_promo');
4e7bf1e0 2571 } else {
7ca75030 2572 $joins['wp' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_promo', XDB::format('$ME.uid = {?}', substr($key, 5)));
4e7bf1e0
FB
2573 }
2574 }
2575 return $joins;
2576 }
48885bbe
FB
2577
2578
2579 /** MARKETING
2580 */
2581 private $with_rm;
2582 public function addMarketingHash()
2583 {
2584 $this->requireAccounts();
2585 $this->with_rm = true;
2586 }
2587
2588 protected function marketingJoins()
2589 {
2590 if ($this->with_rm) {
2591 return array('rm' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'register_marketing', '$ME.uid = $UID'));
2592 } else {
2593 return array();
2594 }
2595 }
a087cc8d 2596}
8363588b 2597// }}}
3f42a6ad 2598
a7d9ab89
RB
2599// {{{ class ProfileFilter
2600class ProfileFilter extends UserFilter
2601{
434570c4 2602 public function get($limit = null)
a7d9ab89
RB
2603 {
2604 return $this->getProfiles($limit);
2605 }
2606}
2607// }}}
2608
a087cc8d
FB
2609// vim:set et sw=4 sts=4 sws=4 foldmethod=marker enc=utf-8:
2610?>