mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-08 10:34:34 +00:00
1052 lines
25 KiB
PHP
1052 lines
25 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2013 Alchemy
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
use Alchemy\Phrasea\Application;
|
|
use Doctrine\Common\Collections\ArrayCollection;
|
|
|
|
/**
|
|
*
|
|
* @package User
|
|
* @license http://opensource.org/licenses/gpl-3.0 GPLv3
|
|
* @link www.phraseanet.com
|
|
*/
|
|
class User_Query implements User_QueryInterface
|
|
{
|
|
/**
|
|
*
|
|
* @var Application
|
|
*/
|
|
protected $app;
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $results = [];
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $sort = [];
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $like_field = [];
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $have_rights;
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $have_not_rights;
|
|
|
|
/**
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $like_match = 'OR';
|
|
|
|
/**
|
|
*
|
|
* @var string
|
|
*/
|
|
protected $get_inactives = '';
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $total = 0;
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $active_bases = [];
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $active_sbas = [];
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $bases_restrictions = false;
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $sbas_restrictions = false;
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $include_templates = false;
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $only_templates = false;
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $email_not_null = false;
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $base_ids = [];
|
|
|
|
/**
|
|
*
|
|
* @var Array
|
|
*/
|
|
protected $sbas_ids = [];
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $page;
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $offset_start;
|
|
protected $last_model;
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $results_quantity;
|
|
protected $include_phantoms = true;
|
|
protected $include_special_users = false;
|
|
protected $include_invite = false;
|
|
protected $activities;
|
|
protected $templates;
|
|
protected $companies;
|
|
protected $countries;
|
|
protected $positions;
|
|
protected $in_ids;
|
|
|
|
const ORD_ASC = 'asc';
|
|
const ORD_DESC = 'desc';
|
|
const SORT_FIRSTNAME = 'usr_prenom';
|
|
const SORT_LASTNAME = 'usr_nom';
|
|
const SORT_COMPANY = 'societe';
|
|
const SORT_LOGIN = 'usr_login';
|
|
const SORT_EMAIL = 'usr_mail';
|
|
const SORT_ID = 'usr_id';
|
|
const SORT_CREATIONDATE = 'usr_creationdate';
|
|
const SORT_COUNTRY = 'pays';
|
|
const SORT_LASTMODEL = 'lastModel';
|
|
const LIKE_FIRSTNAME = 'usr_prenom';
|
|
const LIKE_LASTNAME = 'usr_nom';
|
|
const LIKE_NAME = 'name';
|
|
const LIKE_COMPANY = 'societe';
|
|
const LIKE_LOGIN = 'usr_login';
|
|
const LIKE_EMAIL = 'usr_mail';
|
|
const LIKE_COUNTRY = 'pays';
|
|
const LIKE_MATCH_AND = 'AND';
|
|
const LIKE_MATCH_OR = 'OR';
|
|
|
|
/**
|
|
*
|
|
* @return User_Query
|
|
*/
|
|
public function __construct(Application $app)
|
|
{
|
|
$this->app = $app;
|
|
|
|
foreach ($app['phraseanet.appbox']->get_databoxes() as $databox) {
|
|
$this->active_sbas[] = $databox->get_sbas_id();
|
|
foreach ($databox->get_collections() as $collection) {
|
|
$this->active_bases[] = $collection->get_base_id();
|
|
}
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
protected $sql_params;
|
|
|
|
/**
|
|
*
|
|
* @return \Doctrine\Common\Collections\ArrayCollection
|
|
*/
|
|
public function get_results()
|
|
{
|
|
return $this->results;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function generate_sql_constraints()
|
|
{
|
|
$this->sql_params = [];
|
|
|
|
$sql = '
|
|
FROM usr LEFT JOIN basusr ON (usr.usr_id = basusr.usr_id)
|
|
LEFT JOIN sbasusr ON (usr.usr_id = sbasusr.usr_id)
|
|
WHERE 1 ';
|
|
|
|
if (! $this->include_special_users) {
|
|
$sql .= ' AND usr_login != "autoregister"
|
|
AND usr_login != "invite" ';
|
|
}
|
|
|
|
$sql .= ' AND usr_login NOT LIKE "(#deleted_%" ';
|
|
|
|
if (! $this->include_invite) {
|
|
$sql .= ' AND usr.invite=0 ';
|
|
}
|
|
|
|
if ($this->email_not_null) {
|
|
$sql .= ' AND usr.usr_mail IS NOT NULL ';
|
|
}
|
|
|
|
if ($this->only_templates === true) {
|
|
if (!$this->app['authentication']->getUser()) {
|
|
throw new InvalidArgumentException('Unable to load templates while disconnected');
|
|
}
|
|
$sql .= ' AND model_of = ' . $this->app['authentication']->getUser()->get_id();
|
|
} elseif ($this->include_templates === false) {
|
|
$sql .= ' AND model_of=0';
|
|
} elseif ($this->app['authentication']->getUser()) {
|
|
$sql .= ' AND (model_of=0 OR model_of = ' . $this->app['authentication']->getUser()->get_id() . ' ) ';
|
|
} else {
|
|
$sql .= ' AND model_of=0';
|
|
}
|
|
|
|
if ($this->activities) {
|
|
$sql .= $this->generate_field_constraints('activite', $this->activities);
|
|
}
|
|
|
|
if ($this->positions) {
|
|
$sql .= $this->generate_field_constraints('fonction', $this->positions);
|
|
}
|
|
|
|
if ($this->countries) {
|
|
$sql .= $this->generate_field_constraints('pays', $this->countries);
|
|
}
|
|
|
|
if ($this->companies) {
|
|
$sql .= $this->generate_field_constraints('societe', $this->companies);
|
|
}
|
|
|
|
if ($this->templates) {
|
|
$sql .= $this->generate_field_constraints('lastModel', $this->templates);
|
|
}
|
|
|
|
if (count($this->base_ids) == 0) {
|
|
if ($this->bases_restrictions)
|
|
throw new Exception('No base available for you, not enough rights');
|
|
} else {
|
|
$extra = $this->include_phantoms ? ' OR base_id IS NULL ' : '';
|
|
|
|
$not_base_id = array_diff($this->active_bases, $this->base_ids);
|
|
|
|
if (count($not_base_id) > 0 && count($not_base_id) < count($this->base_ids)) {
|
|
$sql .= sprintf(' AND ((base_id != %s ) ' . $extra . ')'
|
|
, implode(' AND base_id != ', $not_base_id)
|
|
);
|
|
} else {
|
|
$sql .= sprintf(' AND (base_id = %s ' . $extra . ') '
|
|
, implode(' OR base_id = ', $this->base_ids)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (count($this->sbas_ids) == 0) {
|
|
if ($this->sbas_restrictions)
|
|
throw new Exception('No base available for you, not enough rights');
|
|
} else {
|
|
$extra = $this->include_phantoms ? ' OR sbas_id IS NULL ' : '';
|
|
|
|
$not_sbas_id = array_diff($this->active_sbas, $this->sbas_ids);
|
|
|
|
if (count($not_sbas_id) > 0 && count($not_sbas_id) < count($this->sbas_ids)) {
|
|
$sql .= sprintf(' AND ((sbas_id != %s ) ' . $extra . ')'
|
|
, implode(' AND sbas_id != ', $not_sbas_id)
|
|
);
|
|
} else {
|
|
$sql .= sprintf(' AND (sbas_id = %s ' . $extra . ') '
|
|
, implode(' OR sbas_id = ', $this->sbas_ids)
|
|
);
|
|
}
|
|
}
|
|
|
|
if ($this->in_ids) {
|
|
$sql .= 'AND (usr.usr_id = ' . implode(' OR usr.usr_id = ', $this->in_ids) . ')';
|
|
}
|
|
|
|
if ($this->have_rights) {
|
|
foreach ($this->have_rights as $right) {
|
|
$sql .= ' AND basusr.`' . $right . '` = 1 ';
|
|
}
|
|
}
|
|
|
|
if ($this->have_not_rights) {
|
|
foreach ($this->have_not_rights as $right) {
|
|
$sql .= ' AND basusr.`' . $right . '` = 0 ';
|
|
}
|
|
}
|
|
|
|
if ($this->last_model) {
|
|
$sql .= ' AND usr.lastModel = "' . mysql_real_escape_string($this->last_model) . '" ';
|
|
}
|
|
|
|
$sql_like = [];
|
|
|
|
foreach ($this->like_field as $like_field => $like_value) {
|
|
switch ($like_field) {
|
|
case self::LIKE_NAME:
|
|
$qrys = [];
|
|
foreach (explode(' ', $like_value) as $like_val) {
|
|
if (trim($like_val) === '')
|
|
continue;
|
|
|
|
$qrys[] = sprintf(
|
|
' (usr.`%s` LIKE "%s%%" COLLATE utf8_unicode_ci
|
|
OR usr.`%s` LIKE "%s%%" COLLATE utf8_unicode_ci) '
|
|
, self::LIKE_FIRSTNAME
|
|
, str_replace(['"', '%'], ['\"', '\%'], $like_val)
|
|
, self::LIKE_LASTNAME
|
|
, str_replace(['"', '%'], ['\"', '\%'], $like_val)
|
|
);
|
|
}
|
|
|
|
if (count($qrys) > 0)
|
|
$sql_like[] = ' (' . implode(' AND ', $qrys) . ') ';
|
|
|
|
break;
|
|
case self::LIKE_FIRSTNAME:
|
|
case self::LIKE_LASTNAME:
|
|
case self::LIKE_COMPANY:
|
|
case self::LIKE_EMAIL:
|
|
case self::LIKE_LOGIN:
|
|
case self::LIKE_COUNTRY:
|
|
$sql_like[] = sprintf(
|
|
' usr.`%s` LIKE "%s%%" COLLATE utf8_unicode_ci '
|
|
, $like_field
|
|
, str_replace(['"', '%'], ['\"', '\%'], $like_value)
|
|
);
|
|
break;
|
|
default;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (count($sql_like) > 0)
|
|
$sql .= sprintf(' AND (%s) ', implode($this->like_match, $sql_like));
|
|
|
|
return $sql;
|
|
}
|
|
|
|
protected function generate_field_constraints($fieldName, ArrayCollection $fields)
|
|
{
|
|
$n = 0;
|
|
$constraints = [];
|
|
|
|
foreach ($fields as $field) {
|
|
$constraints[':' . $fieldName . $n ++] = $field;
|
|
}
|
|
$sql = ' AND (' . $fieldName . ' = '
|
|
. implode(' OR ' . $fieldName . ' = ', array_keys($constraints)) . ') ';
|
|
|
|
$this->sql_params = array_merge($this->sql_params, $constraints);
|
|
|
|
return $sql;
|
|
}
|
|
|
|
public function in(array $usr_ids)
|
|
{
|
|
$tmp_usr_ids = [];
|
|
|
|
foreach ($usr_ids as $usr_id) {
|
|
$tmp_usr_ids[] = (int) $usr_id;
|
|
}
|
|
|
|
$this->in_ids = array_unique($tmp_usr_ids);
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function last_model_is($login = null)
|
|
{
|
|
$this->last_model = $login instanceof \User_Adapter ? $login->get_login() : $login;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function include_phantoms($boolean = true)
|
|
{
|
|
$this->include_phantoms = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function include_special_users($boolean = false)
|
|
{
|
|
$this->include_special_users = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function include_invite($boolean = false)
|
|
{
|
|
$this->include_invite = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param array $rights
|
|
* @return User_Query
|
|
*/
|
|
public function who_have_right(Array $rights)
|
|
{
|
|
$this->have_rights = $rights;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $boolean
|
|
* @return User_Query
|
|
*/
|
|
public function include_templates($boolean)
|
|
{
|
|
$this->include_templates = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $boolean
|
|
* @return User_Query
|
|
*/
|
|
public function only_templates($boolean)
|
|
{
|
|
$this->only_templates = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $boolean
|
|
* @return User_Query
|
|
*/
|
|
public function email_not_null($boolean)
|
|
{
|
|
$this->email_not_null = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param array $rights
|
|
* @return User_Query
|
|
*/
|
|
public function who_have_not_right(Array $rights)
|
|
{
|
|
$this->have_not_rights = $rights;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return User_Query
|
|
*/
|
|
public function execute()
|
|
{
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
$sql = 'SELECT DISTINCT usr.usr_id ' . $this->generate_sql_constraints();
|
|
|
|
if ('' !== $sorter = $this->generate_sort_constraint()) {
|
|
$sql .= ' ORDER BY ' . $sorter;
|
|
}
|
|
|
|
if (is_int($this->offset_start) && is_int($this->results_quantity)) {
|
|
$sql .= sprintf(
|
|
' LIMIT %d, %d'
|
|
, $this->offset_start
|
|
, $this->results_quantity
|
|
);
|
|
}
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$users = new ArrayCollection();
|
|
|
|
foreach ($rs as $row) {
|
|
$users[] = User_Adapter::getInstance($row['usr_id'], $this->app);
|
|
}
|
|
|
|
$this->results = $users;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_total()
|
|
{
|
|
if ($this->total) {
|
|
return $this->total;
|
|
}
|
|
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql_count = 'SELECT COUNT(DISTINCT usr.usr_id) as total '
|
|
. $this->generate_sql_constraints();
|
|
|
|
$stmt = $conn->prepare($sql_count);
|
|
$stmt->execute($this->sql_params);
|
|
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$this->total = $row['total'];
|
|
|
|
$this->page = 1;
|
|
if ($this->total > 0 && is_int($this->offset_start) && is_int($this->results_quantity)) {
|
|
$this->page = floor($this->offset_start / $this->results_quantity) + 1;
|
|
$this->total_page = floor($this->total / $this->results_quantity) + 1;
|
|
}
|
|
|
|
return $this->total;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_page()
|
|
{
|
|
$this->get_total();
|
|
|
|
return $this->page;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_total_page()
|
|
{
|
|
$this->get_total();
|
|
|
|
return $this->total_page;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param ACL $ACL User's ACLs
|
|
* @param array $rights An array of base rights you need
|
|
* @return User_Query
|
|
*/
|
|
public function on_bases_where_i_am(ACL $ACL, Array $rights)
|
|
{
|
|
$this->bases_restrictions = true;
|
|
$baslist = array_keys($ACL->get_granted_base($rights));
|
|
|
|
if (count($this->base_ids) > 0)
|
|
$this->base_ids = array_intersect($this->base_ids, $baslist);
|
|
else
|
|
$this->base_ids = $baslist;
|
|
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param ACL $ACL
|
|
* @param array $rights An array of sbas rights you need
|
|
* @return User_Query
|
|
*/
|
|
public function on_sbas_where_i_am(ACL $ACL, Array $rights)
|
|
{
|
|
$this->sbas_restrictions = true;
|
|
$sbaslist = array_keys($ACL->get_granted_sbas($rights));
|
|
|
|
if (count($this->sbas_ids) > 0)
|
|
$this->sbas_ids = array_intersect($this->sbas_ids, $sbaslist);
|
|
else
|
|
$this->sbas_ids = $sbaslist;
|
|
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param int $offset_start
|
|
* @param int $results_quantity
|
|
* @return User_Query
|
|
*/
|
|
public function limit($offset_start, $results_quantity)
|
|
{
|
|
$this->offset_start = (int) $offset_start;
|
|
$this->results_quantity = (int) $results_quantity;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Query width a like field
|
|
* like fields are defined as constants of the object
|
|
*
|
|
* @param const $like_field
|
|
* @param string $like_value
|
|
* @return User_Query
|
|
*/
|
|
public function like($like_field, $like_value)
|
|
{
|
|
|
|
// if ($like_field == self::LIKE_NAME)
|
|
// {
|
|
// $this->like_field[self::LIKE_FIRSTNAME] = trim($like_value);
|
|
// $this->like_field[self::LIKE_LASTNAME] = trim($like_value);
|
|
// }
|
|
// else
|
|
// {
|
|
$this->like_field[trim($like_field)] = trim($like_value);
|
|
// }
|
|
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Choose whether multiple like will be treated as AND or OR
|
|
*
|
|
* @param type $like_match
|
|
* @return User_Query
|
|
*/
|
|
public function like_match($like_match)
|
|
{
|
|
switch ($like_match) {
|
|
case self::LIKE_MATCH_AND:
|
|
case self::LIKE_MATCH_OR:
|
|
$this->like_match = $like_match;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Restrict User search on base_ids
|
|
*
|
|
* @param array $base_ids
|
|
* @return User_Query
|
|
*/
|
|
public function on_base_ids(Array $base_ids = null)
|
|
{
|
|
if (! $base_ids) {
|
|
return $this;
|
|
}
|
|
|
|
$this->bases_restrictions = true;
|
|
|
|
$this->include_phantoms(false);
|
|
|
|
if (count($this->base_ids) > 0)
|
|
$this->base_ids = array_intersect($this->base_ids, $base_ids);
|
|
else
|
|
$this->base_ids = $base_ids;
|
|
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param array $sbas_ids
|
|
* @return User_Query
|
|
*/
|
|
public function on_sbas_ids(Array $sbas_ids = null)
|
|
{
|
|
if (! $sbas_ids) {
|
|
return $this;
|
|
}
|
|
|
|
$this->sbas_restrictions = true;
|
|
|
|
$this->include_phantoms(false);
|
|
|
|
if (count($this->sbas_ids) > 0)
|
|
$this->sbas_ids = array_intersect($this->sbas_ids, $sbas_ids);
|
|
else
|
|
$this->sbas_ids = $sbas_ids;
|
|
|
|
$this->total = $this->page = $this->total_page = null;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sort results. Sort field and sort order are defined as constants
|
|
* of this object
|
|
*
|
|
* @param const $sort
|
|
* @param const $ord
|
|
* @return User_Query
|
|
*/
|
|
public function sort_by($sort, $ord = 'asc')
|
|
{
|
|
$this->sort[$sort] = $ord;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function haveActivities(array $req_activities)
|
|
{
|
|
$Activities = new \Doctrine\Common\Collections\ArrayCollection();
|
|
|
|
foreach ($req_activities as $activity) {
|
|
$activity = trim($activity);
|
|
|
|
if ($activity === '')
|
|
continue;
|
|
|
|
if ($Activities->contains($activity))
|
|
continue;
|
|
|
|
$Activities->add($activity);
|
|
}
|
|
|
|
if ( ! $Activities->isEmpty()) {
|
|
$this->activities = $Activities;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function havePositions(array $req_positions)
|
|
{
|
|
$Positions = new \Doctrine\Common\Collections\ArrayCollection();
|
|
|
|
foreach ($req_positions as $Position) {
|
|
$Position = trim($Position);
|
|
|
|
if ($Position === '')
|
|
continue;
|
|
|
|
if ($Positions->contains($Position))
|
|
continue;
|
|
|
|
$Positions->add($Position);
|
|
}
|
|
|
|
if ( ! $Positions->isEmpty()) {
|
|
$this->positions = $Positions;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function inCountries(array $req_countries)
|
|
{
|
|
$Countries = new \Doctrine\Common\Collections\ArrayCollection();
|
|
|
|
foreach ($req_countries as $Country) {
|
|
$Country = trim($Country);
|
|
|
|
if ($Country === '')
|
|
continue;
|
|
|
|
if ($Countries->contains($Country))
|
|
continue;
|
|
|
|
$Countries->add($Country);
|
|
}
|
|
|
|
if ( ! $Countries->isEmpty()) {
|
|
$this->countries = $Countries;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function inCompanies(array $req_companies)
|
|
{
|
|
$Companies = new \Doctrine\Common\Collections\ArrayCollection();
|
|
|
|
foreach ($req_companies as $Company) {
|
|
$Company = trim($Company);
|
|
|
|
if ($Company === '')
|
|
continue;
|
|
|
|
if ($Companies->contains($Company))
|
|
continue;
|
|
|
|
$Companies->add($Company);
|
|
}
|
|
|
|
if ( ! $Companies->isEmpty()) {
|
|
$this->companies = $Companies;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function haveTemplate(array $req_templates)
|
|
{
|
|
$Templates = new \Doctrine\Common\Collections\ArrayCollection();
|
|
|
|
foreach ($req_templates as $Template) {
|
|
$Template = trim($Template);
|
|
|
|
if ($Template === '')
|
|
continue;
|
|
|
|
if ($Templates->contains($Template))
|
|
continue;
|
|
|
|
$Templates->add($Template);
|
|
}
|
|
|
|
if ( ! $Templates->isEmpty()) {
|
|
$this->templates = $Templates;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Wheter or not retrieve inactive users
|
|
* (inactive users do not have the "access" right)
|
|
*
|
|
* @param boolean $boolean
|
|
* @return User_Query
|
|
*/
|
|
public function get_inactives($boolean = true)
|
|
{
|
|
$this->get_inactives = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function getRelatedActivities()
|
|
{
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql = 'SELECT DISTINCT usr.activite ' . $this->generate_sql_constraints();
|
|
|
|
$sql .= ' ORDER BY usr.activite';
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$activities = [];
|
|
|
|
foreach ($rs as $row) {
|
|
if (trim($row['activite']) === '')
|
|
continue;
|
|
|
|
$activities[] = $row['activite'];
|
|
}
|
|
|
|
return $activities;
|
|
}
|
|
|
|
public function getRelatedPositions()
|
|
{
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql = 'SELECT DISTINCT usr.fonction ' . $this->generate_sql_constraints();
|
|
|
|
$sql .= ' ORDER BY usr.fonction';
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$fonction = [];
|
|
|
|
foreach ($rs as $row) {
|
|
if (trim($row['fonction']) === '')
|
|
continue;
|
|
|
|
$fonction[] = $row['fonction'];
|
|
}
|
|
|
|
return $fonction;
|
|
}
|
|
|
|
public function getRelatedCountries()
|
|
{
|
|
require_once __DIR__ . '/../../classes/deprecated/countries.php';
|
|
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql = 'SELECT DISTINCT usr.pays ' . $this->generate_sql_constraints();
|
|
|
|
$sql .= ' ORDER BY usr.pays';
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$pays = [];
|
|
|
|
$ctry = \getCountries($this->app['locale']);
|
|
|
|
foreach ($rs as $row) {
|
|
if (trim($row['pays']) === '')
|
|
continue;
|
|
|
|
if (isset($ctry[$row['pays']]))
|
|
$pays[$row['pays']] = $ctry[$row['pays']];
|
|
}
|
|
|
|
return $pays;
|
|
}
|
|
|
|
public function getRelatedCompanies()
|
|
{
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql = 'SELECT DISTINCT usr.societe ' . $this->generate_sql_constraints();
|
|
|
|
$sql .= ' ORDER BY usr.societe';
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$societe = [];
|
|
|
|
foreach ($rs as $row) {
|
|
if (trim($row['societe']) === '')
|
|
continue;
|
|
|
|
$societe[] = $row['societe'];
|
|
}
|
|
|
|
return $societe;
|
|
}
|
|
|
|
public function getRelatedTemplates()
|
|
{
|
|
$conn = $this->app['phraseanet.appbox']->get_connection();
|
|
|
|
$sql = 'SELECT DISTINCT usr.lastModel ' . $this->generate_sql_constraints();
|
|
|
|
$sql .= ' ORDER BY usr.lastModel';
|
|
|
|
$stmt = $conn->prepare($sql);
|
|
$stmt->execute($this->sql_params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$lastModel = [];
|
|
|
|
foreach ($rs as $row) {
|
|
if (trim($row['lastModel']) === '')
|
|
continue;
|
|
|
|
$lastModel[] = $row['lastModel'];
|
|
}
|
|
|
|
return $lastModel;
|
|
}
|
|
|
|
private function generate_sort_constraint()
|
|
{
|
|
$sorter = [];
|
|
|
|
foreach ($this->sort as $sort => $ord) {
|
|
|
|
$k = count($sorter);
|
|
|
|
switch ($sort) {
|
|
case self::SORT_FIRSTNAME:
|
|
case self::SORT_LASTNAME:
|
|
case self::SORT_COMPANY:
|
|
case self::SORT_LOGIN:
|
|
case self::SORT_EMAIL:
|
|
$sorter[$k] = ' usr.`' . $sort . '` COLLATE utf8_unicode_ci ';
|
|
break;
|
|
case self::SORT_ID:
|
|
case self::SORT_CREATIONDATE:
|
|
case self::SORT_COUNTRY:
|
|
case self::SORT_LASTMODEL:
|
|
$sorter[$k] = ' usr.`' . $sort . '` ';
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if ( ! isset($sorter[$k]))
|
|
continue;
|
|
|
|
switch ($ord) {
|
|
case self::ORD_ASC:
|
|
default:
|
|
$sorter[$k] .= ' ASC ';
|
|
break;
|
|
case self::ORD_DESC:
|
|
$sorter[$k] .= ' DESC ';
|
|
break;
|
|
}
|
|
}
|
|
|
|
return implode(', ', $sorter);
|
|
}
|
|
}
|