+ $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[] = $sub . '.' . $field . ' IN ' . XDB::formatArray($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)
+ * @param $type Whether we search for original or current corps
+ */
+class UFC_Corps implements UserFilterCondition
+{
+ const CURRENT = 1;
+ const ORIGIN = 2;
+
+ private $corps;
+ private $type;
+
+ public function __construct($corps, $type = self::CURRENT)
+ {
+ $this->corps = $corps;
+ $this->type = $type;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ /** Tables shortcuts:
+ * pc for profile_corps,
+ * pceo for profile_corps_enum - orginal
+ * pcec for profile_corps_enum - current
+ */
+ $sub = $uf->addCorpsFilter($this->type);
+ $cond = $sub . '.abbreviation = ' . $corps;
+ 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 implements UserFilterCondition
+{
+ private $rank;
+ public function __construct($rank)
+ {
+ $this->rank = $rank;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ /** Tables shortcuts:
+ * pcr for profile_corps_rank
+ */
+ $sub = $uf->addCorpsRankFilter();
+ $cond = $sub . '.abbreviation = ' . $rank;
+ return $cond;
+ }
+}
+// }}}
+
+// {{{ 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)
+ * @param $value The searched value
+ */
+class UFC_Job_Company implements UserFilterCondition
+{
+ const JOBID = 'id';
+ const JOBNAME = 'name';
+ const JOBACRONYM = 'acronym';
+
+ private $type;
+ private $value;
+
+ public function __construct($type, $value)
+ {
+ $this->assertType($type);
+ $this->type = $type;
+ $this->value = $value;
+ }
+
+ private function assertType($type)
+ {
+ if ($type != self::JOBID && $type != self::JOBNAME && $type != self::JOBACRONYM) {
+ Platal::page()->killError("Type de recherche non valide.");
+ }
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addJobCompanyFilter();
+ $cond = $sub . '.' . $this->type . ' = ' . XDB::format('{?}', $this->value);
+ return $cond;
+ }
+}
+// }}}
+
+// {{{ class UFC_Job_Sectorization
+/** Filters users based on the ((sub)sub)sector they work in
+ * @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;
+
+ public function __construct($val, $type = UserFilter::JOB_SECTOR)
+ {
+ self::assertType($type);
+ if (!is_array($val)) {
+ $val = array($val);
+ }
+ $this->val = $val;
+ $this->type = $type;
+ }
+
+ private static function assertType($type)
+ {
+ if ($type != UserFilter::JOB_SECTOR && $type != UserFilter::JOB_SUBSECTOR && $type != UserFilter::JOB_SUBSUBSECTOR) {
+ Platal::page()->killError("Type de secteur non valide.");
+ }
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addJobSectorizationFilter($this->type);
+ return $sub . '.id = ' . XDB::format('{?}', $this->val);
+ }
+}
+// }}}
+
+// {{{ class UFC_Job_Description
+/** Filters users based on their job description
+ * @param $description The text being searched for
+ * @param $fields The fields to search for (user-defined, ((sub|)sub|)sector)
+ */
+class UFC_Job_Description implements UserFilterCondition
+{
+
+ private $description;
+ private $fields;
+
+ public function __construct($description, $fields)
+ {
+ $this->fields = $fields;
+ $this->description = $description;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $conds = array();
+ if ($this->fields & UserFilter::JOB_USERDEFINED) {
+ $sub = $uf->addJobFilter();
+ $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 ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
+ }
+ if ($this->fields & UserFilter::JOB_SUBSECTOR) {
+ $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_SUBSECTOR);
+ $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 ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
+ $sub = $uf->addJobSectorizationFilter(UserFilter::JOB_ALTERNATES);
+ $conds[] = $sub . '.name ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->description);
+ }
+ return implode(' OR ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_Networking
+/** Filters users based on network identity (IRC, ...)
+ * @param $type Type of network (-1 for any)
+ * @param $value Value to search
+ */
+class UFC_Networking implements UserFilterCondition
+{
+ private $type;
+ private $value;
+
+ public function __construct($type, $value)
+ {
+ $this->type = $type;
+ $this->value = $value;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addNetworkingFilter();
+ $conds = array();
+ $conds[] = $sub . '.address ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->value);
+ if ($this->type != -1) {
+ $conds[] = $sub . '.network_type = ' . XDB::format('{?}', $this->type);
+ }
+ return implode(' AND ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_Phone
+/** Filters users based on their phone number
+ * @param $num_type Type of number (pro/user/home)
+ * @param $phone_type Type of phone (fixed/mobile/fax)
+ * @param $number Phone number
+ */
+class UFC_Phone implements UserFilterCondition
+{
+ const NUM_PRO = 'pro';
+ const NUM_USER = 'user';
+ const NUM_HOME = 'address';
+ const NUM_ANY = 'any';
+
+ const PHONE_FIXED = 'fixed';
+ const PHONE_MOBILE = 'mobile';
+ const PHONE_FAX = 'fax';
+ const PHONE_ANY = 'any';
+
+ private $num_type;
+ private $phone_type;
+ private $number;
+
+ public function __construct($number, $num_type = self::NUM_ANY, $phone_type = self::PHONE_ANY)
+ {
+ 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(PlFilter &$uf)
+ {
+ $sub = $uf->addPhoneFilter();
+ $conds = array();
+ $conds[] = $sub . '.search_tel = ' . XDB::format('{?}', $this->number);
+ if ($this->num_type != self::NUM_ANY) {
+ $conds[] = $sub . '.link_type = ' . XDB::format('{?}', $this->num_type);
+ }
+ if ($this->phone_type != self::PHONE_ANY) {
+ $conds[] = $sub . '.tel_type = ' . XDB::format('{?}', $this->phone_type);
+ }
+ return implode(' AND ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_Medal
+/** Filters users based on their medals
+ * @param $medal ID of the medal
+ * @param $grade Grade of the medal (null for 'any')
+ */
+class UFC_Medal implements UserFilterCondition
+{
+ private $medal;
+ private $grade;
+
+ public function __construct($medal, $grade = null)
+ {
+ $this->medal = $medal;
+ $this->grade = $grade;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $conds = array();
+ $sub = $uf->addMedalFilter();
+ $conds[] = $sub . '.mid = ' . XDB::format('{?}', $this->medal);
+ if ($this->grade != null) {
+ $conds[] = $sub . '.gid = ' . XDB::format('{?}', $this->grade);
+ }
+ return implode(' AND ', $conds);
+ }
+}
+// }}}
+
+// {{{ class UFC_Mentor_Expertise
+/** Filters users by mentoring expertise
+ * @param $expertise Domain of expertise
+ */
+class UFC_Mentor_Expertise implements UserFilterCondition
+{
+ private $expertise;
+
+ public function __construct($expertise)
+ {
+ $this->expertise = $expertise;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addMentorFilter(UserFilter::MENTOR_EXPERTISE);
+ return $sub . '.expertise ' . XDB::formatWildcards(XDB::WILDCARD_CONTAINS, $this->expertise);
+ }
+}
+// }}}
+
+// {{{ class UFC_Mentor_Country
+/** Filters users by mentoring country
+ * @param $country Two-letters code of country being searched
+ */
+class UFC_Mentor_Country implements UserFilterCondition
+{
+ private $country;
+
+ public function __construct($country)
+ {
+ $this->country = $country;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addMentorFilter(UserFilter::MENTOR_COUNTRY);
+ return $sub . '.country = ' . XDB::format('{?}', $this->country);
+ }
+}
+// }}}
+
+// {{{ class UFC_Mentor_Sectorization
+/** Filters users based on mentoring (sub|)sector
+ * @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 $type;
+
+ public function __construct($sector, $type = self::SECTOR)
+ {
+ $this->sector = $sector;
+ $this->type = $type;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addMentorFilter(UserFilter::MENTOR_SECTOR);
+ if ($this->type == self::SECTOR) {
+ $field = 'sectorid';
+ } else {
+ $field = 'subsectorid';
+ }
+ return $sub . '.' . $field . ' = ' . XDB::format('{?}', $this->sector);
+ }
+}
+// }}}
+
+// {{{ 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 implements UserFilterCondition
+{
+ protected $user;
+ public function __construct(PlUser &$user)
+ {
+ $this->user =& $user;
+ }
+}
+// }}}
+
+// {{{ class UFC_Contact
+/** Filters users who belong to selected user's contacts
+ */
+class UFC_Contact extends UFC_UserRelated
+{
+ public function buildCondition(PlFilter &$uf)
+ {
+ $sub = $uf->addContactFilter($this->user->id());
+ return 'c' . $sub . '.contact IS NOT NULL';
+ }
+}
+// }}}
+
+// {{{ class UFC_WatchRegistration
+/** Filters users being watched by selected user
+ */
+class UFC_WatchRegistration extends UFC_UserRelated
+{
+ public function buildCondition(PlFilter &$uf)
+ {
+ if (!$this->user->watch('registration')) {
+ return PlFilterCondition::COND_FALSE;
+ }
+ $uids = $this->user->watchUsers();
+ if (count($uids) == 0) {
+ return PlFilterCondition::COND_FALSE;
+ } else {
+ return '$UID IN ' . XDB::formatArray($uids);
+ }
+ }
+}
+// }}}
+
+// {{{ class UFC_WatchPromo
+/** Filters users belonging to a promo watched by selected user
+ * @param $user Selected user (the one watching promo)
+ * @param $grade Formation the user is watching
+ */
+class UFC_WatchPromo extends UFC_UserRelated
+{
+ private $grade;
+ public function __construct(PlUser &$user, $grade = UserFilter::GRADE_ING)
+ {
+ parent::__construct($user);
+ $this->grade = $grade;
+ }
+
+ public function buildCondition(PlFilter &$uf)
+ {
+ $promos = $this->user->watchPromos();
+ if (count($promos) == 0) {
+ return PlFilterCondition::COND_FALSE;
+ } else {
+ $sube = $uf->addEducationFilter(true, $this->grade);
+ $field = 'pe' . $sube . '.' . UserFilter::promoYear($this->grade);
+ return $field . ' IN ' . XDB::formatArray($promos);
+ }
+ }
+}
+// }}}
+
+// {{{ class UFC_WatchContact
+/** Filters users watched by selected user
+ */
+class UFC_WatchContact extends UFC_Contact
+{
+ public function buildCondition(PlFilter &$uf)
+ {
+ if (!$this->user->watchContacts()) {
+ return PlFilterCondition::COND_FALSE;
+ }
+ return parent::buildCondition($uf);
+ }
+}
+// }}}
+
+
+/******************
+ * ORDERS
+ ******************/
+
+// {{{ class UserFilterOrder
+/** Base class for ordering results of a query.
+ * Parameters for the ordering must be given to the constructor ($desc for a
+ * descending order).
+ * The getSortTokens function is used to get actual ordering part of the query.
+ */
+abstract class UserFilterOrder extends PlFilterOrder
+{
+ /** This function must return the tokens to use for ordering
+ * @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);
+}
+// }}}
+
+// {{{ class UFO_Promo
+/** Orders users by promotion
+ * @param $grade Formation whose promotion users should be sorted by (restricts results to users of that formation)
+ * @param $desc Whether sort is descending
+ */
+class UFO_Promo extends UserFilterOrder
+{
+ private $grade;
+
+ public function __construct($grade = null, $desc = false)
+ {
+ parent::__construct($desc);
+ $this->grade = $grade;
+ }
+
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ if (UserFilter::isGrade($this->grade)) {
+ $sub = $uf->addEducationFilter($this->grade);
+ return 'pe' . $sub . '.' . UserFilter::promoYear($this->grade);
+ } else {
+ $sub = $uf->addDisplayFilter();
+ return 'pd' . $sub . '.promo';
+ }
+ }
+}
+// }}}
+
+// {{{ class UFO_Name
+/** Sorts users by name
+ * @param $type Type of name on which to sort (firstname...)
+ * @param $variant Variant of that name to use (marital, ordinary...)
+ * @param $particle Set to true if particles should be included in the sorting order
+ * @param $desc If sort order should be descending
+ */
+class UFO_Name extends UserFilterOrder
+{
+ private $type;
+ private $variant;
+ private $particle;
+
+ public function __construct($type, $variant = null, $particle = false, $desc = false)
+ {
+ parent::__construct($desc);
+ $this->type = $type;
+ $this->variant = $variant;
+ $this->particle = $particle;
+ }
+
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ if (Profile::isDisplayName($this->type)) {
+ $sub = $uf->addDisplayFilter();
+ return 'pd' . $sub . '.' . $this->type;
+ } else {
+ $sub = $uf->addNameFilter($this->type, $this->variant);
+ if ($this->particle) {
+ return 'CONCAT(pn' . $sub . '.particle, \' \', pn' . $sub . '.name)';
+ } else {
+ return 'pn' . $sub . '.name';
+ }
+ }
+ }
+}
+// }}}
+
+// {{{ class UFO_Score
+class UFO_Score extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ $sub = $uf->addNameTokensFilter();
+ return 'SUM(' . $sub . '.score)';
+ }
+}
+// }}}
+
+// {{{ class UFO_Registration
+/** Sorts users based on registration date
+ */
+class UFO_Registration extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ return 'a.registration_date';
+ }
+}
+// }}}
+
+// {{{ class UFO_Birthday
+/** Sorts users based on next birthday date
+ */
+class UFO_Birthday extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ return 'p.next_birthday';
+ }
+}
+// }}}
+
+// {{{ class UFO_ProfileUpdate
+/** Sorts users based on last profile update
+ */
+class UFO_ProfileUpdate extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ return 'p.last_change';
+ }
+}
+// }}}
+
+// {{{ class UFO_Death
+/** Sorts users based on death date
+ */
+class UFO_Death extends UserFilterOrder
+{
+ protected function getSortTokens(PlFilter &$uf)
+ {
+ return 'p.deathdate';
+ }
+}
+// }}}
+
+
+/***********************************
+ *********************************
+ USER FILTER CLASS
+ *********************************
+ ***********************************/
+
+// {{{ class UserFilter
+/** This class provides a convenient and centralized way of filtering users.
+ *
+ * Usage:
+ * $uf = new UserFilter(new UFC_Blah($x, $y), new UFO_Coin($z, $t));
+ *
+ * Resulting UserFilter can be used to:
+ * - get a list of User objects matching the filter
+ * - get a list of UIDs matching the filter
+ * - get the number of users matching the filter
+ * - check whether a given User matches the filter
+ * - filter a list of User objects depending on whether they match the filter
+ *
+ * Usage for UFC and UFO objects:
+ * A UserFilter will call all private functions named XXXJoins.
+ * These functions must return an array containing the list of join
+ * required by the various UFC and UFO associated to the UserFilter.
+ * Entries in those returned array are of the following form:
+ * 'join_tablealias' => array('join_type', 'joined_table', 'join_criter')
+ * which will be translated into :
+ * join_type JOIN joined_table AS join_tablealias ON (join_criter)
+ * in the final query.
+ *
+ * In the join_criter text, $ME is replaced with 'join_tablealias', $PID with
+ * 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 required joins ; such a function shall return the "join_tablealias" to use
+ * when referring to the joined table.
+ *
+ * For example, if data from profile_job must be available to filter results,
+ * the UFC object will call $uf-addJobFilter(), which will set the 'with_pj' var and
+ * return 'pj', the short name to use when referring to profile_job; when building
+ * the query, calling the jobJoins function will return an array containing a single
+ * row:
+ * 'pj' => array('left', 'profile_job', '$ME.pid = $UID');
+ *
+ * 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 extends PlFilter
+{
+ protected $joinMethods = array();
+
+ protected $joinMetas = array(
+ '$PID' => 'p.pid',
+ '$UID' => 'a.uid',
+ );
+
+ private $root;
+ private $sort = array();
+ private $query = null;
+ private $orderby = null;
+
+ private $lastcount = null;
+
+ public function __construct($cond = null, $sort = null)
+ {
+ if (empty($this->joinMethods)) {
+ $class = new ReflectionClass('UserFilter');
+ foreach ($class->getMethods() as $method) {
+ $name = $method->getName();
+ if (substr($name, -5) == 'Joins' && $name != 'buildJoins') {
+ $this->joinMethods[] = $name;
+ }
+ }
+ }
+ if (!is_null($cond)) {
+ if ($cond instanceof PlFilterCondition) {
+ $this->setCondition($cond);
+ }
+ }
+ if (!is_null($sort)) {
+ if ($sort instanceof UserFilterOrder) {
+ $this->addSort($sort);
+ } else if (is_array($sort)) {
+ foreach ($sort as $s) {
+ $this->addSort($s);
+ }
+ }
+ }
+ }
+
+ private function buildQuery()
+ {
+ if (is_null($this->orderby)) {
+ $orders = array();
+ foreach ($this->sort as $sort) {
+ $orders = array_merge($orders, $sort->buildSort($this));
+ }
+ if (count($orders) == 0) {
+ $this->orderby = '';
+ } else {
+ $this->orderby = 'ORDER BY ' . implode(', ', $orders);
+ }
+ }
+ if (is_null($this->query)) {
+ $where = $this->root->buildCondition($this);
+ if ($this->with_forced_sn) {
+ $this->requireProfiles();
+ $from = 'search_name AS sn';
+ } else if ($this->with_accounts) {
+ $from = 'accounts AS a';
+ } else {
+ $this->requireProfiles();
+ $from = 'profiles AS p';
+ }
+ $joins = $this->buildJoins();
+ $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);
+ }
+ $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()');
+ return $fetched;
+ }
+
+ private function getPIDList($pids = null, PlLimit &$limit)
+ {
+ $this->requireProfiles();
+ $this->buildQuery();
+ $lim = $limit->getSql();
+ $cond = '';
+ if (!is_null($pids)) {
+ $cond = ' AND p.pid IN ' . XDB::formatArray($pids);
+ }
+ $fetched = XDB::fetchColumn('SELECT SQL_CALC_FOUND_ROWS p.pid
+ ' . $this->query . $cond . '
+ GROUP BY p.pid
+ ' . $this->orderby . '
+ ' . $lim);
+ $this->lastcount = (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;
+ }
+
+ /** 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, $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();
+ foreach ($users as $user) {
+ if ($user instanceof PlUser) {
+ $uid = $user->id();
+ } else {
+ $uid = $user;
+ }
+ $uids[] = $uid;
+ $table[$uid] = $user;
+ }
+ $fetched = $this->getUIDList($uids, $limit);
+ $output = array();
+ foreach ($fetched as $uid) {
+ $output[] = $table[$uid];
+ }
+ return $output;
+ }
+
+ /** 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 getPIDs($limit = null)
+ {
+ $limit = self::defaultLimit($limit);
+ return $this->getPIDList(null, $limit);
+ }
+
+ public function getUsers($limit = null)
+ {
+ return User::getBulkUsersWithUIDs($this->getUIDs($limit));
+ }
+
+ public function iterUsers($limit = null)
+ {
+ return User::iterOverUIDs($this->getUIDs($limit));
+ }
+
+ public function getProfiles($limit = null)
+ {
+ return Profile::getBulkProfilesWithPIDs($this->getPIDs($limit));
+ }
+
+ public function iterProfiles($limit = null)
+ {
+ return Profile::iterOverPIDs($this->getPIDs($limit));
+ }
+
+ public function get($limit = null)
+ {
+ return $this->getUsers($limit);
+ }
+
+ public function getTotalCount()
+ {
+ if (is_null($this->lastcount)) {
+ $this->buildQuery();
+ if ($this->with_accounts) {
+ $field = 'a.uid';
+ } else {
+ $field = 'p.pid';
+ }
+ return (int)XDB::fetchOneCell('SELECT COUNT(DISTINCT ' . $field . ')
+ ' . $this->query);
+ } else {
+ return $this->lastcount;
+ }
+ }
+
+ public function setCondition(PlFilterCondition &$cond)
+ {
+ $this->root =& $cond;
+ $this->query = null;
+ }
+
+ public function addSort(PlFilterOrder &$sort)
+ {
+ $this->sort[] = $sort;
+ $this->orderby = null;
+ }
+
+ static public function getLegacy($promo_min, $promo_max)
+ {
+ if ($promo_min != 0) {
+ $min = new UFC_Promo('>=', self::GRADE_ING, intval($promo_min));
+ } else {
+ $min = new PFC_True();
+ }
+ if ($promo_max != 0) {
+ $max = new UFC_Promo('<=', self::GRADE_ING, intval($promo_max));
+ } else {
+ $max = new PFC_True();
+ }
+ return new UserFilter(new PFC_And($min, $max));
+ }
+
+ static public function sortByName()
+ {
+ return array(new UFO_Name(Profile::LASTNAME), new UFO_Name(Profile::FIRSTNAME));
+ }
+
+ static public function sortByPromo()
+ {
+ 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);
+ }
+
+
+ /** Stores a new (and unique) table alias in the &$table table
+ * @param &$table Array in which the table alias must be stored
+ * @param $val Value which will then be used to build the join
+ * @return Name of the newly created alias
+ */
+ private $option = 0;
+ private function register_optional(array &$table, $val)
+ {
+ if (is_null($val)) {
+ $sub = $this->option++;
+ $index = null;
+ } else {
+ $sub = self::getDBSuffix($val);
+ $index = $val;
+ }
+ $sub = '_' . $sub;
+ $table[$sub] = $index;
+ return $sub;
+ }
+
+ /** PROFILE VS ACCOUNT
+ */
+ private $with_profiles = false;
+ private $with_accounts = false;
+ private $with_forced_sn = false;
+ public function requireAccounts()
+ {
+ $this->with_accounts = true;
+ }
+
+ public function requireProfiles()
+ {
+ $this->with_profiles = true;
+ }
+
+ /** Forces the "FROM" to use search_name instead of accounts or profiles */
+ public function forceSearchName()
+ {
+ $this->with_forced_sn = true;
+ }
+
+ protected function accountJoins()
+ {
+ $joins = array();
+ /** Quick search is much more efficient with sn first and PID second */
+ if ($this->with_forced_sn) {
+ $joins['p'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profiles', '$PID = sn.uid');
+ if ($this->with_accounts) {
+ $joins['ap'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'account_profiles', '$ME.pid = $PID');
+ $joins['a'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'accounts', '$UID = ap.uid');
+ }
+ } else if ($this->with_profiles && $this->with_accounts) {
+ $joins['ap'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'account_profiles', '$ME.uid = $UID AND FIND_IN_SET(\'owner\', ap.perms)');
+ $joins['p'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profiles', '$PID = ap.pid');
+ }
+ return $joins;
+ }
+
+ /** DISPLAY
+ */
+ const DISPLAY = 'display';
+ private $pd = false;
+ public function addDisplayFilter()
+ {
+ $this->requireProfiles();
+ $this->pd = true;
+ return '';
+ }
+
+ protected function displayJoins()
+ {
+ if ($this->pd) {
+ return array('pd' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_display', '$ME.pid = $PID'));
+ } else {
+ return array();
+ }
+ }
+
+ /** LOGGER
+ */
+
+ private $with_logger = false;
+ public function addLoggerFilter()
+ {
+ $this->with_logger = true;
+ $this->requireAccounts();
+ return 'ls';
+ }
+ protected function loggerJoins()
+ {
+ $joins = array();
+ if ($this->with_logger) {
+ $joins['ls'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'log_sessions', '$ME.uid = $UID');
+ }
+ return $joins;
+ }
+
+ /** NAMES
+ */
+
+ static public function assertName($name)
+ {
+ if (!Profile::getNameTypeId($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 {
+ $ft = $type;
+ }
+ $sub = '_' . $ft;
+ self::assertName($ft);
+
+ if (!is_null($variant) && $variant == 'other') {
+ $sub .= $this->option++;
+ }
+ $this->pn[$sub] = Profile::getNameTypeId($ft);
+ return $sub;
+ }
+
+ 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);
+ }
+ return $joins;
+ }
+
+ /** NAMETOKENS
+ */
+ private $with_sn = false;
+ // Set $doingQuickSearch to true if you wish to optimize the query
+ public function addNameTokensFilter($doingQuickSearch = false)
+ {
+ $this->requireProfiles();
+ $this->with_forced_sn = ($this->with_forced_sn || $doingQuickSearch);
+ $this->with_sn = true;
+ return 'sn';
+ }
+
+ protected function nameTokensJoins()
+ {
+ /* We don't return joins, since with_sn forces the SELECT to run on search_name first */
+ if ($this->with_sn && !$this->with_forced_sn) {
+ return array(
+ 'sn' => new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'search_name', '$ME.uid = $PID')
+ );
+ } else {
+ return array();
+ }
+ }
+
+ /** 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'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'geoloc_countries', '$ME.iso_3166_1_a2 = p.nationality1 OR $ME.iso_3166_1_a2 = p.nationality2 OR $ME.iso_3166_1_a2 = p.nationality3');
+ }
+ return $joins;
+ }
+
+ /** EDUCATION
+ */
+ const GRADE_ING = 'Ing.';
+ const GRADE_PHD = 'PhD';
+ const GRADE_MST = 'M%';
+ static public function isGrade($grade)
+ {
+ return $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");
+ }
+ }
+
+ static public function promoYear($grade)
+ {
+ // XXX: Definition of promotion for phds and masters might change in near future.
+ return ($grade == UserFilter::GRADE_ING) ? 'entry_year' : 'grad_year';
+ }
+
+ private $pepe = array();
+ private $with_pee = false;
+ public function addEducationFilter($x = false, $grade = null)
+ {
+ $this->requireProfiles();
+ if (!$x) {
+ $index = $this->option;
+ $sub = $this->option++;
+ } else {
+ self::assertGrade($grade);
+ $index = $grade;
+ $sub = $grade[0];
+ $this->with_pee = true;
+ }
+ $sub = '_' . $sub;
+ $this->pepe[$index] = $sub;
+ return $sub;
+ }
+
+ protected function educationJoins()
+ {
+ $joins = array();
+ if ($this->with_pee) {
+ $joins['pee'] = new PlSqlJoin(PlSqlJoin::MODE_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.pid = $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));
+ } else {
+ $joins['pe' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_education', '$ME.pid = $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');
+ }
+ }
+ return $joins;
+ }
+
+
+ /** GROUPS
+ */
+ private $gpm = array();
+ public function addGroupFilter($group = null)
+ {
+ $this->requireAccounts();
+ if (!is_null($group)) {
+ if (ctype_digit($group)) {
+ $index = $sub = $group;
+ } else {
+ $index = $group;
+ $sub = self::getDBSuffix($group);
+ }
+ } else {
+ $sub = 'group_' . $this->option++;
+ $index = null;
+ }
+ $sub = '_' . $sub;
+ $this->gpm[$sub] = $index;
+ return $sub;
+ }
+
+ protected function groupJoins()
+ {
+ $joins = array();
+ foreach ($this->gpm as $sub => $key) {
+ if (is_null($key)) {
+ $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groups');
+ $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'group_members', '$ME.uid = $UID AND $ME.asso_id = gpa' . $sub . '.id');
+ } else if (ctype_digit($key)) {
+ $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'group_members', '$ME.uid = $UID AND $ME.asso_id = ' . $key);
+ } else {
+ $joins['gpa' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_INNER, 'groups', XDB::format('$ME.diminutif = {?}', $key));
+ $joins['gpm' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_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'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_binets', '$ME.pid = $PID');
+ }
+ if ($this->with_bd) {
+ $joins['bd'] = new PlSqlJoin(PlSqlJoin::MODE_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 $ve = array();
+ public function addVirtualEmailFilter($email = null)
+ {
+ $this->addAliasFilter(self::ALIAS_FORLIFE);
+ return $this->register_optional($this->ve, $email);
+ }
+
+ const ALIAS_BEST = 'bestalias';
+ const ALIAS_FORLIFE = 'forlife';
+ private $al = array();
+ public function addAliasFilter($alias = null)
+ {
+ $this->requireAccounts();
+ return $this->register_optional($this->al, $alias);
+ }
+
+ 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\'');
+ } else {
+ $joins['e' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'emails', XDB::format('$ME.uid = $UID AND $ME.flags != \'filter\' AND $ME.email = {?}', $key));
+ }
+ }
+ foreach ($this->al as $sub=>$key) {
+ if (is_null($key)) {
+ $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_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.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.uid = $UID AND $ME.type = \'a_vie\'');
+ } else {
+ $joins['al' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'aliases', XDB::format('$ME.uid = $UID AND $ME.type IN (\'alias\', \'a_vie\') AND $ME.alias = {?}', $key));
+ }
+ }
+ foreach ($this->ve as $sub=>$key) {
+ if (is_null($key)) {
+ $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', '$ME.type = \'user\'');
+ } else {
+ $joins['v' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'virtual', XDB::format('$ME.type = \'user\' AND $ME.alias = {?}', $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));
+ }
+ return $joins;
+ }
+
+
+ /** ADDRESSES
+ */
+ private $with_pa = false;
+ public function addAddressFilter()
+ {
+ $this->requireProfiles();
+ $this->with_pa = true;
+ return 'pa';
+ }
+
+ 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_addresses', '$ME.pid = $PID');
+ }
+ if ($this->with_pac) {
+ $joins['gc'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'geoloc_countries', '$ME.iso_3166_1_a2 = pa.countryID');
+ }
+ if ($this->with_pal) {
+ $joins['gl'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'geoloc_localities', '$ME.id = pa.localityID');
+ }
+ return $joins;
+ }
+
+
+ /** CORPS
+ */
+
+ private $pc = false;
+ private $pce = array();
+ private $pcr = false;
+ public function addCorpsFilter($type)
+ {
+ $this->requireProfiles();
+ $this->pc = true;
+ if ($type == UFC_Corps::CURRENT) {
+ $pce['pcec'] = 'current_corpsid';
+ return 'pcec';
+ } else if ($type == UFC_Corps::ORIGIN) {
+ $pce['pceo'] = 'original_corpsid';
+ return 'pceo';
+ }
+ }
+
+ public function addCorpsRankFilter()
+ {
+ $this->requireProfiles();
+ $this->pc = true;
+ $this->pcr = true;
+ return 'pcr';
+ }
+
+ protected function corpsJoins()
+ {
+ $joins = array();
+ if ($this->pc) {
+ $joins['pc'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_corps', '$ME.pid = $PID');
+ }
+ if ($this->pcr) {
+ $joins['pcr'] = new PlSqlJoin(PlSqlJoin::MODE_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);
+ }
+ return $joins;
+ }
+
+ /** JOBS
+ */
+
+ 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
+ * pje => profile_job_enum
+ * pjse => profile_job_sector_enum
+ * pjsse => profile_job_subsector_enum
+ * pjssse => profile_job_subsubsector_enum
+ * pja => profile_job_alternates
+ */
+ private $with_pj = false;
+ private $with_pje = false;
+ private $with_pjse = false;
+ private $with_pjsse = false;
+ private $with_pjssse = false;
+ private $with_pja = false;
+
+ public function addJobFilter()
+ {
+ $this->requireProfiles();
+ $this->with_pj = true;
+ return 'pj';
+ }
+
+ public function addJobCompanyFilter()
+ {
+ $this->addJobFilter();
+ $this->with_pje = true;
+ return 'pje';
+ }
+
+ public function addJobSectorizationFilter($type)
+ {
+ $this->addJobFilter();
+ if ($type == self::JOB_SECTOR) {
+ $this->with_pjse = true;
+ return 'pjse';
+ } else if ($type == self::JOB_SUBSECTOR) {
+ $this->with_pjsse = true;
+ return 'pjsse';
+ } else if ($type == self::JOB_SUBSUBSECTOR) {
+ $this->with_pjssse = true;
+ return 'pjssse';
+ } else if ($type == self::JOB_ALTERNATES) {
+ $this->with_pja = true;
+ return 'pja';
+ }
+ }
+
+ protected function jobJoins()
+ {
+ $joins = array();
+ if ($this->with_pj) {
+ $joins['pj'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job', '$ME.pid = $PID');
+ }
+ if ($this->with_pje) {
+ $joins['pje'] = new PlSqlJoin(PlSqlJoin::MODE_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');
+ }
+ if ($this->with_pjsse) {
+ $joins['pjsse'] = new PlSqlJoin(PlSqlJoin::MODE_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');
+ }
+ if ($this->with_pja) {
+ $joins['pja'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_job_alternates', '$ME.subsubsectorid = pj.subsubsectorid');
+ }
+ return $joins;
+ }
+
+ /** NETWORKING
+ */
+
+ private $with_pnw = false;
+ public function addNetworkingFilter()
+ {
+ $this->requireAccounts();
+ $this->with_pnw = true;
+ return 'pnw';
+ }
+
+ protected function networkingJoins()
+ {
+ $joins = array();
+ if ($this->with_pnw) {
+ $joins['pnw'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_networking', '$ME.pid = $PID');
+ }
+ return $joins;
+ }
+
+ /** PHONE
+ */
+
+ private $with_ptel = false;
+
+ public function addPhoneFilter()
+ {
+ $this->requireAccounts();
+ $this->with_ptel = true;
+ return 'ptel';
+ }
+
+ protected function phoneJoins()
+ {
+ $joins = array();
+ if ($this->with_ptel) {
+ $joins['ptel'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_phones', '$ME.pid = $PID');
+ }
+ return $joins;
+ }
+
+ /** MEDALS
+ */
+
+ private $with_pmed = false;
+ public function addMedalFilter()
+ {
+ $this->requireProfiles();
+ $this->with_pmed = true;
+ return 'pmed';
+ }
+
+ protected function medalJoins()
+ {
+ $joins = array();
+ if ($this->with_pmed) {
+ $joins['pmed'] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'profile_medals', '$ME.pid = $PID');
+ }
+ return $joins;
+ }
+
+ /** MENTORING
+ */
+
+ private $pms = array();
+ const MENTOR_EXPERTISE = 1;
+ const MENTOR_COUNTRY = 2;
+ const MENTOR_SECTOR = 3;
+
+ public function addMentorFilter($type)
+ {
+ $this->requireAccounts();
+ switch($type) {
+ case self::MENTOR_EXPERTISE:
+ $this->pms['pme'] = 'profile_mentor';
+ return 'pme';
+ case self::MENTOR_COUNTRY:
+ $this->pms['pmc'] = 'profile_mentor_country';
+ return 'pmc';
+ case self::MENTOR_SECTOR:
+ $this->pms['pms'] = 'profile_mentor_sector';
+ return 'pms';
+ default:
+ Platal::page()->killError("Undefined mentor filter.");
+ }
+ }
+
+ protected function mentorJoins()
+ {
+ $joins = array();
+ foreach ($this->pms as $sub => $tab) {
+ $joins[$sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, $tab, '$ME.pid = $PID');
+ }
+ return $joins;
+ }
+
+ /** CONTACTS
+ */
+ private $cts = array();
+ public function addContactFilter($uid = null)
+ {
+ $this->requireAccounts();
+ return $this->register_optional($this->cts, is_null($uid) ? null : 'user_' . $uid);
+ }
+
+ 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');
+ } else {
+ $joins['c' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'contacts', XDB::format('$ME.uid = {?} AND $ME.contact = $UID', substr($key, 5)));
+ }
+ }
+ return $joins;
+ }
+
+
+ /** CARNET
+ */
+ 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);
+ }
+
+ protected function watchJoins()
+ {
+ $joins = array();
+ foreach ($this->w as $sub=>$key) {
+ if (is_null($key)) {
+ $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch');
+ } else {
+ $joins['w' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch', XDB::format('$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');
+ } else {
+ $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$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');
+ } else {
+ $joins['wn' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_nonins', XDB::format('$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');
+ } else {
+ $joins['wp' . $sub] = new PlSqlJoin(PlSqlJoin::MODE_LEFT, 'watch_promo', XDB::format('$ME.uid = {?}', substr($key, 5)));
+ }
+ }
+ return $joins;
+ }
+}
+// }}}
+
+// {{{ class ProfileFilter
+class ProfileFilter extends UserFilter
+{
+ public function get($limit = null)
+ {
+ return $this->getProfiles($limit);