<?php
/***************************************************************************
- * Copyright (C) 2003-2010 Polytechnique.org *
+ * Copyright (C) 2003-2011 Polytechnique.org *
* http://opensource.polytechnique.org/ *
* *
* This program is free software; you can redistribute it and/or modify *
*/
abstract class UserFilterCondition implements PlFilterCondition
{
+ const OP_EQUALS = '=';
+ const OP_GREATER = '>';
+ const OP_NOTGREATER = '<=';
+ const OP_LESSER = '<';
+ const OP_NOTLESSER = '>=';
+ const OP_NULL = 'null';
+ const OP_NOTNULL = 'not null';
+ const OP_CONTAINS = 'contains';
+ const OP_PREFIX = 'prefix';
+ const OP_SUFFIX = 'suffix';
+
+ protected function buildExport($type)
+ {
+ $export = array('type' => $type);
+ return $export;
+ }
+
public function export()
{
throw new Exception("This class is not exportable");
}
+
+ public static function comparisonFromXDBWildcard($wildcard)
+ {
+ switch ($wildcard) {
+ case XDB::WILDCARD_EXACT:
+ return self::OP_EQUALS;
+ case XDB::WILDCARD_PREFIX:
+ return self::OP_PREFIX;
+ case XDB::WILDCARD_SUFFIX:
+ return self::OP_SUFFIX;
+ case XDB::WILDCARD_CONTAINS:
+ return self::OP_CONTAINS;
+ }
+ throw new Exception("Unknown wildcard mode: $wildcard");
+ }
+
+ public static function xdbWildcardFromComparison($comparison)
+ {
+ if (!self::isStringComparison($comparison)) {
+ throw new Exception("Unknown string coparison: $comparison");
+ }
+ switch ($comparison) {
+ case self::OP_EQUALS:
+ return XDB::WILDCARD_EXACT;
+ case self::OP_PREFIX:
+ return XDB::WILDCARD_PREFIX;
+ case self::OP_SUFFIX:
+ return XDB::WILDCARD_SUFFIX;
+ case self::OP_CONTAINS:
+ return XDB::WILDCARD_CONTAINS;
+ }
+ }
+
+ private static function isNumericComparison($comparison)
+ {
+ return $comparison == self::OP_EQUALS
+ || $comparison == self::OP_GREATER
+ || $comparison == self::OP_NOTGREATER
+ || $comparison == self::OP_LESSER
+ || $comparison == self::OP_NOTLESSER;
+ }
+
+ private static function isStringComparison($comparison)
+ {
+ return $comparison == self::OP_EQUALS
+ || $comparison == self::OP_CONTAINS
+ || $comparison == self::OP_PREFIX
+ || $comparison == self::OP_SUFFIX;
+ }
+
+ public static function fromExport(array $export)
+ {
+ $export = new PlDict($export);
+ if (!$export->has('type')) {
+ throw new Exception("Missing type in export");
+ }
+ $type = $export->s('type');
+ $cond = null;
+ switch ($type) {
+ case 'and':
+ case 'or':
+ case 'not':
+ case 'true':
+ case 'false':
+ $class = 'pfc_' . $type;
+ $cond = new $class();
+ break;
+
+ case 'host':
+ if ($export->has('ip')) {
+ $cond = new UFC_Ip($export->s('ip'));
+ }
+ break;
+
+ case 'comment':
+ if ($export->has('text') && $export->s('comparison') == self::OP_CONTAINS) {
+ $cond = new UFC_Comment($export->s('text'));
+ }
+ break;
+
+ case 'promo':
+ if ($export->has('promo') && self::isNumericComparison($export->s('comparison'))) {
+ $cond = new UFC_Promo($export->s('comparison'),
+ $export->s('grade', UserFilter::DISPLAY),
+ $export->s('promo'));
+ }
+ break;
+
+ case 'lastname':
+ case 'name':
+ case 'firstname':
+ case 'nickname':
+ case 'pseudonym':
+ if ($export->has('text')) {
+ $flag = self::xdbWildcardFromComparison($export->s('comparison'));
+ if ($export->b('search_in_variants')) {
+ $flag |= UFC_Name::VARIANTS;
+ }
+ if ($export->b('search_in_particle')) {
+ $flag |= UFC_Name::PARTICLE;
+ }
+ $cond = new UFC_Name($type, $export->s('text'), $flag);
+ }
+ break;
+
+ case 'account_type':
+ case 'account_perm':
+ case 'hrpid':
+ case 'hruid':
+ $values = $export->v('values', array());
+ $class = 'ufc_' . str_replace('_', '', $type);
+ $cond = new $class($values);
+ break;
+
+ case 'school_id':
+ $values = $export->v('values', array());
+ $school_type = $export->s('school_type');
+ $cond = new UFC_SchoolId($school_type, $values);
+ break;
+
+ case 'has_profile':
+ case 'has_email_redirect':
+ case 'has_valid_email':
+ $class = 'ufc_' . str_replace('_', '', $type);
+ $cond = new $class();
+ break;
+
+ default:
+ throw new Exception("Unknown condition type: $type");
+ }
+ if (is_null($cond)) {
+ throw new Exception("Unsupported $type definition");
+ }
+ if ($cond instanceof PFC_NChildren) {
+ $children = $export->v('children', array());
+ foreach ($children as $child) {
+ $cond->addChild(self::fromExport($child));
+ }
+ } else if ($cond instanceof PFC_OneChild) {
+ if ($export->has('child')) {
+ $cond->setChild(self::fromExport($export->v('child')));
+ }
+ }
+ return $cond;
+ }
}
// }}}
-
// {{{ class UFC_HasProfile
/** Filters users who have a profile
*/
$uf->requireProfiles();
return '$PID IS NOT NULL';
}
+
+ public function export()
+ {
+ return $this->buildExport('has_profile');
+ }
}
// }}}
-
// {{{ class UFC_AccountType
/** Filters users who have one of the given account types
*/
$uf->requireAccounts();
return XDB::format('a.type IN {?}', $this->types);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('account_type');
+ $export['values'] = $this->types;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_AccountPerm
/** Filters users who have one of the given permissions
*/
return implode(' OR ', $conds);
}
}
+
+ public function export()
+ {
+ $export = $this->buildExport('account_perm');
+ $export['values'] = $this->perms;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_Hruid
/** Filters users based on their hruid
* @param $val Either an hruid, or a list of those
$uf->requireAccounts();
return XDB::format('a.hruid IN {?}', $this->hruids);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('hruid');
+ $export['values'] = $this->hruids;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_Hrpid
/** Filters users based on the hrpid of their profiles
* @param $val Either an hrpid, or a list of those
$uf->requireProfiles();
return XDB::format('p.hrpid IN {?}', $this->hrpids);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('hrpid');
+ $export['values'] = $this->hrpids;
+ return $export;
+ }
}
// }}}
+// {{{ class UFC_HasEmailRedirect
+/** Filters users, keeping only those with a valid email redirection (only X.org accounts).
+ */
+class UFC_HasEmailRedirect extends UserFilterCondition
+{
+ public function buildCondition(PlFilter $uf)
+ {
+ $sub_redirect = $uf->addActiveEmailRedirectFilter();
+ return 'rf.redirect IS NOT NULL';
+ }
+
+ public function export()
+ {
+ $export = $this->buildExport('has_email_redirect');
+ return $export;
+ }
+}
+// }}}
+// {{{ class UFC_HasValidEmail
+/** Filters users, keeping only those with a valid email address (all accounts).
+ */
+class UFC_HasValidEmail extends UserFilterCondition
+{
+ public function buildCondition(PlFilter $uf)
+ {
+ $sub_redirect = $uf->addEmailRedirectFilter();
+ $uf->requireAccounts();
+ return 'ra' . $sub_redirect . '.flags = \'active\' OR a.email IS NOT NULL';
+ }
+ public function export()
+ {
+ $export = $this->buildExport('has_valid_email');
+ return $export;
+ }
+}
+// }}}
// {{{ class UFC_Ip
/** Filters users based on one of their last IPs
* @param $ip IP from which connection are checked
$ip = ip_to_uint($this->ip);
return XDB::format($sub . '.ip = {?} OR ' . $sub . '.forward_ip = {?}', $ip, $ip);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('host');
+ $export['ip'] = $this->ip;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_Comment
class UFC_Comment extends UserFilterCondition
{
$uf->requireProfiles();
return $uf->getVisibilityCondition('p.freetext_pub') . ' AND p.freetext ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->text);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('comment');
+ $export['comparison'] = self::OP_CONTAINS;
+ $export['text'] = $this->text;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_Promo
/** Filters users based on promotion
* @param $comparison Comparison operator (>, =, ...)
return $field . ' IS NOT NULL AND ' . $field . ' ' . $this->comparison . ' ' . XDB::format('{?}', $this->promo);
}
}
+
+ public function export()
+ {
+ $export = $this->buildExport('promo');
+ $export['comparison'] = $this->comparison;
+ if ($this->grade != UserFilter::DISPLAY) {
+ $export['grade'] = $this->grade;
+ }
+ $export['promo'] = $this->promo;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_SchoolId
/** Filters users based on their shoold identifier
* @param type Parameter type (Xorg, AX, School)
}
return XDB::format('p.' . $type . '_id IN {?}', $ids);
}
+
+ public function export()
+ {
+ $export = $this->buildExport('school_id');
+ $export['school_type'] = $this->type;
+ $export['values'] = $this->ids;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_EducationSchool
/** Filters users by formation
* @param $val The formation to search (either ID or array of IDs)
}
}
// }}}
-
// {{{ class UFC_EducationDegree
class UFC_EducationDegree extends UserFilterCondition
{
}
}
// }}}
-
// {{{ class UFC_EducationField
class UFC_EducationField extends UserFilterCondition
{
}
}
// }}}
-
// {{{ class UFC_Name
/** Filters users based on name
* @param $type Type of name field on which filtering is done (firstname, lastname...)
}
return implode(' OR ', $conds);
}
+
+ public function export()
+ {
+ $export = $this->buildExport($this->type);
+ if ($this->mode & self::VARIANTS) {
+ $export['search_in_variants'] = true;
+ }
+ if ($this->mode & self::PARTICLE) {
+ $export['search_in_particle'] = true;
+ }
+ $export['comparison'] = self::comparisonFromXDBWildcard($this->mode & 0x3);
+ $export['text'] = $this->text;
+ return $export;
+ }
}
// }}}
-
// {{{ class UFC_NameTokens
/** Selects users based on tokens in their name (for quicksearch)
* @param $tokens An array of tokens to search
private $flags;
private $soundex;
private $exact;
+ private $general_type;
- public function __construct($tokens, $flags = array(), $soundex = false, $exact = false)
+ public function __construct($tokens, $flags = array(), $soundex = false, $exact = false, $general_type = '')
{
if (is_array($tokens)) {
$this->tokens = $tokens;
}
$this->soundex = $soundex;
$this->exact = $exact;
+ $this->general_type = $general_type;
}
public function buildCondition(PlFilter $uf)
if ($this->flags != null) {
$c .= XDB::format(' AND ' . $sub . '.flags IN {?}', $this->flags);
}
+ if ($this->general_type) {
+ $c .= XDB::format(' AND ' . $sub . '.general_type = {?}', $this->general_type);
+ }
$conds[] = $c;
}
}
}
// }}}
-
// {{{ class UFC_Nationality
class UFC_Nationality extends UserFilterCondition
{
}
}
// }}}
-
// {{{ class UFC_Dead
/** Filters users based on death date
* @param $comparison Comparison operator
}
}
// }}}
-
// {{{ class UFC_Registered
/** Filters users based on registration state
* @param $active Whether we want to use only "active" users (i.e with a valid redirection)
}
}
// }}}
-
// {{{ class UFC_ProfileUpdated
/** Filters users based on profile update date
* @param $comparison Comparison operator
}
}
// }}}
-
// {{{ class UFC_Birthday
/** Filters users based on next birthday date
* @param $comparison Comparison operator
}
}
// }}}
-
// {{{ class UFC_Sex
/** Filters users based on sex
* @parm $sex One of User::GENDER_MALE or User::GENDER_FEMALE, for selecting users
}
}
// }}}
+// {{{ class UFC_NLSubscribed
+/** Filters users based on NL subscription
+ * @param $nlid NL whose subscribers we are selecting
+ * @param $issue Select only subscribers who have not yet received that issue
+ */
+class UFC_NLSubscribed extends UserFilterCondition
+{
+ private $nlid;
+ private $issue_id;
+ public function __construct($nlid, $issue_id)
+ {
+ $this->nlid = $nlid;
+ $this->issue_id = $issue_id;
+ }
+ public function buildCondition(PlFilter $uf)
+ {
+ $sub = $uf->addNewsLetterFilter($this->nlid);
+ return XDB::format($sub . '.last < {?}', $this->issue_id);
+ }
+}
+// }}}
// {{{ class UFC_Group
/** Filters users based on group membership
* @param $group Group whose members we are selecting
public function buildCondition(PlFilter $uf)
{
- // Groups have AX visibility.
- if ($uf->getVisibilityLevel() == ProfileVisibility::VIS_PUBLIC) {
- return self::COND_TRUE;
+ // Groups are only visible for users with perm 'groups'.
+ if (!S::user()->checkPerms(User::PERM_GROUPS)) {
+ return self::COND_FALSE;
}
$sub = $uf->addGroupFilter($this->group);
$where = 'gpm' . $sub . '.perms IS NOT NULL';
}
}
// }}}
-
// {{{ 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
{
// Binets are private.
if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
- return self::CONF_TRUE;
+ return self::COND_TRUE;
}
$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
{
// Sections are private.
if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
- return self::CONF_TRUE;
+ return self::COND_TRUE;
}
$uf->requireProfiles();
return XDB::format('p.section IN {?}', $this->section);
}
}
// }}}
-
// {{{ class UFC_Email
/** Filters users based on an email or a list of emails
* @param $emails List of emails whose owner must be selected
public function buildCondition(PlFilter $uf)
{
$foreign = array();
- $virtual = array();
- $aliases = array();
- $cond = array();
+ $local = array();
+ $cond = array();
if (count($this->emails) == 0) {
return PlFilterCondition::COND_TRUE;
foreach ($this->emails as $entry) {
if (User::isForeignEmailAddress($entry)) {
$foreign[] = $entry;
- } else if (User::isVirtualEmailAddress($entry)) {
- $virtual[] = $entry;
} else {
- @list($user, $domain) = explode('@', $entry);
- $aliases[] = $user;
+ list($local_part, ) = explode('@', $entry);
+ $local[] = $local_part;
}
}
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';
+ $cond[] = XDB::format('ra' . $sub . '.redirect IS NOT NULL OR ra' . $sub . '.redirect IN {?} OR a.email IN {?}', $foreign, $foreign);
}
- if (count($aliases) > 0) {
- $sub = $uf->addAliasFilter($aliases);
- $cond[] = 'al' . $sub . '.alias IS NOT NULL';
+ if (count($local) > 0) {
+ $sub = $uf->addAliasFilter($local);
+ $cond[] = 'sa' . $sub . '.email IS NOT NULL';
}
return '(' . implode(') OR (', $cond) . ')';
}
}
// }}}
-
// {{{ class UFC_Address
abstract class UFC_Address extends UserFilterCondition
{
- /** Valid address type ('hq' is reserved for company addresses)
+ /** Valid address type
*/
- const TYPE_HOME = 1;
- const TYPE_PRO = 2;
- const TYPE_ANY = 3;
+ const TYPE_HOME = 1;
+ const TYPE_PRO = 2;
+ const TYPE_NON_HQ = 3;
+ const TYPE_HQ = 4;
+ const TYPE_ANY = 7;
/** Text for these types
*/
protected static $typetexts = array(
self::TYPE_HOME => 'home',
self::TYPE_PRO => 'pro',
+ self::TYPE_HQ => 'hq',
);
protected $type;
}
}
if (count($types)) {
- $conds[] = XDB::format($sub . '.type IN {?}', $types);
+ $conds[] = XDB::format('pa' . $sub . '.type IN {?}', $types);
}
if ($this->flags != self::FLAG_ANY) {
foreach(self::$flagtexts as $flag => $text) {
if ($flag & $this->flags) {
- $conds[] = 'FIND_IN_SET(' . XDB::format('{?}', $text) . ', ' . $sub . '.flags)';
+ $conds[] = 'FIND_IN_SET(' . XDB::format('{?}', $text) . ', pa' . $sub . '.flags)';
}
}
}
}
// }}}
-
-// {{{ 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, $uf->getVisibilityCondition($sub . '.pub'));
- if ($this->text != null) {
- $conds[] = $sub . '.text' . $this->mkMatch($this->text);
- }
-
- 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->locality != null) {
- $subl = $uf->addAddressLocalityFilter();
- $conds[] = $subl . '.name' . $this->mkMatch($this->locality);
- }
-
- 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 $type Filter on address type
* @param $flags Filter on address flags
*/
-class UFC_AddressField extends UFC_Address
+class UFC_AddressComponent extends UFC_Address
{
- const FIELD_COUNTRY = 1;
- const FIELD_ADMAREA = 2;
- const FIELD_SUBADMAREA = 3;
- const FIELD_LOCALITY = 4;
- const FIELD_ZIPCODE = 5;
+ static $components = array('sublocality', 'locality', 'administrative_area_level_3', 'administrative_area_level_2', 'administrative_area_level_1', 'country');
/** Data of the filter
*/
private $val;
private $fieldtype;
+ private $exact;
- public function __construct($val, $fieldtype, $type = null, $flags = self::FLAG_ANY)
+ public function __construct($val, $fieldtype, $exact = true, $type = null, $flags = self::FLAG_ANY)
{
- parent::__construct($type, $flags);
+ if (!in_array($fieldtype, self::$components)) {
+ Platal::page()->killError('Invalid address field type: ' . $this->fieldtype);
+ }
+ parent::__construct($type, $flags);
if (!is_array($val)) {
$val = array($val);
}
$this->val = $val;
$this->fieldtype = $fieldtype;
+ $this->exact = $exact;
}
public function buildCondition(PlFilter $uf)
{
- $sub = $uf->addAddressFilter();
- $conds = $this->initConds($sub, $uf->getVisibilityCondition($sub . '.pub'));
-
- 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);
+ $sub = $uf->addAddressFilter($this->fieldtype);
+ $conds = $this->initConds($sub, $uf->getVisibilityCondition('pa' . $sub . '.pub'));
+ $conds[] = XDB::format('pace' . $sub . '.id IN {?}', $this->val);
return implode(' AND ', $conds);
}
}
// }}}
-
// {{{ class UFC_Corps
/** Filters users based on the corps they belong to
* @param $corps Corps we are looking for (abbreviation)
const ORIGIN = 2;
private $corps;
+ private $id;
private $type;
- public function __construct($corps, $type = self::CURRENT)
+ public function __construct($corps, $id = null, $type = self::CURRENT)
{
$this->corps = $corps;
+ $this->id = $id;
$this->type = $type;
}
* pcec for profile_corps_enum - current
*/
$sub = $uf->addCorpsFilter($this->type);
- $cond = $sub . '.abbreviation = ' . $corps;
- $cond .= ' AND ' . $uf->getVisibilityCondition($sub . '.corps_pub');
+ if (is_null($this->id)) {
+ $cond = $sub . '.abbreviation = ' . $this->corps;
+ } else {
+ $cond = $sub . '.id = ' . $this->id;
+ }
+ // XXX(x2006barrois): find a way to get rid of that hardcoded
+ // reference to 'pc'.
+ $cond .= ' AND ' . $uf->getVisibilityCondition('pc.corps_pub');
return $cond;
}
}
// }}}
-
// {{{ class UFC_Corps_Rank
/** Filters users based on their rank in the corps
* @param $rank Rank we are looking for (abbreviation)
class UFC_Corps_Rank extends UserFilterCondition
{
private $rank;
- public function __construct($rank)
+ private $id;
+
+ public function __construct($rank, $id = null)
{
$this->rank = $rank;
+ $this->id = $id;
}
public function buildCondition(PlFilter $uf)
* pcr for profile_corps_rank
*/
$sub = $uf->addCorpsRankFilter();
- $cond = $sub . '.abbreviation = ' . $rank;
+ if (is_null($this->id)) {
+ $cond = $sub . '.abbreviation = ' . $this->rank;
+ } else {
+ $cond = $sub . '.id = ' . $this->id;
+ }
// XXX(x2006barrois): find a way to get rid of that hardcoded
// reference to 'pc'.
$cond .= ' AND ' . $uf->getVisibilityCondition('pc.corps_pub');
}
}
// }}}
-
// {{{ class UFC_Job_Company
/** Filters users based on the company they belong to
* @param $type The field being searched (self::JOBID, self::JOBNAME or self::JOBACRONYM)
}
}
// }}}
-
// {{{ class UFC_Job_Terms
/** Filters users based on the job terms they assigned to one of their
* jobs.
}
}
// }}}
-
// {{{ class UFC_Job_Description
/** Filters users based on their job description
* @param $description The text being searched for
// don't do anything. Otherwise restrict to standard job visibility.
if ($this->fields == UserFilter::JOB_CV) {
if ($uf->getVisibilityLevel() != ProfileVisibility::VIS_PRIVATE) {
- return self::CONF_TRUE;
+ return self::COND_TRUE;
}
- } else {
- $conds[] = $uf->getVisibilityCondition($jsub . '.pub');
}
-
if ($this->fields & UserFilter::JOB_USERDEFINED) {
$conds[] = $jsub . '.description ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
$uf->requireProfiles();
$conds[] = 'p.cv ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
}
- return implode(' OR ', $conds);
+ if (count($conds) == 0) {
+ return self::COND_TRUE;
+ }
+ return $uf->getVisibilityCondition($jsub . '.pub') . ' AND ( ' . implode(' OR ', $conds) . ' )';
}
}
// }}}
-
// {{{ class UFC_Networking
/** Filters users based on network identity (IRC, ...)
* @param $type Type of network (-1 for any)
}
}
// }}}
-
// {{{ class UFC_Phone
/** Filters users based on their phone number
* @param $num_type Type of number (pro/user/home)
{
$phone = new Phone(array('display' => $number));
$phone->format();
- $this->number = $phone->search();
+ $this->number = $phone->search;
$this->num_type = $num_type;
$this->phone_type = $phone_type;
}
}
}
// }}}
-
// {{{ class UFC_Medal
/** Filters users based on their medals
* @param $medal ID of the medal
}
}
// }}}
-
// {{{ class UFC_Photo
/** Filters profiles with photo
*/
}
}
// }}}
-
// {{{ class UFC_Mentor
class UFC_Mentor extends UserFilterCondition
{
}
}
// }}}
-
-
// {{{ class UFC_Mentor_Expertise
/** Filters users by mentoring expertise
* @param $expertise Domain of expertise
}
}
// }}}
-
// {{{ class UFC_Mentor_Country
/** Filters users by mentoring country
* @param $country Two-letters code of country being searched
}
}
// }}}
-
// {{{ class UFC_Mentor_Terms
/** Filters users based on the job terms they used in mentoring.
* @param $val The ID of the job term, or an array of such IDs
}
}
// }}}
-
// {{{ class UFC_UserRelated
/** Filters users based on a relation toward a user
* @param $user User to which searched users are related
abstract class UFC_UserRelated extends UserFilterCondition
{
protected $user;
- public function __construct(PlUser &$user)
+ public function __construct(PlUser $user)
{
$this->user =& $user;
}
}
// }}}
+// {{{ class UFC_DeltaTen
+class UFC_DeltaTen extends UserFilterCondition
+{
+ public function buildCondition(PlFilter $uf)
+ {
+ $sub = $uf->addDeltaTenFilter(UserFilter::DELTATEN);
+ return $sub . '.message IS NOT NULL';
+ }
+}
+// }}}
+// {{{ class UFC_DeltaTen_Message
+/** Filters users by deltaten message
+ * @param $message Message for the DeltaTen program
+ */
+class UFC_DeltaTen_Message extends UserFilterCondition
+{
+ private $message;
+
+ public function __construct($message)
+ {
+ $this->message = $message;
+ }
+ public function buildCondition(PlFilter $uf)
+ {
+ $sub = $uf->addDeltaTenFilter(UserFilter::DELTATEN_MESSAGE);
+ return $sub . '.message ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->message);
+ }
+}
+// }}}
// {{{ class UFC_Contact
/** Filters users who belong to selected user's contacts
*/
}
}
// }}}
-
// {{{ class UFC_WatchRegistration
/** Filters users being watched by selected user
*/
}
}
// }}}
-
// {{{ class UFC_WatchPromo
/** Filters users belonging to a promo watched by selected user
* @param $user Selected user (the one watching promo)
class UFC_WatchPromo extends UFC_UserRelated
{
private $grade;
- public function __construct(PlUser &$user, $grade = UserFilter::GRADE_ING)
+ public function __construct(PlUser $user, $grade = UserFilter::GRADE_ING)
{
parent::__construct($user);
$this->grade = $grade;
}
}
// }}}
-
// {{{ class UFC_WatchContact
/** Filters users watched by selected user
*/
}
}
// }}}
-
// {{{ class UFC_MarketingHash
/** Filters users using the hash generated
* to send marketing emails to him.
projects / platal.git / blobdiff