nextcloud/lib/private/User/Manager.php

373 lines
9.9 KiB
PHP
Raw Normal View History

2013-05-29 01:46:57 +04:00
<?php
/**
2016-07-21 18:07:57 +03:00
* @copyright Copyright (c) 2016, ownCloud, Inc.
*
2016-05-26 20:56:05 +03:00
* @author Arthur Schiwon <blizzz@arthur-schiwon.de>
2016-07-21 18:07:57 +03:00
* @author Joas Schilling <coding@schilljs.com>
2015-03-26 13:44:34 +03:00
* @author Jörn Friedrich Dreyer <jfd@butonic.de>
2016-05-26 20:56:05 +03:00
* @author Lukas Reschke <lukas@statuscode.ch>
* @author Michael U <mdusher@users.noreply.github.com>
2015-03-26 13:44:34 +03:00
* @author Morris Jobke <hey@morrisjobke.de>
2016-07-21 19:13:36 +03:00
* @author Robin Appelman <robin@icewind.nl>
2016-01-12 17:02:16 +03:00
* @author Robin McCorkell <robin@mccorkell.me.uk>
2016-07-21 18:07:57 +03:00
* @author Roeland Jago Douma <roeland@famdouma.nl>
2016-01-12 17:02:16 +03:00
* @author Thomas Müller <thomas.mueller@tmit.eu>
* @author Vincent Chan <plus.vincchan@gmail.com>
2015-03-26 13:44:34 +03:00
* @author Volkan Gezer <volkangezer@gmail.com>
*
* @license AGPL-3.0
*
* This code is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License, version 3,
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
2013-05-29 01:46:57 +04:00
*/
2013-05-29 01:46:57 +04:00
namespace OC\User;
use OC\Hooks\PublicEmitter;
use OCP\IUser;
use OCP\IUserBackend;
use OCP\IUserManager;
2014-11-27 20:19:14 +03:00
use OCP\IConfig;
2013-05-29 01:46:57 +04:00
/**
* Class Manager
*
* Hooks available in scope \OC\User:
* - preSetPassword(\OC\User\User $user, string $password, string $recoverPassword)
* - postSetPassword(\OC\User\User $user, string $password, string $recoverPassword)
* - preDelete(\OC\User\User $user)
* - postDelete(\OC\User\User $user)
* - preCreateUser(string $uid, string $password)
2013-05-29 03:05:49 +04:00
* - postCreateUser(\OC\User\User $user, string $password)
* - change(\OC\User\User $user)
2013-05-29 01:46:57 +04:00
*
* @package OC\User
*/
class Manager extends PublicEmitter implements IUserManager {
2013-05-29 01:46:57 +04:00
/**
2016-02-14 23:28:22 +03:00
* @var \OCP\UserInterface[] $backends
2013-05-29 01:46:57 +04:00
*/
private $backends = array();
2013-07-10 02:06:22 +04:00
/**
* @var \OC\User\User[] $cachedUsers
*/
2013-05-31 19:31:27 +04:00
private $cachedUsers = array();
/**
2014-11-27 20:19:14 +03:00
* @var \OCP\IConfig $config
*/
private $config;
/**
2014-11-27 20:19:14 +03:00
* @param \OCP\IConfig $config
*/
2014-11-27 20:19:14 +03:00
public function __construct(IConfig $config = null) {
$this->config = $config;
$cachedUsers = &$this->cachedUsers;
2013-05-31 19:42:51 +04:00
$this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
/** @var \OC\User\User $user */
unset($cachedUsers[$user->getUID()]);
2013-05-31 19:42:51 +04:00
});
$this->listen('\OC\User', 'postLogin', function ($user) {
/** @var \OC\User\User $user */
$user->updateLastLoginTimestamp();
});
$this->listen('\OC\User', 'postRememberedLogin', function ($user) {
/** @var \OC\User\User $user */
$user->updateLastLoginTimestamp();
});
2013-05-31 19:42:51 +04:00
}
/**
* Get the active backends
2014-12-11 14:29:58 +03:00
* @return \OCP\UserInterface[]
*/
public function getBackends() {
return $this->backends;
}
2013-05-29 01:46:57 +04:00
/**
2013-06-03 15:33:56 +04:00
* register a user backend
*
2014-12-11 14:29:58 +03:00
* @param \OCP\UserInterface $backend
2013-05-29 01:46:57 +04:00
*/
public function registerBackend($backend) {
$this->backends[] = $backend;
}
/**
2013-06-03 15:33:56 +04:00
* remove a user backend
*
2014-12-11 14:29:58 +03:00
* @param \OCP\UserInterface $backend
2013-05-29 01:46:57 +04:00
*/
public function removeBackend($backend) {
$this->cachedUsers = array();
2013-05-29 01:46:57 +04:00
if (($i = array_search($backend, $this->backends)) !== false) {
unset($this->backends[$i]);
}
}
2013-06-03 15:33:56 +04:00
/**
* remove all user backends
*/
2013-05-29 01:46:57 +04:00
public function clearBackends() {
2013-06-03 15:46:05 +04:00
$this->cachedUsers = array();
2013-05-29 01:46:57 +04:00
$this->backends = array();
}
/**
2013-06-03 15:33:56 +04:00
* get a user by user id
*
2013-05-29 01:46:57 +04:00
* @param string $uid
* @return \OC\User\User|null Either the user or null if the specified user does not exist
2013-05-29 01:46:57 +04:00
*/
public function get($uid) {
2013-06-03 15:33:56 +04:00
if (isset($this->cachedUsers[$uid])) { //check the cache first to prevent having to loop over the backends
2013-05-31 19:31:27 +04:00
return $this->cachedUsers[$uid];
}
2013-05-29 01:46:57 +04:00
foreach ($this->backends as $backend) {
if ($backend->userExists($uid)) {
2013-05-31 19:42:51 +04:00
return $this->getUserObject($uid, $backend);
2013-05-29 01:46:57 +04:00
}
}
return null;
}
2013-06-03 15:33:56 +04:00
/**
* get or construct the user object
*
* @param string $uid
2014-12-11 14:29:58 +03:00
* @param \OCP\UserInterface $backend
* @param bool $cacheUser If false the newly created user object will not be cached
2013-06-03 15:33:56 +04:00
* @return \OC\User\User
*/
protected function getUserObject($uid, $backend, $cacheUser = true) {
2013-05-31 19:42:51 +04:00
if (isset($this->cachedUsers[$uid])) {
return $this->cachedUsers[$uid];
}
$user = new User($uid, $backend, $this, $this->config);
if ($cacheUser) {
$this->cachedUsers[$uid] = $user;
}
return $user;
2013-05-31 19:42:51 +04:00
}
2013-05-29 01:46:57 +04:00
/**
2013-06-03 15:33:56 +04:00
* check if a user exists
*
2013-05-29 01:46:57 +04:00
* @param string $uid
* @return bool
*/
public function userExists($uid) {
2013-06-03 15:46:05 +04:00
$user = $this->get($uid);
return ($user !== null);
2013-05-29 01:46:57 +04:00
}
/**
* Check if the password is valid for the user
*
* @param string $loginName
* @param string $password
* @return mixed the User object on success, false otherwise
*/
public function checkPassword($loginName, $password) {
$loginName = str_replace("\0", '', $loginName);
$password = str_replace("\0", '', $password);
foreach ($this->backends as $backend) {
2016-08-11 10:52:02 +03:00
if ($backend->implementsActions(Backend::CHECK_PASSWORD)) {
$uid = $backend->checkPassword($loginName, $password);
2013-09-24 19:10:01 +04:00
if ($uid !== false) {
return $this->getUserObject($uid, $backend);
}
}
}
\OC::$server->getLogger()->warning('Login failed: \''. $loginName .'\' (Remote IP: \''. \OC::$server->getRequest()->getRemoteAddress(). '\')', ['app' => 'core']);
2013-09-24 19:10:01 +04:00
return false;
}
2013-05-29 01:46:57 +04:00
/**
* search by user id
*
* @param string $pattern
* @param int $limit
* @param int $offset
* @return \OC\User\User[]
*/
public function search($pattern, $limit = null, $offset = null) {
$users = array();
foreach ($this->backends as $backend) {
$backendUsers = $backend->getUsers($pattern, $limit, $offset);
if (is_array($backendUsers)) {
foreach ($backendUsers as $uid) {
$users[$uid] = $this->getUserObject($uid, $backend);
2013-05-29 01:46:57 +04:00
}
}
}
uasort($users, function ($a, $b) {
2013-05-29 01:46:57 +04:00
/**
* @var \OC\User\User $a
* @var \OC\User\User $b
*/
return strcmp($a->getUID(), $b->getUID());
});
return $users;
}
/**
* search by displayName
*
* @param string $pattern
* @param int $limit
* @param int $offset
* @return \OC\User\User[]
*/
public function searchDisplayName($pattern, $limit = null, $offset = null) {
$users = array();
foreach ($this->backends as $backend) {
$backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
if (is_array($backendUsers)) {
foreach ($backendUsers as $uid => $displayName) {
2013-05-31 19:42:51 +04:00
$users[] = $this->getUserObject($uid, $backend);
2013-05-29 01:46:57 +04:00
}
}
}
usort($users, function ($a, $b) {
/**
* @var \OC\User\User $a
* @var \OC\User\User $b
*/
return strcmp($a->getDisplayName(), $b->getDisplayName());
});
return $users;
}
/**
* @param string $uid
* @param string $password
* @throws \Exception
* @return bool|\OC\User\User the created user or false
2013-05-29 01:46:57 +04:00
*/
public function createUser($uid, $password) {
2014-08-31 12:05:59 +04:00
$l = \OC::$server->getL10N('lib');
2013-05-29 01:46:57 +04:00
// Check the name for bad characters
2016-01-20 16:21:54 +03:00
// Allowed are: "a-z", "A-Z", "0-9" and "_.@-'"
if (preg_match('/[^a-zA-Z0-9 _\.@\-\']/', $uid)) {
throw new \Exception($l->t('Only the following characters are allowed in a username:'
2016-01-20 16:21:54 +03:00
. ' "a-z", "A-Z", "0-9", and "_.@-\'"'));
2013-05-29 01:46:57 +04:00
}
// No empty username
if (trim($uid) == '') {
throw new \Exception($l->t('A valid username must be provided'));
2013-05-29 01:46:57 +04:00
}
2016-02-03 16:09:15 +03:00
// No whitespace at the beginning or at the end
if (strlen(trim($uid, "\t\n\r\0\x0B\xe2\x80\x8b")) !== strlen(trim($uid))) {
throw new \Exception($l->t('Username contains whitespace at the beginning or at the end'));
}
2013-05-29 01:46:57 +04:00
// No empty password
if (trim($password) == '') {
throw new \Exception($l->t('A valid password must be provided'));
2013-05-29 01:46:57 +04:00
}
// Check if user already exists
if ($this->userExists($uid)) {
throw new \Exception($l->t('The username is already being used'));
2013-05-29 01:46:57 +04:00
}
$this->emit('\OC\User', 'preCreateUser', array($uid, $password));
foreach ($this->backends as $backend) {
2016-08-11 10:52:02 +03:00
if ($backend->implementsActions(Backend::CREATE_USER)) {
2013-05-29 01:46:57 +04:00
$backend->createUser($uid, $password);
2013-05-31 19:42:51 +04:00
$user = $this->getUserObject($uid, $backend);
2013-05-29 03:05:49 +04:00
$this->emit('\OC\User', 'postCreateUser', array($user, $password));
2013-05-29 01:46:57 +04:00
return $user;
}
}
return false;
}
/**
* returns how many users per backend exist (if supported by backend)
*
2014-05-11 21:13:51 +04:00
* @return array an array of backend class as key and count number as value
*/
public function countUsers() {
$userCountStatistics = array();
foreach ($this->backends as $backend) {
2016-08-11 10:52:02 +03:00
if ($backend->implementsActions(Backend::COUNT_USERS)) {
$backendUsers = $backend->countUsers();
if($backendUsers !== false) {
if($backend instanceof IUserBackend) {
$name = $backend->getBackendName();
} else {
$name = get_class($backend);
}
if(isset($userCountStatistics[$name])) {
$userCountStatistics[$name] += $backendUsers;
} else {
$userCountStatistics[$name] = $backendUsers;
}
}
}
}
return $userCountStatistics;
}
/**
* The callback is executed for each user on each backend.
* If the callback returns false no further users will be retrieved.
*
* @param \Closure $callback
* @param string $search
* @since 9.0.0
*/
public function callForAllUsers(\Closure $callback, $search = '') {
foreach($this->getBackends() as $backend) {
2015-12-02 11:20:58 +03:00
$limit = 500;
$offset = 0;
do {
$users = $backend->getUsers($search, $limit, $offset);
foreach ($users as $uid) {
if (!$backend->userExists($uid)) {
continue;
}
$user = $this->getUserObject($uid, $backend, false);
$return = $callback($user);
if ($return === false) {
break;
}
}
$offset += $limit;
} while (count($users) >= $limit);
}
}
/**
* @param string $email
* @return IUser[]
* @since 9.1.0
*/
public function getByEmail($email) {
$userIds = $this->config->getUsersForUserValue('settings', 'email', $email);
return array_map(function($uid) {
return $this->get($uid);
}, $userIds);
}
2013-05-29 01:46:57 +04:00
}