<?php
/***************************************************************************
- * Copyright (C) 2003-2009 Polytechnique.org *
+ * Copyright (C) 2003-2010 Polytechnique.org *
* http://opensource.polytechnique.org/ *
* *
* This program is free software; you can redistribute it and/or modify *
* adequate joins. It must return the 'WHERE' condition to use
* with the filter.
*/
-interface UserFilterCondition
+interface UserFilterCondition extends PlFilterCondition
{
- /** Check that the given user matches the rule.
- */
- public function buildCondition(UserFilter &$uf);
}
// }}}
-// {{{ class UFC_Profile
+// {{{ class UFC_HasProfile
/** Filters users who have a profile
*/
-class UFC_Profile implements UserFilterCondition
+class UFC_HasProfile implements UserFilterCondition
{
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
+ $uf->requireProfiles();
return '$PID IS NOT NULL';
}
}
// }}}
+// {{{ class UFC_Hruid
+/** Filters users based on their hruid
+ * @param $val Either an hruid, or a list of those
+ */
+class UFC_Hruid implements UserFilterCondition
+{
+ private $hruids;
+
+ public function __construct()
+ {
+ $this->hruids = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireAccounts();
+ return XDB::format('a.hruid IN {?}', $this->hruids);
+ }
+}
+// }}}
+
+// {{{ class UFC_Hrpid
+/** Filters users based on the hrpid of their profiles
+ * @param $val Either an hrpid, or a list of those
+ */
+class UFC_Hrpid implements UserFilterCondition
+{
+ private $hrpids;
+
+ public function __construct()
+ {
+ $this->hrpids = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ return XDB::format('p.hrpid IN {?}', $this->hrpids);
+ }
+}
+// }}}
+
+// {{{ class UFC_Ip
+/** Filters users based on one of their last IPs
+ * @param $ip IP from which connection are checked
+ */
+class UFC_Ip implements UserFilterCondition
+{
+ private $ip;
+
+ public function __construct($ip)
+ {
+ $this->ip = $ip;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addLoggerFilter();
+ $ip = ip_to_uint($this->ip);
+ return XDB::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
+ }
+}
+// }}}
+
+// {{{ class UFC_Comment
+class UFC_Comment implements UserFilterCondition
+{
+ private $text;
+
+ public function __construct($text)
+ {
+ $this->text = $text;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ return 'p.freetext ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->text);
+ }
+}
+// }}}
+
// {{{ class UFC_Promo
/** Filters users based on promotion
* @param $comparison Comparison operator (>, =, ...)
if ($this->grade != UserFilter::DISPLAY) {
UserFilter::assertGrade($this->grade);
}
+ if ($this->grade == UserFilter::DISPLAY && $this->comparison != '=') {
+ // XXX: we might try to guess the grade from the first char of the promo and forbid only '<= 2004', but allow '<= X2004'
+ Platal::page()->killError("Il n'est pas possible d'appliquer la comparaison '" . $this->comparison . "' aux promotions sans spécifier de formation (X/M/D)");
+ }
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
if ($this->grade == UserFilter::DISPLAY) {
$sub = $uf->addDisplayFilter();
- return XDB::format('pd' . $sub . '.promo = {?}', $this->promo);
+ return XDB::format('pd' . $sub . '.promo ' . $this->comparison . ' {?}', $this->promo);
} else {
$sub = $uf->addEducationFilter(true, $this->grade);
$field = 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
}
// }}}
+// {{{ class UFC_SchoolId
+/** Filters users based on their shoold identifier
+ * @param type Parameter type (Xorg, AX, School)
+ * @param value School id value
+ */
+class UFC_SchoolId implements UserFilterCondition
+{
+ const AX = 'ax';
+ const Xorg = 'xorg';
+ const School = 'school';
+
+ private $type;
+ private $id;
+
+ static public function assertType($type)
+ {
+ if ($type != self::AX && $type != self::Xorg && $type != self::School) {
+ Platal::page()->killError("Type de matricule invalide: $type");
+ }
+ }
+
+ public function __construct($type, $id)
+ {
+ $this->type = $type;
+ $this->id = $id;
+ self::assertType($type);
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ $id = $this->id;
+ $type = $this->type;
+ if ($type == self::School) {
+ $type = self::Xorg;
+ $id = Profile::getXorgId($id);
+ }
+ return XDB::format('p.' . $type . '_id = {?}', $id);
+ }
+}
+// }}}
+
+// {{{ class UFC_EducationSchool
+/** Filters users by formation
+ * @param $val The formation to search (either ID or array of IDs)
+ */
+class UFC_EducationSchool implements UserFilterCondition
+{
+ private $val;
+
+ public function __construct()
+ {
+ $this->val = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addEducationFilter();
+ return XDB::format('pe' . $sub . '.eduid IN {?}', $this->val);
+ }
+}
+// }}}
+
+// {{{ class UFC_EducationDegree
+class UFC_EducationDegree implements UserFilterCondition
+{
+ private $diploma;
+
+ public function __construct()
+ {
+ $this->diploma = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addEducationFilter();
+ return XDB::format('pe' . $sub . '.degreeid IN {?}', $this->diploma);
+ }
+}
+// }}}
+
+// {{{ class UFC_EducationField
+class UFC_EducationField implements UserFilterCondition
+{
+ private $val;
+
+ public function __construct()
+ {
+ $this->val = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addEducationFilter();
+ return XDB::format('pe' . $sub . '.fieldid IN {?}', $this->val);
+ }
+}
+// }}}
+
// {{{ class UFC_Name
/** Filters users based on name
* @param $type Type of name field on which filtering is done (firstname, lastname...)
*/
class UFC_Name implements UserFilterCondition
{
- const PREFIX = 1;
- const SUFFIX = 2;
- const PARTICLE = 7;
- const VARIANTS = 8;
- const CONTAINS = 3;
+ const EXACT = XDB::WILDCARD_EXACT; // 0x000
+ const PREFIX = XDB::WILDCARD_PREFIX; // 0x001
+ const SUFFIX = XDB::WILDCARD_SUFFIX; // 0x002
+ const CONTAINS = XDB::WILDCARD_CONTAINS; // 0x003
+ const PARTICLE = 0x004;
+ const VARIANTS = 0x008;
private $type;
private $text;
return str_replace('$ME', 'pn' . $sub, $where);
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$left = '$ME.name';
- $op = ' LIKE ';
if (($this->mode & self::PARTICLE) == self::PARTICLE) {
$left = 'CONCAT($ME.particle, \' \', $ME.name)';
}
- if (($this->mode & self::CONTAINS) == 0) {
- $right = XDB::format('{?}', $this->text);
- $op = ' = ';
- } else if (($this->mode & self::CONTAINS) == self::PREFIX) {
- $right = XDB::format('CONCAT({?}, \'%\')', $this->text);
- } else if (($this->mode & self::CONTAINS) == self::SUFFIX) {
- $right = XDB::format('CONCAT(\'%\', {?})', $this->text);
- } else {
- $right = XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->text);
- }
- $cond = $left . $op . $right;
+ $right = XDB::formatWildcards($this->mode & self::CONTAINS, $this->text);
+
+ $cond = $left . $right;
$conds = array($this->buildNameQuery($this->type, null, $cond, $uf));
- if (($this->mode & self::VARIANTS) != 0 && isset(UserFilter::$name_variants[$this->type])) {
- foreach (UserFilter::$name_variants[$this->type] as $var) {
+ if (($this->mode & self::VARIANTS) != 0 && isset(Profile::$name_variants[$this->type])) {
+ foreach (Profile::$name_variants[$this->type] as $var) {
$conds[] = $this->buildNameQuery($this->type, $var, $cond, $uf);
}
}
}
// }}}
+// {{{ class UFC_NameTokens
+/** Selects users based on tokens in their name (for quicksearch)
+ * @param $tokens An array of tokens to search
+ * @param $flags Flags the tokens must have (e.g 'public' for public search)
+ * @param $soundex (bool) Whether those tokens are fulltext or soundex
+ */
+class UFC_NameTokens implements UserFilterCondition
+{
+ /* Flags */
+ const FLAG_PUBLIC = 'public';
+
+ private $tokens;
+ private $flags;
+ private $soundex;
+ private $exact;
+
+ public function __construct($tokens, $flags = array(), $soundex = false, $exact = false)
+ {
+ if (is_array($tokens)) {
+ $this->tokens = $tokens;
+ } else {
+ $this->tokens = array($tokens);
+ }
+ if (is_array($flags)) {
+ $this->flags = $flags;
+ } else {
+ $this->flags = array($flags);
+ }
+ $this->soundex = $soundex;
+ $this->exact = $exact;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $conds = array();
+ foreach ($this->tokens as $i => $token) {
+ $sub = $uf->addNameTokensFilter($token);
+ if ($this->soundex) {
+ $c = XDB::format($sub . '.soundex = {?}', $token);
+ } else if ($this->exact) {
+ $c = XDB::format($sub . '.token = {?}', $token);
+ } else {
+ $c = $sub . '.token ' . XDB::formatWildcards(XDB::WILDCARD_PREFIX, $token);
+ }
+ if ($this->flags != null) {
+ $c .= XDB::format(' AND ' . $sub . '.flags IN {?}', $this->flags);
+ }
+ $conds[] = $c;
+ }
+
+ return implode(' AND ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_Nationality
+class UFC_Nationality implements UserFilterCondition
+{
+ private $val;
+
+ public function __construct()
+ {
+ $this->val = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ $nat = XDB::formatArray($this->val);
+ $conds = array(
+ 'p.nationality1 IN ' . $nat,
+ 'p.nationality2 IN ' . $nat,
+ 'p.nationality3 IN ' . $nat,
+ );
+ return implode(' OR ', $conds);
+ }
+}
+// }}}
+
// {{{ class UFC_Dead
/** Filters users based on death date
* @param $comparison Comparison operator
- * @param $date Date to which death date should be compared
+ * @param $date Date to which death date should be compared (DateTime object, string or timestamp)
*/
class UFC_Dead implements UserFilterCondition
{
public function __construct($comparison = null, $date = null)
{
$this->comparison = $comparison;
- $this->date = $date;
+ $this->date = make_datetime($date);
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
+ $uf->requireProfiles();
$str = 'p.deathdate IS NOT NULL';
if (!is_null($this->comparison)) {
- $str .= ' AND p.deathdate ' . $this->comparison . ' ' . XDB::format('{?}', date('Y-m-d', $this->date));
+ $str .= ' AND p.deathdate ' . $this->comparison . ' ' . XDB::format('{?}', $this->date->format('Y-m-d'));
}
return $str;
}
public function __construct($active = false, $comparison = null, $date = null)
{
- $this->only_active = $active;
+ $this->active = $active;
$this->comparison = $comparison;
- $this->date = $date;
+ $this->date = make_datetime($date);
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
+ $uf->requireAccounts();
if ($this->active) {
- $date = 'a.uid IS NOT NULL AND a.state = \'active\'';
+ $date = '$UID IS NOT NULL AND a.state = \'active\'';
} else {
- $date = 'a.uid IS NOT NULL AND a.state != \'pending\'';
+ $date = '$UID IS NOT NULL AND a.state != \'pending\'';
}
if (!is_null($this->comparison)) {
- $date .= ' AND a.registration_date ' . $this->comparison . ' ' . XDB::format('{?}', date('Y-m-d', $this->date));
+ $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'));
}
return $date;
}
$this->date = $date;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
+ $uf->requireProfiles();
return 'p.last_change ' . $this->comparison . XDB::format(' {?}', date('Y-m-d H:i:s', $this->date));
}
}
$this->date = $date;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
+ $uf->requireProfiles();
return 'p.next_birthday ' . $this->comparison . XDB::format(' {?}', date('Y-m-d', $this->date));
}
}
$this->sex = $sex;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
if ($this->sex != User::GENDER_MALE && $this->sex != User::GENDER_FEMALE) {
return self::COND_FALSE;
} else {
+ $uf->requireProfiles();
return XDB::format('p.sex = {?}', $this->sex == User::GENDER_FEMALE ? 'female' : 'male');
}
}
$this->anim = $anim;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addGroupFilter($this->group);
$where = 'gpm' . $sub . '.perms IS NOT NULL';
}
// }}}
-// {{{ class UFC_Email
-/** Filters users based on email address
- * @param $email Email whose owner we are looking for
+// {{{ class UFC_Binet
+/** Selects users based on their belonging to a given (list of) binet
+ * @param $binet either a binet_id or an array of binet_ids
*/
-class UFC_Email implements UserFilterCondition
+class UFC_Binet implements UserFilterCondition
{
- private $email;
- public function __construct($email)
+ private $val;
+
+ public function __construct()
{
- $this->email = $email;
+ $this->val = pl_flatten(func_get_args());
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
- if (User::isForeignEmailAddress($this->email)) {
- $sub = $uf->addEmailRedirectFilter($this->email);
- return XDB::format('e' . $sub . '.email IS NOT NULL OR a.email = {?}', $this->email);
- } else if (User::isVirtualEmailAddress($this->email)) {
- $sub = $uf->addVirtualEmailFilter($this->email);
- return 'vr' . $sub . '.redirect IS NOT NULL';
- } else {
- @list($user, $domain) = explode('@', $this->email);
- $sub = $uf->addAliasFilter($user);
- return 'al' . $sub . '.alias IS NOT NULL';
- }
+ $sub = $uf->addBinetsFilter();
+ return XDB::format($sub . '.binet_id IN {?}', $this->val);
+ }
+}
+// }}}
+
+// {{{ class UFC_Section
+/** Selects users based on section
+ * @param $section ID of the section
+ */
+class UFC_Section implements UserFilterCondition
+{
+ private $section;
+
+ public function __construct()
+ {
+ $this->section = pl_flatten(func_get_args());
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ return XDB::format('p.section IN {?}', $this->section);
}
}
// }}}
-// {{{ class UFC_EmailList
-/** Filters users based on an email list
+// {{{ class UFC_Email
+/** Filters users based on an email or a list of emails
* @param $emails List of emails whose owner must be selected
*/
-class UFC_EmailList implements UserFilterCondition
+class UFC_Email implements UserFilterCondition
{
private $emails;
- public function __construct($emails)
+ public function __construct()
{
- $this->emails = $emails;
+ $this->emails = pl_flatten(func_get_args());
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
- $email = null;
- $virtual = null;
- $alias = null;
+ $foreign = array();
+ $virtual = array();
+ $aliases = array();
$cond = array();
if (count($this->emails) == 0) {
- return UserFilterCondition::COND_TRUE;
+ return PlFilterCondition::COND_TRUE;
}
foreach ($this->emails as $entry) {
if (User::isForeignEmailAddress($entry)) {
- if (is_null($email)) {
- $email = $uf->addEmailRedirectFilter();
- }
- $cond[] = XDB::format('e' . $email . '.email = {?} OR a.email = {?}', $entry, $entry);
+ $foreign[] = $entry;
} else if (User::isVirtualEmailAddress($entry)) {
- if (is_null($virtual)) {
- $virtual = $uf->addVirtualEmailFilter();
- }
- $cond[] = XDB::format('vr' . $virtual . '.redirect IS NOT NULL AND v' . $virtual . '.alias = {?}', $entry);
+ $virtual[] = $entry;
} else {
- if (is_null($alias)) {
- $alias = $uf->addAliasFilter();
- }
@list($user, $domain) = explode('@', $entry);
- $cond[] = XDB::format('al' . $alias . '.alias = {?}', $user);
+ $aliases[] = $user;
}
}
+
+ if (count($foreign) > 0) {
+ $sub = $uf->addEmailRedirectFilter($foreign);
+ $cond[] = XDB::format('e' . $sub . '.email IS NOT NULL OR a.email IN {?}', $foreign);
+ }
+ if (count($virtual) > 0) {
+ $sub = $uf->addVirtualEmailFilter($virtual);
+ $cond[] = 'vr' . $sub . '.redirect IS NOT NULL';
+ }
+ if (count($aliases) > 0) {
+ $sub = $uf->addAliasFilter($aliases);
+ $cond[] = 'al' . $sub . '.alias IS NOT NULL';
+ }
return '(' . implode(') OR (', $cond) . ')';
}
}
// }}}
// {{{ class UFC_Address
-/** Filters users based on their address
- * @param $text Text for filter in fulltext search
- * @param $textSearchMode Mode for search (PREFIX, SUFFIX, ...)
- * @param $type Filter on address type
- * @param $flags Filter on address flags
- * @param $countryId Filter on address countryId
- * @param $administrativeAreaId Filter on address administrativeAreaId
- * @param $subAdministrativeAreaId Filter on address subAdministrativeAreaId
- * @param $localityId Filter on address localityId
- * @param $postalCode Filter on address postalCode
- */
-class UFC_Address implements UserFilterCondition
+abstract class UFC_Address implements UserFilterCondition
{
- /** Flags for text search
+ /** Valid address type ('hq' is reserved for company addresses)
*/
- const PREFIX = 0x0001;
- const SUFFIX = 0x0002;
- const CONTAINS = 0x0003;
+ const TYPE_HOME = 1;
+ const TYPE_PRO = 2;
+ const TYPE_ANY = 3;
- /** Valid address type ('hq' is reserved for company addresses)
+ /** Text for these types
*/
- const TYPE_HOME = 'home';
- const TYPE_PRO = 'job';
+ protected static $typetexts = array(
+ self::TYPE_HOME => 'home',
+ self::TYPE_PRO => 'pro',
+ );
+
+ protected $type;
/** Flags for addresses
*/
/** Text of these flags
*/
- private static $flagtexts = array(
+ protected static $flagtexts = array(
self::FLAG_CURRENT => 'current',
self::FLAG_TEMP => 'temporary',
self::FLAG_SECOND => 'secondary',
self::FLAG_CEDEX => 'cedex',
);
- /** Data of the filter
- */
- private $text;
- private $type;
- private $flags;
- private $countryId;
- private $administrativeAreaId;
- private $subAdministrativeAreaId;
- private $localityId;
- private $postalCode;
-
- private $textSearchMode;
+ protected $flags;
- public function __construct($text = null, $textSearchMode = self::CONTAINS,
- $type = null, $flags = self::FLAG_ANY, $countryId = null, $administrativeAreaId = null,
- $subAdministrativeAreaId = null, $localityId = null, $postalCode = null)
+ public function __construct($type = null, $flags = null)
{
- $this->text = $text;
- $this->textSearchMode = $textSearchMode;
- $this->type = $type;
- $this->flags = $flags;
- $this->countryId = $countryId;
- $this->administrativeAreaId = $administrativeAreaId;
- $this->subAdministrativeAreaId = $subAdministrativeAreaId;
- $this->localityId = $localityId;
- $this->postalCode = $postalCode;
+ $this->type = $type;
+ $this->flags = $flags;
}
- public function buildCondition(UserFilter &$uf)
+ protected function initConds($sub)
{
- $sub = $uf->addAddressFilter();
$conds = array();
- if ($this->text != null) {
- $left = $sub . '.text ';
- $op = ' LIKE ';
- if (($this->textSearchMode & self::CONTAINS) == 0) {
- $right = XDB::format('{?}', $this->text);
- $op = ' = ';
- } else if (($this->mode & self::CONTAINS) == self::PREFIX) {
- $right = XDB::format('CONCAT({?}, \'%\')', $this->text);
- } else if (($this->mode & self::CONTAINS) == self::SUFFIX) {
- $right = XDB::format('CONCAT(\'%\', {?})', $this->text);
- } else {
- $right = XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->text);
+ $types = array();
+ foreach (self::$typetexts as $flag => $type) {
+ if ($flag & $this->type) {
+ $types[] = $type;
}
- $conds[] = $left . $op . $right;
}
-
- if ($this->type != null) {
- $conds[] = $sub . '.type = ' . XDB::format('{?}', $this->type);
+ if (count($types)) {
+ $conds[] = XDB::format($sub . '.type IN {?}', $types);
}
if ($this->flags != self::FLAG_ANY) {
}
}
}
+ return $conds;
+ }
- if ($this->countryId != null) {
- $conds[] = $sub . '.countryId = ' . XDB::format('{?}', $this->countryId);
+}
+// }}}
+
+// {{{ class UFC_AddressText
+/** Select users based on their address, using full text search
+ * @param $text Text for filter in fulltext search
+ * @param $textSearchMode Mode for search (one of XDB::WILDCARD_*)
+ * @param $type Filter on address type
+ * @param $flags Filter on address flags
+ * @param $country Filter on address country
+ * @param $locality Filter on address locality
+ */
+class UFC_AddressText extends UFC_Address
+{
+
+ private $text;
+ private $textSearchMode;
+
+ public function __construct($text = null, $textSearchMode = XDB::WILDCARD_CONTAINS,
+ $type = null, $flags = self::FLAG_ANY, $country = null, $locality = null)
+ {
+ parent::__construct($type, $flags);
+ $this->text = $text;
+ $this->textSearchMode = $textSearchMode;
+ $this->country = $country;
+ $this->locality = $locality;
+ }
+
+ private function mkMatch($txt)
+ {
+ return XDB::formatWildcards($this->textSearchMode, $txt);
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addAddressFilter();
+ $conds = $this->initConds($sub);
+ if ($this->text != null) {
+ $conds[] = $sub . '.text' . $this->mkMatch($this->text);
}
- if ($this->administrativeAreaId != null) {
- $conds[] = $sub . '.administrativeAreaId = ' . XDB::format('{?}', $this->administrativeAreaId);
+
+ if ($this->country != null) {
+ $subc = $uf->addAddressCountryFilter();
+ $subconds = array();
+ $subconds[] = $subc . '.country' . $this->mkMatch($this->country);
+ $subconds[] = $subc . '.countryFR' . $this->mkMatch($this->country);
+ $conds[] = implode(' OR ', $subconds);
}
- if ($this->subAdministrativeAreaId != null) {
- $conds[] = $sub . '.subAdministrativeAreaId = ' . XDB::format('{?}', $this->subAdministrativeAreaId);
+
+ if ($this->locality != null) {
+ $subl = $uf->addAddressLocalityFilter();
+ $conds[] = $subl . '.name' . $this->mkMatch($this->locality);
}
- if ($this->localityId != null) {
- $conds[] = $sub . '.localityId = ' . XDB::format('{?}', $this->localityId);
+
+ return implode(' AND ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_AddressField
+/** Filters users based on their address,
+ * @param $val Either a code for one of the fields, or an array of such codes
+ * @param $fieldtype The type of field to look for
+ * @param $type Filter on address type
+ * @param $flags Filter on address flags
+ */
+class UFC_AddressField extends UFC_Address
+{
+ const FIELD_COUNTRY = 1;
+ const FIELD_ADMAREA = 2;
+ const FIELD_SUBADMAREA = 3;
+ const FIELD_LOCALITY = 4;
+ const FIELD_ZIPCODE = 5;
+
+ /** Data of the filter
+ */
+ private $val;
+ private $fieldtype;
+
+ public function __construct($val, $fieldtype, $type = null, $flags = self::FLAG_ANY)
+ {
+ parent::__construct($type, $flags);
+
+ if (!is_array($val)) {
+ $val = array($val);
}
- if ($this->postalCode != null) {
- $conds[] = $sub . '.postalCode = ' . XDB::format('{?}', $this->postalCode);
+ $this->val = $val;
+ $this->fieldtype = $fieldtype;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addAddressFilter();
+ $conds = $this->initConds($sub);
+
+ switch ($this->fieldtype) {
+ case self::FIELD_COUNTRY:
+ $field = 'countryId';
+ break;
+ case self::FIELD_ADMAREA:
+ $field = 'administrativeAreaId';
+ break;
+ case self::FIELD_SUBADMAREA:
+ $field = 'subAdministrativeAreaId';
+ break;
+ case self::FIELD_LOCALITY:
+ $field = 'localityId';
+ break;
+ case self::FIELD_ZIPCODE:
+ $field = 'postalCode';
+ break;
+ default:
+ Platal::page()->killError('Invalid address field type: ' . $this->fieldtype);
}
+ $conds[] = XDB::format($sub . '.' . $field . ' IN {?}', $this->val);
return implode(' AND ', $conds);
}
$this->type = $type;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
/** Tables shortcuts:
* pc for profile_corps,
$this->rank = $rank;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
/** Tables shortcuts:
* pcr for profile_corps_rank
}
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addJobCompanyFilter();
$cond = $sub . '.' . $this->type . ' = ' . XDB::format('{?}', $this->value);
// {{{ class UFC_Job_Sectorization
/** Filters users based on the ((sub)sub)sector they work in
- * @param $sector The sector searched
- * @param $subsector The subsector
- * @param $subsubsector The subsubsector
+ * @param $val The ID of the sector, or an array of such IDs
+ * @param $type The kind of search (subsubsector/subsector/sector)
*/
class UFC_Job_Sectorization implements UserFilterCondition
{
+ private $val;
+ private $type;
- private $sector;
- private $subsector;
- private $subsubsector;
-
- public function __construct($sector = null, $subsector = null, $subsubsector = null)
+ public function __construct($val, $type = UserFilter::JOB_SECTOR)
{
- $this->sector = $sector;
- $this->subsector = $subsector;
- $this->subsubsector = $subsubsector;
+ self::assertType($type);
+ if (!is_array($val)) {
+ $val = array($val);
+ }
+ $this->val = $val;
+ $this->type = $type;
}
- public function buildCondition(UserFilter &$uf)
+ private static function assertType($type)
{
- // No need to add the JobFilter, it will be done by addJobSectorizationFilter
- $conds = array();
- if ($this->sector !== null) {
- $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SECTOR);
- $conds[] = $sub . '.id = ' . XDB::format('{?}', $this->sector);
- }
- if ($this->subsector !== null) {
- $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSECTOR);
- $conds[] = $sub . '.id = ' . XDB::format('{?}', $this->subsector);
- }
- if ($this->subsubsector !== null) {
- $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSUBSECTOR);
- $conds[] = $sub . '.id = ' . XDB::format('{?}', $this->subsubsector);
+ if ($type != UserFilter::JOB_SECTOR && $type != UserFilter::JOB_SUBSECTOR && $type != UserFilter::JOB_SUBSUBSECTOR) {
+ Platal::page()->killError("Type de secteur non valide.");
}
- return implode(' AND ', $conds);
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addJobSectorizationFilter($this->type);
+ return $sub . '.id = ' . XDB::format('{?}', $this->val);
}
}
// }}}
class UFC_Job_Description implements UserFilterCondition
{
- /** Meta-filters
- * Built with binary OR on UserFilter::JOB_*
- */
- const ANY = 31;
- const SECTORIZATION = 15;
-
private $description;
private $fields;
- public function __construct($description)
+ public function __construct($description, $fields)
{
$this->fields = $fields;
$this->description = $description;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$conds = array();
if ($this->fields & UserFilter::JOB_USERDEFINED) {
$sub = $uf->addJobFilter();
- $conds[] = $sub . '.description LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->description);
+ $conds[] = $sub . '.description ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
+ }
+ if ($this->fields & UserFilter::JOB_CV) {
+ $uf->requireProfiles();
+ $conds[] = 'p.cv ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
if ($this->fields & UserFilter::JOB_SECTOR) {
$sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SECTOR);
- $conds[] = $sub . '.name LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->description);
+ $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
if ($this->fields & UserFilter::JOB_SUBSECTOR) {
$sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSECTOR);
- $conds[] = $sub . '.name LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->description);
+ $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
if ($this->fields & UserFilter::JOB_SUBSUBSECTOR) {
$sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSUBSECTOR);
- $conds[] = $sub . '.name LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->description);
+ $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
$sub = $uf->addJobSectorizationFilter(UserFilter::JOB_ALTERNATES);
- $conds[] = $sub . '.name LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->description);
+ $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
return implode(' OR ', $conds);
}
$this->value = $value;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addNetworkingFilter();
$conds = array();
- $conds[] = $sub . '.address = ' . XDB::format('CONCAT(\'%\', {?}, \'%\')', $this->value);
+ $conds[] = $sub . '.address ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
if ($this->type != -1) {
- $conds[] = $sub . '.network_type = ' . XDB::format('{?}', $this->type);
+ $conds[] = $sub . '.nwid = ' . XDB::format('{?}', $this->type);
}
return implode(' AND ', $conds);
}
public function __construct($number, $num_type = self::NUM_ANY, $phone_type = self::PHONE_ANY)
{
- require_once('profil.inc.php');
+ require_once('profil.func.inc.php');
$this->number = $number;
$this->num_type = $num_type;
$this->phone_type = format_phone_number($phone_type);
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addPhoneFilter();
$conds = array();
$this->grade = $grade;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$conds = array();
$sub = $uf->addMedalFilter();
}
// }}}
+// {{{ class UFC_Photo
+/** Filters profiles with photo
+ */
+class UFC_Photo implements UserFilterCondition
+{
+ public function buildCondition(PlFilter &$uf)
+ {
+ $uf->addPhotoFilter();
+ return 'photo.attach IS NOT NULL';
+ }
+}
+// }}}
+
// {{{ class UFC_Mentor_Expertise
/** Filters users by mentoring expertise
* @param $expertise Domain of expertise
$this->expertise = $expertise;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addMentorFilter(UserFilter::MENTOR_EXPERTISE);
- return $sub . '.expertise LIKE ' . XDB::format('CONCAT(\'%\', {?}, \'%\'', $this->expertise);
+ return $sub . '.expertise ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->expertise);
}
}
// }}}
{
private $country;
- public function __construct($country)
+ public function __construct()
{
- $this->country = $country;
+ $this->country = pl_flatten(func_get_args());
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addMentorFilter(UserFilter::MENTOR_COUNTRY);
- return $sub . '.country = ' . XDB::format('{?}', $this->country);
+ return $sub . '.country IN ' . XDB::format('{?}', $this->country);
}
}
// }}}
// {{{ class UFC_Mentor_Sectorization
/** Filters users based on mentoring (sub|)sector
- * @param $sector ID of sector
- * @param $subsector Subsector (null for any)
+ * @param $sector ID of (sub)sector
+ * @param $type Whether we are looking for a sector or a subsector
*/
class UFC_Mentor_Sectorization implements UserFilterCondition
{
+ const SECTOR = 1;
+ const SUBSECTOR = 2;
private $sector;
- private $subsector;
+ private $type;
- public function __construct($sector, $subsector = null)
+ public function __construct($sector, $type = self::SECTOR)
{
$this->sector = $sector;
- $this->subsubsector = $subsector;
+ $this->type = $type;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addMentorFilter(UserFilter::MENTOR_SECTOR);
- $conds = array();
- $conds[] = $sub . '.sectorid = ' . XDB::format('{?}', $this->sector);
- if ($this->subsector != null) {
- $conds[] = $sub . '.subsectorid = ' . XDB::format('{?}', $this->subsector);
+ if ($this->type == self::SECTOR) {
+ $field = 'sectorid';
+ } else {
+ $field = 'subsectorid';
}
- return implode(' AND ', $conds);
+ return $sub . '.' . $field . ' = ' . XDB::format('{?}', $this->sector);
}
}
// }}}
*/
class UFC_Contact extends UFC_UserRelated
{
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$sub = $uf->addContactFilter($this->user->id());
return 'c' . $sub . '.contact IS NOT NULL';
*/
class UFC_WatchRegistration extends UFC_UserRelated
{
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
- if (!$this->user->watch('registration')) {
- return UserFilterCondition::COND_FALSE;
+ if (!$this->user->watchType('registration')) {
+ return PlFilterCondition::COND_FALSE;
}
$uids = $this->user->watchUsers();
if (count($uids) == 0) {
- return UserFilterCondition::COND_FALSE;
+ return PlFilterCondition::COND_FALSE;
} else {
- return '$UID IN ' . XDB::formatArray($uids);
+ return XDB::format('$UID IN {?}', $uids);
}
}
}
$this->grade = $grade;
}
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
$promos = $this->user->watchPromos();
if (count($promos) == 0) {
- return UserFilterCondition::COND_FALSE;
+ return PlFilterCondition::COND_FALSE;
} else {
$sube = $uf->addEducationFilter(true, $this->grade);
$field = 'pe' . $sube . '.' . UserFilter::promoYear($this->grade);
- return $field . ' IN ' . XDB::formatArray($promos);
+ return XDB::format($field . ' IN {?}', $promos);
}
}
}
*/
class UFC_WatchContact extends UFC_Contact
{
- public function buildCondition(UserFilter &$uf)
+ public function buildCondition(PlFilter &$uf)
{
if (!$this->user->watchContacts()) {
- return UserFilterCondition::COND_FALSE;
+ return PlFilterCondition::COND_FALSE;
}
return parent::buildCondition($uf);
}
}
// }}}
+// {{{ class UFC_MarketingHash
+/** Filters users using the hash generated
+ * to send marketing emails to him.
+ */
+class UFC_MarketingHash implements UserFilterCondition
+{
+ private $hash;
+
+ public function __construct($hash)
+ {
+ $this->hash = $hash;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $table = $uf->addMarketingHash();
+ return XDB::format('rm.hash = {?}', $this->hash);
+ }
+}
+// }}}
/******************
* ORDERS
* @param &$uf The UserFilter whose results must be ordered
* @return The name of the field to use for ordering results
*/
- abstract protected function getSortTokens(UserFilter &$uf);
+// abstract protected function getSortTokens(UserFilter &$uf);
}
// }}}
$this->grade = $grade;
}
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
if (UserFilter::isGrade($this->grade)) {
$sub = $uf->addEducationFilter($this->grade);
$this->particle = $particle;
}
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
- if (UserFilter::isDisplayName($this->type)) {
+ if (Profile::isDisplayName($this->type)) {
$sub = $uf->addDisplayFilter();
return 'pd' . $sub . '.' . $this->type;
} else {
}
// }}}
+// {{{ class UFO_Score
+class UFO_Score extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $toks = $uf->getNameTokens();
+ $scores = array();
+
+ // If there weren't any sort tokens, we shouldn't sort by score, sort by NULL instead
+ if (count($toks) == 0) {
+ return 'NULL';
+ }
+
+ foreach ($toks as $sub => $token) {
+ $scores[] = XDB::format('SUM(' . $sub . '.score + IF (' . $sub . '.token = {?}, 5, 0) )', $token);
+ }
+ return implode(' + ', $scores);
+ }
+}
+// }}}
+
// {{{ class UFO_Registration
/** Sorts users based on registration date
*/
class UFO_Registration extends UserFilterOrder
{
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
+ $uf->requireAccounts();
return 'a.registration_date';
}
}
*/
class UFO_Birthday extends UserFilterOrder
{
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
+ $uf->requireProfiles();
return 'p.next_birthday';
}
}
*/
class UFO_ProfileUpdate extends UserFilterOrder
{
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
+ $uf->requireProfiles();
return 'p.last_change';
}
}
*/
class UFO_Death extends UserFilterOrder
{
- protected function getSortTokens(UserFilter &$uf)
+ protected function getSortTokens(PlFilter &$uf)
{
+ $uf->requireProfiles();
return 'p.deathdate';
}
}
// }}}
+// {{{ class UFO_Uid
+/** Sorts users based on their uid
+ */
+class UFO_Uid extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $uf->requireAccounts();
+ return '$UID';
+ }
+}
+// }}}
+
+// {{{ class UFO_Hruid
+/** Sorts users based on their hruid
+ */
+class UFO_Hruid extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $uf->requireAccounts();
+ return 'a.hruid';
+ }
+}
+// }}}
+
+// {{{ class UFO_Pid
+/** Sorts users based on their pid
+ */
+class UFO_Pid extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ return '$PID';
+ }
+}
+// }}}
+
+// {{{ class UFO_Hrpid
+/** Sorts users based on their hrpid
+ */
+class UFO_Hrpid extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $uf->requireProfiles();
+ return 'p.hrpid';
+ }
+}
+// }}}
+
/***********************************
*********************************
* in the final query.
*
* In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
- * profile.pid, and $UID with auth_user_md5.user_id.
+ * profile.pid, and $UID with accounts.uid.
*
* For each kind of "JOIN" needed, a function named addXXXFilter() should be defined;
* its parameter will be used to set various private vars of the UserFilter describing
* The 'register_optional' function can be used to generate unique table aliases when
* the same table has to be joined several times with different aliases.
*/
-class UserFilter
+class UserFilter extends PlFilter
{
- private $joinMethods = array();
+ protected $joinMethods = array();
- private $joinMetas = array('$PID' => 'p.pid',
- '$UID' => 'a.uid',
- );
+ protected $joinMetas = array(
+ '$PID' => 'p.pid',
+ '$UID' => 'a.uid',
+ );
private $root;
private $sort = array();
private $query = null;
private $orderby = null;
- private $lastcount = null;
+ private $lastusercount = null;
+ private $lastprofilecount = null;
public function __construct($cond = null, $sort = null)
{
- if (empty(self::$joinMethods)) {
+ if (empty($this->joinMethods)) {
$class = new ReflectionClass('UserFilter');
foreach ($class->getMethods() as $method) {
$name = $method->getName();
if (substr($name, -5) == 'Joins' && $name != 'buildJoins') {
- self::$joinMethods[] = $name;
+ $this->joinMethods[] = $name;
}
}
}
if (!is_null($cond)) {
- if ($cond instanceof UserFilterCondition) {
+ if ($cond instanceof PlFilterCondition) {
$this->setCondition($cond);
}
}
private function buildQuery()
{
+ // The root condition is built first because some orders need info
+ // available only once all UFC have set their conditions (UFO_Score)
+ if (is_null($this->query)) {
+ $where = $this->root->buildCondition($this);
+ $where = str_replace(array_keys($this->joinMetas),
+ $this->joinMetas,
+ $where);
+ }
if (is_null($this->orderby)) {
$orders = array();
foreach ($this->sort as $sort) {
} else {
$this->orderby = 'ORDER BY ' . implode(', ', $orders);
}
+ $this->orderby = str_replace(array_keys($this->joinMetas),
+ $this->joinMetas,
+ $this->orderby);
}
if (is_null($this->query)) {
- $where = $this->root->buildCondition($this);
+ if ($this->with_accounts) {
+ $from = 'accounts AS a';
+ } else {
+ $this->requireProfiles();
+ $from = 'profiles AS p';
+ }
$joins = $this->buildJoins();
- $this->query = 'FROM accounts AS a
- LEFT JOIN account_profiles AS ap ON (ap.uid = a.uid AND FIND_IN_SET(\'owner\', ap.perms))
- LEFT JOIN profiles AS p ON (p.pid = ap.pid)
+ $this->query = 'FROM ' . $from . '
' . $joins . '
WHERE (' . $where . ')';
}
private function getUIDList($uids = null, PlLimit &$limit)
{
+ $this->requireAccounts();
$this->buildQuery();
$lim = $limit->getSql();
$cond = '';
- if (!is_null($uids)) {
- $cond = ' AND a.uid IN ' . XDB::formatArray($uids);
+ if (!empty($uids)) {
+ $cond = XDB::format(' AND a.uid IN {?}', $uids);
}
$fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS a.uid
' . $this->query . $cond . '
GROUP BY a.uid
' . $this->orderby . '
' . $lim);
- $this->lastcount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
+ $this->lastusercount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
return $fetched;
}
+ private function getPIDList($pids = null, PlLimit &$limit)
+ {
+ $this->requireProfiles();
+ $this->buildQuery();
+ $lim = $limit->getSql();
+ $cond = '';
+ if (!is_null($pids)) {
+ $cond = XDB::format(' AND p.pid IN {?}', $pids);
+ }
+ $fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS p.pid
+ ' . $this->query . $cond . '
+ GROUP BY p.pid
+ ' . $this->orderby . '
+ ' . $lim);
+ $this->lastprofilecount = (int)XDB::fetchOneCell('SELECT FOUND_ROWS()');
+ return $fetched;
+ }
+
+ private static function defaultLimit($limit) {
+ if ($limit == null) {
+ return new PlLimit();
+ } else {
+ return $limit;
+ }
+ }
+
/** Check that the user match the given rule.
*/
public function checkUser(PlUser &$user)
{
+ $this->requireAccounts();
$this->buildQuery();
$count = (int)XDB::fetchOneCell('SELECT COUNT(*)
' . $this->query . XDB::format(' AND a.uid = {?}', $user->id()));
return $count == 1;
}
- /** Filter a list of user to extract the users matching the rule.
+ /** Check that the profile match the given rule.
+ */
+ public function checkProfile(Profile &$profile)
+ {
+ $this->requireProfiles();
+ $this->buildQuery();
+ $count = (int)XDB::fetchOneCell('SELECT COUNT(*)
+ ' . $this->query . XDB::format(' AND p.pid = {?}', $profile->id()));
+ return $count == 1;
+ }
+
+ /** Default filter is on users
*/
- public function filter(array $users, PlLimit &$limit)
+ public function filter(array $users, $limit = null)
{
+ return $this->filterUsers($users, self::defaultLimit($limit));
+ }
+
+ /** Filter a list of users to extract the users matching the rule.
+ */
+ public function filterUsers(array $users, $limit = null)
+ {
+ $limit = self::defaultLimit($limit);
+ $this->requireAccounts();
$this->buildQuery();
$table = array();
$uids = array();
return $output;
}
- public function getUIDs(PlLimit &$limit)
+ /** Filter a list of profiles to extract the users matching the rule.
+ */
+ public function filterProfiles(array $profiles, $limit = null)
+ {
+ $limit = self::defaultLimit($limit);
+ $this->requireProfiles();
+ $this->buildQuery();
+ $table = array();
+ $pids = array();
+ foreach ($profiles as $profile) {
+ if ($profile instanceof Profile) {
+ $pid = $profile->id();
+ } else {
+ $pid = $profile;
+ }
+ $pids[] = $pid;
+ $table[$pid] = $profile;
+ }
+ $fetched = $this->getPIDList($pids, $limit);
+ $output = array();
+ foreach ($fetched as $pid) {
+ $output[] = $table[$pid];
+ }
+ return $output;
+ }
+
+ public function getUIDs($limit = null)
{
+ $limit = self::defaultLimit($limit);
return $this->getUIDList(null, $limit);
}
- public function getUsers(PlLimit &$limit)
+ public function getUID($pos = 0)
+ {
+ $uids =$this->getUIDList(null, new PlLimit(1, $pos));
+ if (count($uids) == 0) {
+ return null;
+ } else {
+ return $uids[0];
+ }
+ }
+
+ public function getPIDs($limit = null)
+ {
+ $limit = self::defaultLimit($limit);
+ return $this->getPIDList(null, $limit);
+ }
+
+ public function getPID($pos = 0)
+ {
+ $pids =$this->getPIDList(null, new PlLimit(1, $pos));
+ if (count($pids) == 0) {
+ return null;
+ } else {
+ return $pids[0];
+ }
+ }
+
+ public function getUsers($limit = null)
{
return User::getBulkUsersWithUIDs($this->getUIDs($limit));
}
- public function get(PlLimit &$limit)
+ public function getUser($pos = 0)
+ {
+ $uid = $this->getUID($pos);
+ if ($uid == null) {
+ return null;
+ } else {
+ return User::getWithUID($uid);
+ }
+ }
+
+ public function iterUsers($limit = null)
+ {
+ return User::iterOverUIDs($this->getUIDs($limit));
+ }
+
+ public function getProfiles($limit = null, $fields = 0x0000, $visibility = null)
+ {
+ return Profile::getBulkProfilesWithPIDs($this->getPIDs($limit), $fields, $visibility);
+ }
+
+ public function getProfile($pos = 0, $fields = 0x0000, $visibility = null)
+ {
+ $pid = $this->getPID($pos);
+ if ($pid == null) {
+ return null;
+ } else {
+ return Profile::get($pid, $fields, $visibility);
+ }
+ }
+
+ public function iterProfiles($limit = null, $fields = 0x0000, $visibility = null)
+ {
+ return Profile::iterOverPIDs($this->getPIDs($limit), true, $fields, $visibility);
+ }
+
+ public function get($limit = null)
{
return $this->getUsers($limit);
}
+
public function getTotalCount()
{
- if (is_null($this->lastcount)) {
+ return $this->getTotalUserCount();
+ }
+
+ public function getTotalUserCount()
+ {
+ if (is_null($this->lastusercount)) {
+ $this->requireAccounts();
$this->buildQuery();
return (int)XDB::fetchOneCell('SELECT COUNT(DISTINCT a.uid)
' . $this->query);
} else {
- return $this->lastcount;
+ return $this->lastusercount;
+ }
+ }
+
+ public function getTotalProfileCount()
+ {
+ if (is_null($this->lastprofilecount)) {
+ $this->requireProfiles();
+ $this->buildQuery();
+ return (int)XDB::fetchOneCell('SELECT COUNT(DISTINCT p.pid)
+ ' . $this->query);
+ } else {
+ return $this->lastprofilecount;
}
}
- public function setCondition(UserFilterCondition &$cond)
+ public function setCondition(PlFilterCondition &$cond)
{
$this->root =& $cond;
$this->query = null;
}
- public function addSort(UserFilterOrder &$sort)
+ public function addSort(PlFilterOrder &$sort)
{
$this->sort[] = $sort;
$this->orderby = null;
if ($promo_min != 0) {
$min = new UFC_Promo('>=', self::GRADE_ING, intval($promo_min));
} else {
- $min = new UFC_True();
+ $min = new PFC_True();
}
if ($promo_max != 0) {
$max = new UFC_Promo('<=', self::GRADE_ING, intval($promo_max));
} else {
- $max = new UFC_True();
+ $max = new PFC_True();
}
- return new UserFilter(new UFC_And($min, $max));
+ return new UserFilter(new PFC_And($min, $max));
}
static public function sortByName()
{
- return array(new UFO_Name(self::LASTNAME), new UFO_Name(self::FIRSTNAME));
+ return array(new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
}
static public function sortByPromo()
{
- return array(new UFO_Promo(), new UFO_Name(self::LASTNAME), new UFO_Name(self::FIRSTNAME));
+ return array(new UFO_Promo(), new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
}
static private function getDBSuffix($string)
{
- return preg_replace('/[^a-z0-9]/i', '', $string);
+ if (is_array($string)) {
+ if (count($string) == 1) {
+ return self::getDBSuffix(array_pop($string));
+ }
+ return md5(implode('|', $string));
+ } else {
+ return preg_replace('/[^a-z0-9]/i', '', $string);
+ }
}
return $sub;
}
+ /** PROFILE VS ACCOUNT
+ */
+ private $with_profiles = false;
+ private $with_accounts = false;
+ public function requireAccounts()
+ {
+ $this->with_accounts = true;
+ }
+
+ public function requireProfiles()
+ {
+ $this->with_profiles = true;
+ }
+
+ protected function accountJoins()
+ {
+ $joins = array();
+ if ($this->with_profiles && $this->with_accounts) {
+ $joins['ap'] = PlSqlJoin::left('account_profiles', '$ME.uid = $UID AND FIND_IN_SET(\'owner\', ap.perms)');
+ $joins['p'] = PlSqlJoin::left('profiles', '$PID = ap.pid');
+ }
+ return $joins;
+ }
+
/** DISPLAY
*/
const DISPLAY = 'display';
private $pd = false;
public function addDisplayFilter()
{
+ $this->requireProfiles();
$this->pd = true;
return '';
}
- private function displayJoins()
+ protected function displayJoins()
{
if ($this->pd) {
- return array('pd' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_display', '$ME.pid = $PID'));
+ return array('pd' => PlSqlJoin::left('profile_display', '$ME.pid = $PID'));
} else {
return array();
}
}
- /** NAMES
+ /** LOGGER
*/
- /* name tokens */
- const LASTNAME = 'lastname';
- const FIRSTNAME = 'firstname';
- const NICKNAME = 'nickname';
- const PSEUDONYM = 'pseudonym';
- const NAME = 'name';
- /* name variants */
- const VN_MARITAL = 'marital';
- const VN_ORDINARY = 'ordinary';
- const VN_OTHER = 'other';
- const VN_INI = 'ini';
- /* display names */
- const DN_FULL = 'directory_name';
- const DN_DISPLAY = 'yourself';
- const DN_YOURSELF = 'yourself';
- const DN_DIRECTORY = 'directory_name';
- const DN_PRIVATE = 'private_name';
- const DN_PUBLIC = 'public_name';
- const DN_SHORT = 'short_name';
- const DN_SORT = 'sort_name';
-
- static public $name_variants = array(
- self::LASTNAME => array(self::VN_MARITAL, self::VN_ORDINARY),
- self::FIRSTNAME => array(self::VN_ORDINARY, self::VN_INI, self::VN_OTHER)
- );
- static public function assertName($name)
+ private $with_logger = false;
+ public function addLoggerFilter()
{
- if (!Profile::getNameTypeId($name)) {
- Platal::page()->kill('Invalid name type');
+ $this->with_logger = true;
+ $this->requireAccounts();
+ return 'ls';
+ }
+ protected function loggerJoins()
+ {
+ $joins = array();
+ if ($this->with_logger) {
+ $joins['ls'] = PlSqlJoin::left('log_sessions', '$ME.uid = $UID');
}
+ return $joins;
}
- static public function isDisplayName($name)
+ /** NAMES
+ */
+
+ static public function assertName($name)
{
- return $name == self::DN_FULL || $name == self::DN_DISPLAY
- || $name == self::DN_YOURSELF || $name == self::DN_DIRECTORY
- || $name == self::DN_PRIVATE || $name == self::DN_PUBLIC
- || $name == self::DN_SHORT || $name == self::DN_SORT;
+ if (!DirEnum::getID(DirEnum::NAMETYPES, $name)) {
+ Platal::page()->kill('Invalid name type: ' . $name);
+ }
}
private $pn = array();
public function addNameFilter($type, $variant = null)
{
+ $this->requireProfiles();
if (!is_null($variant)) {
$ft = $type . '_' . $variant;
} else {
if (!is_null($variant) && $variant == 'other') {
$sub .= $this->option++;
}
- $this->pn[$sub] = Profile::getNameTypeId($ft);
+ $this->pn[$sub] = DirEnum::getID(DirEnum::NAMETYPES, $ft);
return $sub;
}
- private function nameJoins()
+ protected function nameJoins()
{
$joins = array();
foreach ($this->pn as $sub => $type) {
- $joins['pn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_name', '$ME.pid = $PID AND $ME.typeid = ' . $type);
+ $joins['pn' . $sub] = PlSqlJoin::left('profile_name', '$ME.pid = $PID AND $ME.typeid = {?}', $type);
+ }
+ return $joins;
+ }
+
+ /** NAMETOKENS
+ */
+ private $name_tokens = array();
+ private $nb_tokens = 0;
+
+ public function addNameTokensFilter($token)
+ {
+ $this->requireProfiles();
+ $sub = 'sn' . (1 + $this->nb_tokens);
+ $this->nb_tokens++;
+ $this->name_tokens[$sub] = $token;
+ return $sub;
+ }
+
+ protected function nameTokensJoins()
+ {
+ /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
+ $joins = array();
+ foreach ($this->name_tokens as $sub => $token) {
+ $joins[$sub] = PlSqlJoin::left('search_name', '$ME.pid = $PID');
}
return $joins;
}
+ public function getNameTokens()
+ {
+ return $this->name_tokens;
+ }
+
+ /** NATIONALITY
+ */
+
+ private $with_nat = false;
+ public function addNationalityFilter()
+ {
+ $this->with_nat = true;
+ return 'ngc';
+ }
+
+ protected function nationalityJoins()
+ {
+ $joins = array();
+ if ($this->with_nat) {
+ $joins['ngc'] = PlSqlJoin::left('geoloc_countries', '$ME.iso_3166_1_a2 = p.nationality1 OR $ME.iso_3166_1_a2 = p.nationality2 OR $ME.iso_3166_1_a2 = p.nationality3');
+ }
+ return $joins;
+ }
/** EDUCATION
*/
const GRADE_MST = 'M%';
static public function isGrade($grade)
{
- return $grade == self::GRADE_ING || $grade == self::GRADE_PHD || $grade == self::GRADE_MST;
+ return ($grade !== 0) && ($grade == self::GRADE_ING || $grade == self::GRADE_PHD || $grade == self::GRADE_MST);
}
static public function assertGrade($grade)
{
if (!self::isGrade($grade)) {
- Platal::page()->killError("DiplĂ´me non valide");
+ Platal::page()->killError("DiplĂ´me non valide: $grade");
}
}
private $with_pee = false;
public function addEducationFilter($x = false, $grade = null)
{
+ $this->requireProfiles();
if (!$x) {
$index = $this->option;
$sub = $this->option++;
return $sub;
}
- private function educationJoins()
+ protected function educationJoins()
{
$joins = array();
if ($this->with_pee) {
- $joins['pee'] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_enum', 'pee.abbreviation = \'X\'');
+ $joins['pee'] = PlSqlJoin::inner('profile_education_enum', 'pee.abbreviation = \'X\'');
}
foreach ($this->pepe as $grade => $sub) {
if ($this->isGrade($grade)) {
- $joins['pe' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_education', '$ME.eduid = pee.id AND $ME.uid = $PID');
- $joins['pede' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.abbreviation LIKE ' .
- XDB::format('{?}', $grade));
+ $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.eduid = pee.id AND $ME.pid = $PID');
+ $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid AND $ME.abbreviation LIKE {?}', $grade);
} else {
- $joins['pe' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_education', '$ME.uid = $PID');
- $joins['pee' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
- $joins['pede' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
+ $joins['pe' . $sub] = PlSqlJoin::left('profile_education', '$ME.pid = $PID');
+ $joins['pee' . $sub] = PlSqlJoin::inner('profile_education_enum', '$ME.id = pe' . $sub . '.eduid');
+ $joins['pede' . $sub] = PlSqlJoin::inner('profile_education_degree_enum', '$ME.id = pe' . $sub . '.degreeid');
}
}
return $joins;
private $gpm = array();
public function addGroupFilter($group = null)
{
+ $this->requireAccounts();
if (!is_null($group)) {
- if (ctype_digit($group)) {
+ if (is_int($group) || ctype_digit($group)) {
$index = $sub = $group;
} else {
$index = $group;
return $sub;
}
- private function groupJoins()
+ protected function groupJoins()
{
$joins = array();
foreach ($this->gpm as $sub => $key) {
if (is_null($key)) {
- $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groupex.asso');
- $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'groupex.membres', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
- } else if (ctype_digit($key)) {
- $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'groupex.membres', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
+ $joins['gpa' . $sub] = PlSqlJoin::inner('groups');
+ $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
+ } else if (is_int($key) || ctype_digit($key)) {
+ $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
} else {
- $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groupex.asso', XDB::format('$ME.diminutif = {?}', $key));
- $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'groupex.membres', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
+ $joins['gpa' . $sub] = PlSqlJoin::inner('groups', '$ME.diminutif = {?}', $key);
+ $joins['gpm' . $sub] = PlSqlJoin::left('group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
}
}
return $joins;
}
+ /** BINETS
+ */
+
+ private $with_bi = false;
+ private $with_bd = false;
+ public function addBinetsFilter($with_enum = false)
+ {
+ $this->requireProfiles();
+ $this->with_bi = true;
+ if ($with_enum) {
+ $this->with_bd = true;
+ return 'bd';
+ } else {
+ return 'bi';
+ }
+ }
+
+ protected function binetsJoins()
+ {
+ $joins = array();
+ if ($this->with_bi) {
+ $joins['bi'] = PlSqlJoin::left('profile_binets', '$ME.pid = $PID');
+ }
+ if ($this->with_bd) {
+ $joins['bd'] = PlSqlJoin::left('profile_binet_enum', '$ME.id = bi.binet_id');
+ }
+ return $joins;
+ }
+
/** EMAILS
*/
private $e = array();
public function addEmailRedirectFilter($email = null)
{
+ $this->requireAccounts();
return $this->register_optional($this->e, $email);
}
private $al = array();
public function addAliasFilter($alias = null)
{
+ $this->requireAccounts();
return $this->register_optional($this->al, $alias);
}
- private function emailJoins()
+ protected function emailJoins()
{
global $globals;
$joins = array();
foreach ($this->e as $sub=>$key) {
if (is_null($key)) {
- $joins['e' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'emails', '$ME.uid = $UID AND $ME.flags != \'filter\'');
+ $joins['e' . $sub] = PlSqlJoin::left('emails', '$ME.uid = $UID AND $ME.flags != \'filter\'');
} else {
- $joins['e' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'emails', XDB::format('$ME.uid = $UID AND $ME.flags != \'filter\' AND $ME.email = {?}', $key));
+ if (!is_array($key)) {
+ $key = array($key);
+ }
+ $joins['e' . $sub] = PlSqlJoin::left('emails', '$ME.uid = $UID AND $ME.flags != \'filter\'
+ AND $ME.email IN {?}', $key);
}
}
foreach ($this->al as $sub=>$key) {
if (is_null($key)) {
- $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.id = $UID AND $ME.type IN (\'alias\', \'a_vie\')');
+ $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\')');
} else if ($key == self::ALIAS_BEST) {
- $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.id = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND FIND_IN_SET(\'bestalias\', $ME.flags)');
+ $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND FIND_IN_SET(\'bestalias\', $ME.flags)');
} else if ($key == self::ALIAS_FORLIFE) {
- $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', '$ME.id = $UID AND $ME.type = \'a_vie\'');
+ $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type = \'a_vie\'');
} else {
- $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', XDB::format('$ME.id = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND $ME.alias = {?}', $key));
+ if (!is_array($key)) {
+ $key = array($key);
+ }
+ $joins['al' . $sub] = PlSqlJoin::left('aliases', '$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\')
+ AND $ME.alias IN {?}', $key);
}
}
foreach ($this->ve as $sub=>$key) {
if (is_null($key)) {
- $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', '$ME.type = \'user\'');
+ $joins['v' . $sub] = PlSqlJoin::left('virtual', '$ME.type = \'user\'');
} else {
- $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', XDB::format('$ME.type = \'user\' AND $ME.alias = {?}', $key));
+ if (!is_array($key)) {
+ $key = array($key);
+ }
+ $joins['v' . $sub] = PlSqlJoin::left('virtual', '$ME.type = \'user\' AND $ME.alias IN {?}', $key);
}
- $joins['vr' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual_redirect', XDB::format('$ME.vid = v' . $sub . '.vid
- AND ($ME.redirect IN (CONCAT(al_forlife.alias, \'@\', {?}),
- CONCAT(al_forlife.alias, \'@\', {?}),
- a.email))',
- $globals->mail->domain, $globals->mail->domain2));
+ $joins['vr' . $sub] = PlSqlJoin::left('virtual_redirect',
+ '$ME.vid = v' . $sub . '.vid
+ AND ($ME.redirect IN (CONCAT(al_forlife.alias, \'@\', {?}),
+ CONCAT(al_forlife.alias, \'@\', {?}),
+ a.email))',
+ $globals->mail->domain, $globals->mail->domain2);
}
return $joins;
}
private $with_pa = false;
public function addAddressFilter()
{
+ $this->requireProfiles();
$this->with_pa = true;
return 'pa';
}
- private function addressJoins()
+ private $with_pac = false;
+ public function addAddressCountryFilter()
+ {
+ $this->requireProfiles();
+ $this->addAddressFilter();
+ $this->with_pac = true;
+ return 'gc';
+ }
+
+ private $with_pal = false;
+ public function addAddressLocalityFilter()
+ {
+ $this->requireProfiles();
+ $this->addAddressFilter();
+ $this->with_pal = true;
+ return 'gl';
+ }
+
+ protected function addressJoins()
{
$joins = array();
if ($this->with_pa) {
- $joins['pa'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_address', '$ME.pid = $PID');
+ $joins['pa'] = PlSqlJoin::left('profile_addresses', '$ME.pid = $PID');
+ }
+ if ($this->with_pac) {
+ $joins['gc'] = PlSqlJoin::left('geoloc_countries', '$ME.iso_3166_1_a2 = pa.countryID');
+ }
+ if ($this->with_pal) {
+ $joins['gl'] = PlSqlJoin::left('geoloc_localities', '$ME.id = pa.localityID');
}
return $joins;
}
private $pcr = false;
public function addCorpsFilter($type)
{
+ $this->requireProfiles();
$this->pc = true;
if ($type == UFC_Corps::CURRENT) {
$pce['pcec'] = 'current_corpsid';
public function addCorpsRankFilter()
{
+ $this->requireProfiles();
$this->pc = true;
$this->pcr = true;
return 'pcr';
}
- private function corpsJoins()
+ protected function corpsJoins()
{
$joins = array();
if ($this->pc) {
- $joins['pc'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps', '$ME.uid = $UID');
+ $joins['pc'] = PlSqlJoin::left('profile_corps', '$ME.pid = $PID');
}
if ($this->pcr) {
- $joins['pcr'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps_rank_enum', '$ME.id = pc.rankid');
+ $joins['pcr'] = PlSqlJoin::left('profile_corps_rank_enum', '$ME.id = pc.rankid');
}
foreach($this->pce as $sub => $field) {
- $joins[$sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps_enum', '$ME.id = pc.' . $field);
+ $joins[$sub] = PlSqlJoin::left('profile_corps_enum', '$ME.id = pc.' . $field);
}
return $joins;
}
/** JOBS
*/
- const JOB_SECTOR = 1;
- const JOB_SUBSECTOR = 2;
- const JOB_SUBSUBSECTOR = 4;
- const JOB_ALTERNATES = 8;
- const JOB_USERDEFINED = 16;
+ const JOB_SECTOR = 0x0001;
+ const JOB_SUBSECTOR = 0x0002;
+ const JOB_SUBSUBSECTOR = 0x0004;
+ const JOB_ALTERNATES = 0x0008;
+ const JOB_USERDEFINED = 0x0010;
+ const JOB_CV = 0x0020;
+
+ const JOB_SECTORIZATION = 0x000F;
+ const JOB_ANY = 0x003F;
/** Joins :
* pj => profile_job
public function addJobFilter()
{
+ $this->requireProfiles();
$this->with_pj = true;
return 'pj';
}
}
}
- private function jobJoins()
+ protected function jobJoins()
{
$joins = array();
if ($this->with_pj) {
- $joins['pj'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job', '$ME.uid = $UID');
+ $joins['pj'] = PlSqlJoin::left('profile_job', '$ME.pid = $PID');
}
if ($this->with_pje) {
- $joins['pje'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_enum', '$ME.id = pj.jobid');
+ $joins['pje'] = PlSqlJoin::left('profile_job_enum', '$ME.id = pj.jobid');
}
if ($this->with_pjse) {
- $joins['pjse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_sector_enum', '$ME.id = pj.sectorid');
+ $joins['pjse'] = PlSqlJoin::left('profile_job_sector_enum', '$ME.id = pj.sectorid');
}
if ($this->with_pjsse) {
- $joins['pjsse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_subsector_enum', '$ME.id = pj.subsectorid');
+ $joins['pjsse'] = PlSqlJoin::left('profile_job_subsector_enum', '$ME.id = pj.subsectorid');
}
if ($this->with_pjssse) {
- $joins['pjssse'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_subsubsector_enum', '$ME.id = pj.subsubsectorid');
+ $joins['pjssse'] = PlSqlJoin::left('profile_job_subsubsector_enum', '$ME.id = pj.subsubsectorid');
}
if ($this->with_pja) {
- $joins['pja'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_alternates', '$ME.subsubsectorid = pj.subsubsectorid');
+ $joins['pja'] = PlSqlJoin::left('profile_job_alternates', '$ME.subsubsectorid = pj.subsubsectorid');
}
return $joins;
}
private $with_pnw = false;
public function addNetworkingFilter()
{
+ $this->requireAccounts();
$this->with_pnw = true;
return 'pnw';
}
- private function networkingJoins()
+ protected function networkingJoins()
{
$joins = array();
if ($this->with_pnw) {
- $joins['pnw'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_networking', '$ME.uid = $UID');
+ $joins['pnw'] = PlSqlJoin::left('profile_networking', '$ME.pid = $PID');
}
return $joins;
}
public function addPhoneFilter()
{
+ $this->requireAccounts();
$this->with_ptel = true;
return 'ptel';
}
- private function phoneJoins()
+ protected function phoneJoins()
{
$joins = array();
if ($this->with_ptel) {
- $joins['ptel'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_phone', '$ME.uid = $UID');
+ $joins['ptel'] = PlSqlJoin::left('profile_phones', '$ME.pid = $PID');
}
return $joins;
}
private $with_pmed = false;
public function addMedalFilter()
{
+ $this->requireProfiles();
$this->with_pmed = true;
return 'pmed';
}
- private function medalJoins()
+ protected function medalJoins()
{
$joins = array();
if ($this->with_pmed) {
- $joins['pmed'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_medals_sub', '$ME.uid = $UID');
+ $joins['pmed'] = PlSqlJoin::left('profile_medals', '$ME.pid = $PID');
}
return $joins;
}
public function addMentorFilter($type)
{
+ $this->requireAccounts();
switch($type) {
- case MENTOR_EXPERTISE:
- $pms['pme'] = 'profile_mentor';
+ case self::MENTOR_EXPERTISE:
+ $this->pms['pme'] = 'profile_mentor';
return 'pme';
- case MENTOR_COUNTRY:
- $pms['pmc'] = 'profile_mentor_country';
+ case self::MENTOR_COUNTRY:
+ $this->pms['pmc'] = 'profile_mentor_country';
return 'pmc';
- case MENTOR_SECTOR:
- $pms['pms'] = 'profile_mentor_sector';
+ case self::MENTOR_SECTOR:
+ $this->pms['pms'] = 'profile_mentor_sector';
return 'pms';
default:
Platal::page()->killError("Undefined mentor filter.");
}
}
- private function mentorJoins()
+ protected function mentorJoins()
{
$joins = array();
foreach ($this->pms as $sub => $tab) {
- $joins[$sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, $tab, '$ME.uid = $UID');
+ $joins[$sub] = PlSqlJoin::left($tab, '$ME.pid = $PID');
}
return $joins;
}
private $cts = array();
public function addContactFilter($uid = null)
{
+ $this->requireProfiles();
return $this->register_optional($this->cts, is_null($uid) ? null : 'user_' . $uid);
}
- private function contactJoins()
+ protected function contactJoins()
{
$joins = array();
foreach ($this->cts as $sub=>$key) {
if (is_null($key)) {
- $joins['c' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'contacts', '$ME.contact = $UID');
+ $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.contact = $PID');
} else {
- $joins['c' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'contacts', XDB::format('$ME.uid = {?} AND $ME.contact = $UID', substr($key, 5)));
+ $joins['c' . $sub] = PlSqlJoin::left('contacts', '$ME.uid = {?} AND $ME.contact = $PID', substr($key, 5));
}
}
return $joins;
private $wn = array();
public function addWatchRegistrationFilter($uid = null)
{
+ $this->requireAccounts();
return $this->register_optional($this->wn, is_null($uid) ? null : 'user_' . $uid);
}
private $wp = array();
public function addWatchPromoFilter($uid = null)
{
+ $this->requireAccounts();
return $this->register_optional($this->wp, is_null($uid) ? null : 'user_' . $uid);
}
private $w = array();
public function addWatchFilter($uid = null)
{
+ $this->requireAccounts();
return $this->register_optional($this->w, is_null($uid) ? null : 'user_' . $uid);
}
- private function watchJoins()
+ protected function watchJoins()
{
$joins = array();
foreach ($this->w as $sub=>$key) {
if (is_null($key)) {
- $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch');
+ $joins['w' . $sub] = PlSqlJoin::left('watch');
} else {
- $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch', XDB::format('$ME.uid = {?}', substr($key, 5)));
+ $joins['w' . $sub] = PlSqlJoin::left('watch', '$ME.uid = {?}', substr($key, 5));
}
}
foreach ($this->wn as $sub=>$key) {
if (is_null($key)) {
- $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', '$ME.ni_id = $UID');
+ $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
} else {
- $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5)));
+ $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
}
}
foreach ($this->wn as $sub=>$key) {
if (is_null($key)) {
- $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', '$ME.ni_id = $UID');
+ $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.ni_id = $UID');
} else {
- $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5)));
+ $joins['wn' . $sub] = PlSqlJoin::left('watch_nonins', '$ME.uid = {?} AND $ME.ni_id = $UID', substr($key, 5));
}
}
foreach ($this->wp as $sub=>$key) {
if (is_null($key)) {
- $joins['wp' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_promo');
+ $joins['wp' . $sub] = PlSqlJoin::left('watch_promo');
} else {
- $joins['wp' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_promo', XDB::format('$ME.uid = {?}', substr($key, 5)));
+ $joins['wp' . $sub] = PlSqlJoin::left('watch_promo', '$ME.uid = {?}', substr($key, 5));
}
}
return $joins;
}
+
+
+ /** PHOTOS
+ */
+ private $with_photo;
+ public function addPhotoFilter()
+ {
+ $this->requireProfiles();
+ $this->with_photo = true;
+ }
+
+ protected function photoJoins()
+ {
+ if ($this->with_photo) {
+ return array('photo' => PlSqlJoin::left('profile_photos', '$ME.pid = $PID'));
+ } else {
+ return array();
+ }
+ }
+
+
+ /** MARKETING
+ */
+ private $with_rm;
+ public function addMarketingHash()
+ {
+ $this->requireAccounts();
+ $this->with_rm = true;
+ }
+
+ protected function marketingJoins()
+ {
+ if ($this->with_rm) {
+ return array('rm' => PlSqlJoin::left('register_marketing', '$ME.uid = $UID'));
+ } else {
+ return array();
+ }
+ }
+}
+// }}}
+
+// {{{ class ProfileFilter
+class ProfileFilter extends UserFilter
+{
+ public function get($limit = null)
+ {
+ return $this->getProfiles($limit);
+ }
+
+ public function filter(array $profiles, $limit = null)
+ {
+ return $this->filterProfiles($profiles, self::defaultLimit($limit));
+ }
+
+ public function getTotalCount()
+ {
+ return $this->getTotalProfileCount();
+ }
}
// }}}