nextcloud / server

apps/user_ldap/lib/User_LDAP.php

Indentation +583 added lines, -583 removed lines

@@ -52,587 +52,587 @@
 use OCP\Util;
 
 class User_LDAP extends BackendUtility implements \OCP\IUserBackend, \OCP\UserInterface, IUserLDAP {
-	/** @var \OCP\IConfig */
-	protected $ocConfig;
-
-	/** @var INotificationManager */
-	protected $notificationManager;
-
-	/** @var UserPluginManager */
-	protected $userPluginManager;
-
-	/**
-	 * @param Access $access
-	 * @param \OCP\IConfig $ocConfig
-	 * @param \OCP\Notification\IManager $notificationManager
-	 * @param IUserSession $userSession
-	 */
-	public function __construct(Access $access, IConfig $ocConfig, INotificationManager $notificationManager, IUserSession $userSession, UserPluginManager $userPluginManager) {
-		parent::__construct($access);
-		$this->ocConfig = $ocConfig;
-		$this->notificationManager = $notificationManager;
-		$this->userPluginManager = $userPluginManager;
-	}
-
-	/**
-	 * checks whether the user is allowed to change his avatar in Nextcloud
-	 *
-	 * @param string $uid the Nextcloud user name
-	 * @return boolean either the user can or cannot
-	 * @throws \Exception
-	 */
-	public function canChangeAvatar($uid) {
-		if ($this->userPluginManager->implementsActions(Backend::PROVIDE_AVATAR)) {
-			return $this->userPluginManager->canChangeAvatar($uid);
-		}
-
-		if (!$this->implementsActions(Backend::PROVIDE_AVATAR)) {
-			return true;
-		}
-
-		$user = $this->access->userManager->get($uid);
-		if (!$user instanceof User) {
-			return false;
-		}
-		$imageData = $user->getAvatarImage();
-		if ($imageData === false) {
-			return true;
-		}
-		return !$user->updateAvatar(true);
-	}
-
-	/**
-	 * Return the username for the given login name, if available
-	 *
-	 * @param string $loginName
-	 * @return string|false
-	 * @throws \Exception
-	 */
-	public function loginName2UserName($loginName) {
-		$cacheKey = 'loginName2UserName-' . $loginName;
-		$username = $this->access->connection->getFromCache($cacheKey);
-
-		if ($username !== null) {
-			return $username;
-		}
-
-		try {
-			$ldapRecord = $this->getLDAPUserByLoginName($loginName);
-			$user = $this->access->userManager->get($ldapRecord['dn'][0]);
-			if ($user === null || $user instanceof OfflineUser) {
-				// this path is not really possible, however get() is documented
-				// to return User, OfflineUser or null so we are very defensive here.
-				$this->access->connection->writeToCache($cacheKey, false);
-				return false;
-			}
-			$username = $user->getUsername();
-			$this->access->connection->writeToCache($cacheKey, $username);
-			return $username;
-		} catch (NotOnLDAP $e) {
-			$this->access->connection->writeToCache($cacheKey, false);
-			return false;
-		}
-	}
-
-	/**
-	 * returns the username for the given LDAP DN, if available
-	 *
-	 * @param string $dn
-	 * @return string|false with the username
-	 */
-	public function dn2UserName($dn) {
-		return $this->access->dn2username($dn);
-	}
-
-	/**
-	 * returns an LDAP record based on a given login name
-	 *
-	 * @param string $loginName
-	 * @return array
-	 * @throws NotOnLDAP
-	 */
-	public function getLDAPUserByLoginName($loginName) {
-		//find out dn of the user name
-		$attrs = $this->access->userManager->getAttributes();
-		$users = $this->access->fetchUsersByLoginName($loginName, $attrs);
-		if (count($users) < 1) {
-			throw new NotOnLDAP('No user available for the given login name on ' .
-				$this->access->connection->ldapHost . ':' . $this->access->connection->ldapPort);
-		}
-		return $users[0];
-	}
-
-	/**
-	 * Check if the password is correct without logging in the user
-	 *
-	 * @param string $uid The username
-	 * @param string $password The password
-	 * @return false|string
-	 */
-	public function checkPassword($uid, $password) {
-		try {
-			$ldapRecord = $this->getLDAPUserByLoginName($uid);
-		} catch (NotOnLDAP $e) {
-			\OC::$server->getLogger()->logException($e, ['app' => 'user_ldap', 'level' => ILogger::DEBUG]);
-			return false;
-		}
-		$dn = $ldapRecord['dn'][0];
-		$user = $this->access->userManager->get($dn);
-
-		if (!$user instanceof User) {
-			Util::writeLog('user_ldap',
-				'LDAP Login: Could not get user object for DN ' . $dn .
-				'. Maybe the LDAP entry has no set display name attribute?',
-				ILogger::WARN);
-			return false;
-		}
-		if ($user->getUsername() !== false) {
-			//are the credentials OK?
-			if (!$this->access->areCredentialsValid($dn, $password)) {
-				return false;
-			}
-
-			$this->access->cacheUserExists($user->getUsername());
-			$user->processAttributes($ldapRecord);
-			$user->markLogin();
-
-			return $user->getUsername();
-		}
-
-		return false;
-	}
-
-	/**
-	 * Set password
-	 * @param string $uid The username
-	 * @param string $password The new password
-	 * @return bool
-	 */
-	public function setPassword($uid, $password) {
-		if ($this->userPluginManager->implementsActions(Backend::SET_PASSWORD)) {
-			return $this->userPluginManager->setPassword($uid, $password);
-		}
-
-		$user = $this->access->userManager->get($uid);
-
-		if (!$user instanceof User) {
-			throw new \Exception('LDAP setPassword: Could not get user object for uid ' . $uid .
-				'. Maybe the LDAP entry has no set display name attribute?');
-		}
-		if ($user->getUsername() !== false && $this->access->setPassword($user->getDN(), $password)) {
-			$ldapDefaultPPolicyDN = $this->access->connection->ldapDefaultPPolicyDN;
-			$turnOnPasswordChange = $this->access->connection->turnOnPasswordChange;
-			if (!empty($ldapDefaultPPolicyDN) && ((int)$turnOnPasswordChange === 1)) {
-				//remove last password expiry warning if any
-				$notification = $this->notificationManager->createNotification();
-				$notification->setApp('user_ldap')
-					->setUser($uid)
-					->setObject('pwd_exp_warn', $uid)
-				;
-				$this->notificationManager->markProcessed($notification);
-			}
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param integer $limit
-	 * @param integer $offset
-	 * @return string[] an array of all uids
-	 */
-	public function getUsers($search = '', $limit = 10, $offset = 0) {
-		$search = $this->access->escapeFilterPart($search, true);
-		$cachekey = 'getUsers-'.$search.'-'.$limit.'-'.$offset;
-
-		//check if users are cached, if so return
-		$ldap_users = $this->access->connection->getFromCache($cachekey);
-		if (!is_null($ldap_users)) {
-			return $ldap_users;
-		}
-
-		// if we'd pass -1 to LDAP search, we'd end up in a Protocol
-		// error. With a limit of 0, we get 0 results. So we pass null.
-		if ($limit <= 0) {
-			$limit = null;
-		}
-		$filter = $this->access->combineFilterWithAnd([
-			$this->access->connection->ldapUserFilter,
-			$this->access->connection->ldapUserDisplayName . '=*',
-			$this->access->getFilterPartForUserSearch($search)
-		]);
-
-		Util::writeLog('user_ldap',
-			'getUsers: Options: search '.$search.' limit '.$limit.' offset '.$offset.' Filter: '.$filter,
-			ILogger::DEBUG);
-		//do the search and translate results to Nextcloud names
-		$ldap_users = $this->access->fetchListOfUsers(
-			$filter,
-			$this->access->userManager->getAttributes(true),
-			$limit, $offset);
-		$ldap_users = $this->access->nextcloudUserNames($ldap_users);
-		Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', ILogger::DEBUG);
-
-		$this->access->connection->writeToCache($cachekey, $ldap_users);
-		return $ldap_users;
-	}
-
-	/**
-	 * checks whether a user is still available on LDAP
-	 *
-	 * @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
-	 * name or an instance of that user
-	 * @return bool
-	 * @throws \Exception
-	 * @throws \OC\ServerNotAvailableException
-	 */
-	public function userExistsOnLDAP($user) {
-		if (is_string($user)) {
-			$user = $this->access->userManager->get($user);
-		}
-		if (is_null($user)) {
-			return false;
-		}
-		$uid = $user instanceof User ? $user->getUsername() : $user->getOCName();
-		$cacheKey = 'userExistsOnLDAP' . $uid;
-		$userExists = $this->access->connection->getFromCache($cacheKey);
-		if (!is_null($userExists)) {
-			return (bool)$userExists;
-		}
-
-		$dn = $user->getDN();
-		//check if user really still exists by reading its entry
-		if (!is_array($this->access->readAttribute($dn, '', $this->access->connection->ldapUserFilter))) {
-			try {
-				$uuid = $this->access->getUserMapper()->getUUIDByDN($dn);
-				if (!$uuid) {
-					$this->access->connection->writeToCache($cacheKey, false);
-					return false;
-				}
-				$newDn = $this->access->getUserDnByUuid($uuid);
-				//check if renamed user is still valid by reapplying the ldap filter
-				if ($newDn === $dn || !is_array($this->access->readAttribute($newDn, '', $this->access->connection->ldapUserFilter))) {
-					$this->access->connection->writeToCache($cacheKey, false);
-					return false;
-				}
-				$this->access->getUserMapper()->setDNbyUUID($newDn, $uuid);
-				$this->access->connection->writeToCache($cacheKey, true);
-				return true;
-			} catch (ServerNotAvailableException $e) {
-				throw $e;
-			} catch (\Exception $e) {
-				$this->access->connection->writeToCache($cacheKey, false);
-				return false;
-			}
-		}
-
-		if ($user instanceof OfflineUser) {
-			$user->unmark();
-		}
-
-		$this->access->connection->writeToCache($cacheKey, true);
-		return true;
-	}
-
-	/**
-	 * check if a user exists
-	 * @param string $uid the username
-	 * @return boolean
-	 * @throws \Exception when connection could not be established
-	 */
-	public function userExists($uid) {
-		$userExists = $this->access->connection->getFromCache('userExists'.$uid);
-		if (!is_null($userExists)) {
-			return (bool)$userExists;
-		}
-		//getting dn, if false the user does not exist. If dn, he may be mapped only, requires more checking.
-		$user = $this->access->userManager->get($uid);
-
-		if (is_null($user)) {
-			Util::writeLog('user_ldap', 'No DN found for '.$uid.' on '.
-				$this->access->connection->ldapHost, ILogger::DEBUG);
-			$this->access->connection->writeToCache('userExists'.$uid, false);
-			return false;
-		}
-
-		$this->access->connection->writeToCache('userExists'.$uid, true);
-		return true;
-	}
-
-	/**
-	 * returns whether a user was deleted in LDAP
-	 *
-	 * @param string $uid The username of the user to delete
-	 * @return bool
-	 */
-	public function deleteUser($uid) {
-		if ($this->userPluginManager->canDeleteUser()) {
-			$status = $this->userPluginManager->deleteUser($uid);
-			if ($status === false) {
-				return false;
-			}
-		}
-
-		$marked = $this->ocConfig->getUserValue($uid, 'user_ldap', 'isDeleted', 0);
-		if ((int)$marked === 0) {
-			\OC::$server->getLogger()->notice(
-				'User '.$uid . ' is not marked as deleted, not cleaning up.',
-				['app' => 'user_ldap']);
-			return false;
-		}
-		\OC::$server->getLogger()->info('Cleaning up after user ' . $uid,
-			['app' => 'user_ldap']);
-
-		$this->access->getUserMapper()->unmap($uid); // we don't emit unassign signals here, since it is implicit to delete signals fired from core
-		$this->access->userManager->invalidate($uid);
-		$this->access->connection->clearCache();
-		return true;
-	}
-
-	/**
-	 * get the user's home directory
-	 *
-	 * @param string $uid the username
-	 * @return bool|string
-	 * @throws NoUserException
-	 * @throws \Exception
-	 */
-	public function getHome($uid) {
-		// user Exists check required as it is not done in user proxy!
-		if (!$this->userExists($uid)) {
-			return false;
-		}
-
-		if ($this->userPluginManager->implementsActions(Backend::GET_HOME)) {
-			return $this->userPluginManager->getHome($uid);
-		}
-
-		$cacheKey = 'getHome'.$uid;
-		$path = $this->access->connection->getFromCache($cacheKey);
-		if (!is_null($path)) {
-			return $path;
-		}
-
-		// early return path if it is a deleted user
-		$user = $this->access->userManager->get($uid);
-		if ($user instanceof User || $user instanceof OfflineUser) {
-			$path = $user->getHomePath() ?: false;
-		} else {
-			throw new NoUserException($uid . ' is not a valid user anymore');
-		}
-
-		$this->access->cacheUserHome($uid, $path);
-		return $path;
-	}
-
-	/**
-	 * get display name of the user
-	 * @param string $uid user ID of the user
-	 * @return string|false display name
-	 */
-	public function getDisplayName($uid) {
-		if ($this->userPluginManager->implementsActions(Backend::GET_DISPLAYNAME)) {
-			return $this->userPluginManager->getDisplayName($uid);
-		}
-
-		if (!$this->userExists($uid)) {
-			return false;
-		}
-
-		$cacheKey = 'getDisplayName'.$uid;
-		if (!is_null($displayName = $this->access->connection->getFromCache($cacheKey))) {
-			return $displayName;
-		}
-
-		//Check whether the display name is configured to have a 2nd feature
-		$additionalAttribute = $this->access->connection->ldapUserDisplayName2;
-		$displayName2 = '';
-		if ($additionalAttribute !== '') {
-			$displayName2 = $this->access->readAttribute(
-				$this->access->username2dn($uid),
-				$additionalAttribute);
-		}
-
-		$displayName = $this->access->readAttribute(
-			$this->access->username2dn($uid),
-			$this->access->connection->ldapUserDisplayName);
-
-		if ($displayName && (count($displayName) > 0)) {
-			$displayName = $displayName[0];
-
-			if (is_array($displayName2)) {
-				$displayName2 = count($displayName2) > 0 ? $displayName2[0] : '';
-			}
-
-			$user = $this->access->userManager->get($uid);
-			if ($user instanceof User) {
-				$displayName = $user->composeAndStoreDisplayName($displayName, $displayName2);
-				$this->access->connection->writeToCache($cacheKey, $displayName);
-			}
-			if ($user instanceof OfflineUser) {
-				/** @var OfflineUser $user*/
-				$displayName = $user->getDisplayName();
-			}
-			return $displayName;
-		}
-
-		return null;
-	}
-
-	/**
-	 * set display name of the user
-	 * @param string $uid user ID of the user
-	 * @param string $displayName new display name of the user
-	 * @return string|false display name
-	 */
-	public function setDisplayName($uid, $displayName) {
-		if ($this->userPluginManager->implementsActions(Backend::SET_DISPLAYNAME)) {
-			$this->userPluginManager->setDisplayName($uid, $displayName);
-			$this->access->cacheUserDisplayName($uid, $displayName);
-			return $displayName;
-		}
-		return false;
-	}
-
-	/**
-	 * Get a list of all display names
-	 *
-	 * @param string $search
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null) {
-		$cacheKey = 'getDisplayNames-'.$search.'-'.$limit.'-'.$offset;
-		if (!is_null($displayNames = $this->access->connection->getFromCache($cacheKey))) {
-			return $displayNames;
-		}
-
-		$displayNames = [];
-		$users = $this->getUsers($search, $limit, $offset);
-		foreach ($users as $user) {
-			$displayNames[$user] = $this->getDisplayName($user);
-		}
-		$this->access->connection->writeToCache($cacheKey, $displayNames);
-		return $displayNames;
-	}
-
-	/**
-	 * Check if backend implements actions
-	 * @param int $actions bitwise-or'ed actions
-	 * @return boolean
-	 *
-	 * Returns the supported actions as int to be
-	 * compared with \OC\User\Backend::CREATE_USER etc.
-	 */
-	public function implementsActions($actions) {
-		return (bool)((Backend::CHECK_PASSWORD
-			| Backend::GET_HOME
-			| Backend::GET_DISPLAYNAME
-			| (($this->access->connection->ldapUserAvatarRule !== 'none') ? Backend::PROVIDE_AVATAR : 0)
-			| Backend::COUNT_USERS
-			| (((int)$this->access->connection->turnOnPasswordChange === 1)? Backend::SET_PASSWORD :0)
-			| $this->userPluginManager->getImplementedActions())
-			& $actions);
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function hasUserListings() {
-		return true;
-	}
-
-	/**
-	 * counts the users in LDAP
-	 *
-	 * @return int|bool
-	 */
-	public function countUsers() {
-		if ($this->userPluginManager->implementsActions(Backend::COUNT_USERS)) {
-			return $this->userPluginManager->countUsers();
-		}
-
-		$filter = $this->access->getFilterForUserCount();
-		$cacheKey = 'countUsers-'.$filter;
-		if (!is_null($entries = $this->access->connection->getFromCache($cacheKey))) {
-			return $entries;
-		}
-		$entries = $this->access->countUsers($filter);
-		$this->access->connection->writeToCache($cacheKey, $entries);
-		return $entries;
-	}
-
-	/**
-	 * Backend name to be shown in user management
-	 * @return string the name of the backend to be shown
-	 */
-	public function getBackendName() {
-		return 'LDAP';
-	}
-
-	/**
-	 * Return access for LDAP interaction.
-	 * @param string $uid
-	 * @return Access instance of Access for LDAP interaction
-	 */
-	public function getLDAPAccess($uid) {
-		return $this->access;
-	}
-
-	/**
-	 * Return LDAP connection resource from a cloned connection.
-	 * The cloned connection needs to be closed manually.
-	 * of the current access.
-	 * @param string $uid
-	 * @return resource of the LDAP connection
-	 */
-	public function getNewLDAPConnection($uid) {
-		$connection = clone $this->access->getConnection();
-		return $connection->getConnectionResource();
-	}
-
-	/**
-	 * create new user
-	 * @param string $username username of the new user
-	 * @param string $password password of the new user
-	 * @throws \UnexpectedValueException
-	 * @return bool
-	 */
-	public function createUser($username, $password) {
-		if ($this->userPluginManager->implementsActions(Backend::CREATE_USER)) {
-			if ($dn = $this->userPluginManager->createUser($username, $password)) {
-				if (is_string($dn)) {
-					// the NC user creation work flow requires a know user id up front
-					$uuid = $this->access->getUUID($dn, true);
-					if (is_string($uuid)) {
-						$this->access->mapAndAnnounceIfApplicable(
-							$this->access->getUserMapper(),
-							$dn,
-							$username,
-							$uuid,
-							true
-						);
-						$this->access->cacheUserExists($username);
-					} else {
-						\OC::$server->getLogger()->warning(
-							'Failed to map created LDAP user with userid {userid}, because UUID could not be determined',
-							[
-								'app' => 'user_ldap',
-								'userid' => $username,
-							]
-						);
-					}
-				} else {
-					throw new \UnexpectedValueException("LDAP Plugin: Method createUser changed to return the user DN instead of boolean.");
-				}
-			}
-			return (bool) $dn;
-		}
-		return false;
-	}
+    /** @var \OCP\IConfig */
+    protected $ocConfig;
+
+    /** @var INotificationManager */
+    protected $notificationManager;
+
+    /** @var UserPluginManager */
+    protected $userPluginManager;
+
+    /**
+     * @param Access $access
+     * @param \OCP\IConfig $ocConfig
+     * @param \OCP\Notification\IManager $notificationManager
+     * @param IUserSession $userSession
+     */
+    public function __construct(Access $access, IConfig $ocConfig, INotificationManager $notificationManager, IUserSession $userSession, UserPluginManager $userPluginManager) {
+        parent::__construct($access);
+        $this->ocConfig = $ocConfig;
+        $this->notificationManager = $notificationManager;
+        $this->userPluginManager = $userPluginManager;
+    }
+
+    /**
+     * checks whether the user is allowed to change his avatar in Nextcloud
+     *
+     * @param string $uid the Nextcloud user name
+     * @return boolean either the user can or cannot
+     * @throws \Exception
+     */
+    public function canChangeAvatar($uid) {
+        if ($this->userPluginManager->implementsActions(Backend::PROVIDE_AVATAR)) {
+            return $this->userPluginManager->canChangeAvatar($uid);
+        }
+
+        if (!$this->implementsActions(Backend::PROVIDE_AVATAR)) {
+            return true;
+        }
+
+        $user = $this->access->userManager->get($uid);
+        if (!$user instanceof User) {
+            return false;
+        }
+        $imageData = $user->getAvatarImage();
+        if ($imageData === false) {
+            return true;
+        }
+        return !$user->updateAvatar(true);
+    }
+
+    /**
+     * Return the username for the given login name, if available
+     *
+     * @param string $loginName
+     * @return string|false
+     * @throws \Exception
+     */
+    public function loginName2UserName($loginName) {
+        $cacheKey = 'loginName2UserName-' . $loginName;
+        $username = $this->access->connection->getFromCache($cacheKey);
+
+        if ($username !== null) {
+            return $username;
+        }
+
+        try {
+            $ldapRecord = $this->getLDAPUserByLoginName($loginName);
+            $user = $this->access->userManager->get($ldapRecord['dn'][0]);
+            if ($user === null || $user instanceof OfflineUser) {
+                // this path is not really possible, however get() is documented
+                // to return User, OfflineUser or null so we are very defensive here.
+                $this->access->connection->writeToCache($cacheKey, false);
+                return false;
+            }
+            $username = $user->getUsername();
+            $this->access->connection->writeToCache($cacheKey, $username);
+            return $username;
+        } catch (NotOnLDAP $e) {
+            $this->access->connection->writeToCache($cacheKey, false);
+            return false;
+        }
+    }
+
+    /**
+     * returns the username for the given LDAP DN, if available
+     *
+     * @param string $dn
+     * @return string|false with the username
+     */
+    public function dn2UserName($dn) {
+        return $this->access->dn2username($dn);
+    }
+
+    /**
+     * returns an LDAP record based on a given login name
+     *
+     * @param string $loginName
+     * @return array
+     * @throws NotOnLDAP
+     */
+    public function getLDAPUserByLoginName($loginName) {
+        //find out dn of the user name
+        $attrs = $this->access->userManager->getAttributes();
+        $users = $this->access->fetchUsersByLoginName($loginName, $attrs);
+        if (count($users) < 1) {
+            throw new NotOnLDAP('No user available for the given login name on ' .
+                $this->access->connection->ldapHost . ':' . $this->access->connection->ldapPort);
+        }
+        return $users[0];
+    }
+
+    /**
+     * Check if the password is correct without logging in the user
+     *
+     * @param string $uid The username
+     * @param string $password The password
+     * @return false|string
+     */
+    public function checkPassword($uid, $password) {
+        try {
+            $ldapRecord = $this->getLDAPUserByLoginName($uid);
+        } catch (NotOnLDAP $e) {
+            \OC::$server->getLogger()->logException($e, ['app' => 'user_ldap', 'level' => ILogger::DEBUG]);
+            return false;
+        }
+        $dn = $ldapRecord['dn'][0];
+        $user = $this->access->userManager->get($dn);
+
+        if (!$user instanceof User) {
+            Util::writeLog('user_ldap',
+                'LDAP Login: Could not get user object for DN ' . $dn .
+                '. Maybe the LDAP entry has no set display name attribute?',
+                ILogger::WARN);
+            return false;
+        }
+        if ($user->getUsername() !== false) {
+            //are the credentials OK?
+            if (!$this->access->areCredentialsValid($dn, $password)) {
+                return false;
+            }
+
+            $this->access->cacheUserExists($user->getUsername());
+            $user->processAttributes($ldapRecord);
+            $user->markLogin();
+
+            return $user->getUsername();
+        }
+
+        return false;
+    }
+
+    /**
+     * Set password
+     * @param string $uid The username
+     * @param string $password The new password
+     * @return bool
+     */
+    public function setPassword($uid, $password) {
+        if ($this->userPluginManager->implementsActions(Backend::SET_PASSWORD)) {
+            return $this->userPluginManager->setPassword($uid, $password);
+        }
+
+        $user = $this->access->userManager->get($uid);
+
+        if (!$user instanceof User) {
+            throw new \Exception('LDAP setPassword: Could not get user object for uid ' . $uid .
+                '. Maybe the LDAP entry has no set display name attribute?');
+        }
+        if ($user->getUsername() !== false && $this->access->setPassword($user->getDN(), $password)) {
+            $ldapDefaultPPolicyDN = $this->access->connection->ldapDefaultPPolicyDN;
+            $turnOnPasswordChange = $this->access->connection->turnOnPasswordChange;
+            if (!empty($ldapDefaultPPolicyDN) && ((int)$turnOnPasswordChange === 1)) {
+                //remove last password expiry warning if any
+                $notification = $this->notificationManager->createNotification();
+                $notification->setApp('user_ldap')
+                    ->setUser($uid)
+                    ->setObject('pwd_exp_warn', $uid)
+                ;
+                $this->notificationManager->markProcessed($notification);
+            }
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param integer $limit
+     * @param integer $offset
+     * @return string[] an array of all uids
+     */
+    public function getUsers($search = '', $limit = 10, $offset = 0) {
+        $search = $this->access->escapeFilterPart($search, true);
+        $cachekey = 'getUsers-'.$search.'-'.$limit.'-'.$offset;
+
+        //check if users are cached, if so return
+        $ldap_users = $this->access->connection->getFromCache($cachekey);
+        if (!is_null($ldap_users)) {
+            return $ldap_users;
+        }
+
+        // if we'd pass -1 to LDAP search, we'd end up in a Protocol
+        // error. With a limit of 0, we get 0 results. So we pass null.
+        if ($limit <= 0) {
+            $limit = null;
+        }
+        $filter = $this->access->combineFilterWithAnd([
+            $this->access->connection->ldapUserFilter,
+            $this->access->connection->ldapUserDisplayName . '=*',
+            $this->access->getFilterPartForUserSearch($search)
+        ]);
+
+        Util::writeLog('user_ldap',
+            'getUsers: Options: search '.$search.' limit '.$limit.' offset '.$offset.' Filter: '.$filter,
+            ILogger::DEBUG);
+        //do the search and translate results to Nextcloud names
+        $ldap_users = $this->access->fetchListOfUsers(
+            $filter,
+            $this->access->userManager->getAttributes(true),
+            $limit, $offset);
+        $ldap_users = $this->access->nextcloudUserNames($ldap_users);
+        Util::writeLog('user_ldap', 'getUsers: '.count($ldap_users). ' Users found', ILogger::DEBUG);
+
+        $this->access->connection->writeToCache($cachekey, $ldap_users);
+        return $ldap_users;
+    }
+
+    /**
+     * checks whether a user is still available on LDAP
+     *
+     * @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
+     * name or an instance of that user
+     * @return bool
+     * @throws \Exception
+     * @throws \OC\ServerNotAvailableException
+     */
+    public function userExistsOnLDAP($user) {
+        if (is_string($user)) {
+            $user = $this->access->userManager->get($user);
+        }
+        if (is_null($user)) {
+            return false;
+        }
+        $uid = $user instanceof User ? $user->getUsername() : $user->getOCName();
+        $cacheKey = 'userExistsOnLDAP' . $uid;
+        $userExists = $this->access->connection->getFromCache($cacheKey);
+        if (!is_null($userExists)) {
+            return (bool)$userExists;
+        }
+
+        $dn = $user->getDN();
+        //check if user really still exists by reading its entry
+        if (!is_array($this->access->readAttribute($dn, '', $this->access->connection->ldapUserFilter))) {
+            try {
+                $uuid = $this->access->getUserMapper()->getUUIDByDN($dn);
+                if (!$uuid) {
+                    $this->access->connection->writeToCache($cacheKey, false);
+                    return false;
+                }
+                $newDn = $this->access->getUserDnByUuid($uuid);
+                //check if renamed user is still valid by reapplying the ldap filter
+                if ($newDn === $dn || !is_array($this->access->readAttribute($newDn, '', $this->access->connection->ldapUserFilter))) {
+                    $this->access->connection->writeToCache($cacheKey, false);
+                    return false;
+                }
+                $this->access->getUserMapper()->setDNbyUUID($newDn, $uuid);
+                $this->access->connection->writeToCache($cacheKey, true);
+                return true;
+            } catch (ServerNotAvailableException $e) {
+                throw $e;
+            } catch (\Exception $e) {
+                $this->access->connection->writeToCache($cacheKey, false);
+                return false;
+            }
+        }
+
+        if ($user instanceof OfflineUser) {
+            $user->unmark();
+        }
+
+        $this->access->connection->writeToCache($cacheKey, true);
+        return true;
+    }
+
+    /**
+     * check if a user exists
+     * @param string $uid the username
+     * @return boolean
+     * @throws \Exception when connection could not be established
+     */
+    public function userExists($uid) {
+        $userExists = $this->access->connection->getFromCache('userExists'.$uid);
+        if (!is_null($userExists)) {
+            return (bool)$userExists;
+        }
+        //getting dn, if false the user does not exist. If dn, he may be mapped only, requires more checking.
+        $user = $this->access->userManager->get($uid);
+
+        if (is_null($user)) {
+            Util::writeLog('user_ldap', 'No DN found for '.$uid.' on '.
+                $this->access->connection->ldapHost, ILogger::DEBUG);
+            $this->access->connection->writeToCache('userExists'.$uid, false);
+            return false;
+        }
+
+        $this->access->connection->writeToCache('userExists'.$uid, true);
+        return true;
+    }
+
+    /**
+     * returns whether a user was deleted in LDAP
+     *
+     * @param string $uid The username of the user to delete
+     * @return bool
+     */
+    public function deleteUser($uid) {
+        if ($this->userPluginManager->canDeleteUser()) {
+            $status = $this->userPluginManager->deleteUser($uid);
+            if ($status === false) {
+                return false;
+            }
+        }
+
+        $marked = $this->ocConfig->getUserValue($uid, 'user_ldap', 'isDeleted', 0);
+        if ((int)$marked === 0) {
+            \OC::$server->getLogger()->notice(
+                'User '.$uid . ' is not marked as deleted, not cleaning up.',
+                ['app' => 'user_ldap']);
+            return false;
+        }
+        \OC::$server->getLogger()->info('Cleaning up after user ' . $uid,
+            ['app' => 'user_ldap']);
+
+        $this->access->getUserMapper()->unmap($uid); // we don't emit unassign signals here, since it is implicit to delete signals fired from core
+        $this->access->userManager->invalidate($uid);
+        $this->access->connection->clearCache();
+        return true;
+    }
+
+    /**
+     * get the user's home directory
+     *
+     * @param string $uid the username
+     * @return bool|string
+     * @throws NoUserException
+     * @throws \Exception
+     */
+    public function getHome($uid) {
+        // user Exists check required as it is not done in user proxy!
+        if (!$this->userExists($uid)) {
+            return false;
+        }
+
+        if ($this->userPluginManager->implementsActions(Backend::GET_HOME)) {
+            return $this->userPluginManager->getHome($uid);
+        }
+
+        $cacheKey = 'getHome'.$uid;
+        $path = $this->access->connection->getFromCache($cacheKey);
+        if (!is_null($path)) {
+            return $path;
+        }
+
+        // early return path if it is a deleted user
+        $user = $this->access->userManager->get($uid);
+        if ($user instanceof User || $user instanceof OfflineUser) {
+            $path = $user->getHomePath() ?: false;
+        } else {
+            throw new NoUserException($uid . ' is not a valid user anymore');
+        }
+
+        $this->access->cacheUserHome($uid, $path);
+        return $path;
+    }
+
+    /**
+     * get display name of the user
+     * @param string $uid user ID of the user
+     * @return string|false display name
+     */
+    public function getDisplayName($uid) {
+        if ($this->userPluginManager->implementsActions(Backend::GET_DISPLAYNAME)) {
+            return $this->userPluginManager->getDisplayName($uid);
+        }
+
+        if (!$this->userExists($uid)) {
+            return false;
+        }
+
+        $cacheKey = 'getDisplayName'.$uid;
+        if (!is_null($displayName = $this->access->connection->getFromCache($cacheKey))) {
+            return $displayName;
+        }
+
+        //Check whether the display name is configured to have a 2nd feature
+        $additionalAttribute = $this->access->connection->ldapUserDisplayName2;
+        $displayName2 = '';
+        if ($additionalAttribute !== '') {
+            $displayName2 = $this->access->readAttribute(
+                $this->access->username2dn($uid),
+                $additionalAttribute);
+        }
+
+        $displayName = $this->access->readAttribute(
+            $this->access->username2dn($uid),
+            $this->access->connection->ldapUserDisplayName);
+
+        if ($displayName && (count($displayName) > 0)) {
+            $displayName = $displayName[0];
+
+            if (is_array($displayName2)) {
+                $displayName2 = count($displayName2) > 0 ? $displayName2[0] : '';
+            }
+
+            $user = $this->access->userManager->get($uid);
+            if ($user instanceof User) {
+                $displayName = $user->composeAndStoreDisplayName($displayName, $displayName2);
+                $this->access->connection->writeToCache($cacheKey, $displayName);
+            }
+            if ($user instanceof OfflineUser) {
+                /** @var OfflineUser $user*/
+                $displayName = $user->getDisplayName();
+            }
+            return $displayName;
+        }
+
+        return null;
+    }
+
+    /**
+     * set display name of the user
+     * @param string $uid user ID of the user
+     * @param string $displayName new display name of the user
+     * @return string|false display name
+     */
+    public function setDisplayName($uid, $displayName) {
+        if ($this->userPluginManager->implementsActions(Backend::SET_DISPLAYNAME)) {
+            $this->userPluginManager->setDisplayName($uid, $displayName);
+            $this->access->cacheUserDisplayName($uid, $displayName);
+            return $displayName;
+        }
+        return false;
+    }
+
+    /**
+     * Get a list of all display names
+     *
+     * @param string $search
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null) {
+        $cacheKey = 'getDisplayNames-'.$search.'-'.$limit.'-'.$offset;
+        if (!is_null($displayNames = $this->access->connection->getFromCache($cacheKey))) {
+            return $displayNames;
+        }
+
+        $displayNames = [];
+        $users = $this->getUsers($search, $limit, $offset);
+        foreach ($users as $user) {
+            $displayNames[$user] = $this->getDisplayName($user);
+        }
+        $this->access->connection->writeToCache($cacheKey, $displayNames);
+        return $displayNames;
+    }
+
+    /**
+     * Check if backend implements actions
+     * @param int $actions bitwise-or'ed actions
+     * @return boolean
+     *
+     * Returns the supported actions as int to be
+     * compared with \OC\User\Backend::CREATE_USER etc.
+     */
+    public function implementsActions($actions) {
+        return (bool)((Backend::CHECK_PASSWORD
+            | Backend::GET_HOME
+            | Backend::GET_DISPLAYNAME
+            | (($this->access->connection->ldapUserAvatarRule !== 'none') ? Backend::PROVIDE_AVATAR : 0)
+            | Backend::COUNT_USERS
+            | (((int)$this->access->connection->turnOnPasswordChange === 1)? Backend::SET_PASSWORD :0)
+            | $this->userPluginManager->getImplementedActions())
+            & $actions);
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasUserListings() {
+        return true;
+    }
+
+    /**
+     * counts the users in LDAP
+     *
+     * @return int|bool
+     */
+    public function countUsers() {
+        if ($this->userPluginManager->implementsActions(Backend::COUNT_USERS)) {
+            return $this->userPluginManager->countUsers();
+        }
+
+        $filter = $this->access->getFilterForUserCount();
+        $cacheKey = 'countUsers-'.$filter;
+        if (!is_null($entries = $this->access->connection->getFromCache($cacheKey))) {
+            return $entries;
+        }
+        $entries = $this->access->countUsers($filter);
+        $this->access->connection->writeToCache($cacheKey, $entries);
+        return $entries;
+    }
+
+    /**
+     * Backend name to be shown in user management
+     * @return string the name of the backend to be shown
+     */
+    public function getBackendName() {
+        return 'LDAP';
+    }
+
+    /**
+     * Return access for LDAP interaction.
+     * @param string $uid
+     * @return Access instance of Access for LDAP interaction
+     */
+    public function getLDAPAccess($uid) {
+        return $this->access;
+    }
+
+    /**
+     * Return LDAP connection resource from a cloned connection.
+     * The cloned connection needs to be closed manually.
+     * of the current access.
+     * @param string $uid
+     * @return resource of the LDAP connection
+     */
+    public function getNewLDAPConnection($uid) {
+        $connection = clone $this->access->getConnection();
+        return $connection->getConnectionResource();
+    }
+
+    /**
+     * create new user
+     * @param string $username username of the new user
+     * @param string $password password of the new user
+     * @throws \UnexpectedValueException
+     * @return bool
+     */
+    public function createUser($username, $password) {
+        if ($this->userPluginManager->implementsActions(Backend::CREATE_USER)) {
+            if ($dn = $this->userPluginManager->createUser($username, $password)) {
+                if (is_string($dn)) {
+                    // the NC user creation work flow requires a know user id up front
+                    $uuid = $this->access->getUUID($dn, true);
+                    if (is_string($uuid)) {
+                        $this->access->mapAndAnnounceIfApplicable(
+                            $this->access->getUserMapper(),
+                            $dn,
+                            $username,
+                            $uuid,
+                            true
+                        );
+                        $this->access->cacheUserExists($username);
+                    } else {
+                        \OC::$server->getLogger()->warning(
+                            'Failed to map created LDAP user with userid {userid}, because UUID could not be determined',
+                            [
+                                'app' => 'user_ldap',
+                                'userid' => $username,
+                            ]
+                        );
+                    }
+                } else {
+                    throw new \UnexpectedValueException("LDAP Plugin: Method createUser changed to return the user DN instead of boolean.");
+                }
+            }
+            return (bool) $dn;
+        }
+        return false;
+    }
 }

apps/user_ldap/lib/User_Proxy.php

Indentation +323 added lines, -323 removed lines

@@ -38,352 +38,352 @@
 use OCP\Notification\IManager as INotificationManager;
 
 class User_Proxy extends Proxy implements \OCP\IUserBackend, \OCP\UserInterface, IUserLDAP {
-	private $backends = [];
-	/** @var User_LDAP */
-	private $refBackend = null;
+    private $backends = [];
+    /** @var User_LDAP */
+    private $refBackend = null;
 
-	public function __construct(
-		Helper $helper,
-		ILDAPWrapper $ldap,
-		IConfig $ocConfig,
-		INotificationManager $notificationManager,
-		IUserSession $userSession,
-		UserPluginManager $userPluginManager
-	) {
-		parent::__construct($ldap);
-		$serverConfigPrefixes = $helper->getServerConfigurationPrefixes(true);
-		foreach ($serverConfigPrefixes as $configPrefix) {
-			$this->backends[$configPrefix] =
-				new User_LDAP($this->getAccess($configPrefix), $ocConfig, $notificationManager, $userSession, $userPluginManager);
+    public function __construct(
+        Helper $helper,
+        ILDAPWrapper $ldap,
+        IConfig $ocConfig,
+        INotificationManager $notificationManager,
+        IUserSession $userSession,
+        UserPluginManager $userPluginManager
+    ) {
+        parent::__construct($ldap);
+        $serverConfigPrefixes = $helper->getServerConfigurationPrefixes(true);
+        foreach ($serverConfigPrefixes as $configPrefix) {
+            $this->backends[$configPrefix] =
+                new User_LDAP($this->getAccess($configPrefix), $ocConfig, $notificationManager, $userSession, $userPluginManager);
 
-			if (is_null($this->refBackend)) {
-				$this->refBackend = &$this->backends[$configPrefix];
-			}
-		}
-	}
+            if (is_null($this->refBackend)) {
+                $this->refBackend = &$this->backends[$configPrefix];
+            }
+        }
+    }
 
-	/**
-	 * Tries the backends one after the other until a positive result is returned from the specified method
-	 *
-	 * @param string $id the uid connected to the request
-	 * @param string $method the method of the user backend that shall be called
-	 * @param array $parameters an array of parameters to be passed
-	 * @return mixed the result of the method or false
-	 */
-	protected function walkBackends($id, $method, $parameters) {
-		$uid = $id;
-		$cacheKey = $this->getUserCacheKey($uid);
-		foreach ($this->backends as $configPrefix => $backend) {
-			$instance = $backend;
-			if (!method_exists($instance, $method)
-				&& method_exists($this->getAccess($configPrefix), $method)) {
-				$instance = $this->getAccess($configPrefix);
-			}
-			if ($result = call_user_func_array([$instance, $method], $parameters)) {
-				if (!$this->isSingleBackend()) {
-					$this->writeToCache($cacheKey, $configPrefix);
-				}
-				return $result;
-			}
-		}
-		return false;
-	}
+    /**
+     * Tries the backends one after the other until a positive result is returned from the specified method
+     *
+     * @param string $id the uid connected to the request
+     * @param string $method the method of the user backend that shall be called
+     * @param array $parameters an array of parameters to be passed
+     * @return mixed the result of the method or false
+     */
+    protected function walkBackends($id, $method, $parameters) {
+        $uid = $id;
+        $cacheKey = $this->getUserCacheKey($uid);
+        foreach ($this->backends as $configPrefix => $backend) {
+            $instance = $backend;
+            if (!method_exists($instance, $method)
+                && method_exists($this->getAccess($configPrefix), $method)) {
+                $instance = $this->getAccess($configPrefix);
+            }
+            if ($result = call_user_func_array([$instance, $method], $parameters)) {
+                if (!$this->isSingleBackend()) {
+                    $this->writeToCache($cacheKey, $configPrefix);
+                }
+                return $result;
+            }
+        }
+        return false;
+    }
 
-	/**
-	 * Asks the backend connected to the server that supposely takes care of the uid from the request.
-	 *
-	 * @param string $id the uid connected to the request
-	 * @param string $method the method of the user backend that shall be called
-	 * @param array $parameters an array of parameters to be passed
-	 * @param mixed $passOnWhen the result matches this variable
-	 * @return mixed the result of the method or false
-	 */
-	protected function callOnLastSeenOn($id, $method, $parameters, $passOnWhen) {
-		$uid = $id;
-		$cacheKey = $this->getUserCacheKey($uid);
-		$prefix = $this->getFromCache($cacheKey);
-		//in case the uid has been found in the past, try this stored connection first
-		if (!is_null($prefix)) {
-			if (isset($this->backends[$prefix])) {
-				$instance = $this->backends[$prefix];
-				if (!method_exists($instance, $method)
-					&& method_exists($this->getAccess($prefix), $method)) {
-					$instance = $this->getAccess($prefix);
-				}
-				$result = call_user_func_array([$instance, $method], $parameters);
-				if ($result === $passOnWhen) {
-					//not found here, reset cache to null if user vanished
-					//because sometimes methods return false with a reason
-					$userExists = call_user_func_array(
-						[$this->backends[$prefix], 'userExistsOnLDAP'],
-						[$uid]
-					);
-					if (!$userExists) {
-						$this->writeToCache($cacheKey, null);
-					}
-				}
-				return $result;
-			}
-		}
-		return false;
-	}
+    /**
+     * Asks the backend connected to the server that supposely takes care of the uid from the request.
+     *
+     * @param string $id the uid connected to the request
+     * @param string $method the method of the user backend that shall be called
+     * @param array $parameters an array of parameters to be passed
+     * @param mixed $passOnWhen the result matches this variable
+     * @return mixed the result of the method or false
+     */
+    protected function callOnLastSeenOn($id, $method, $parameters, $passOnWhen) {
+        $uid = $id;
+        $cacheKey = $this->getUserCacheKey($uid);
+        $prefix = $this->getFromCache($cacheKey);
+        //in case the uid has been found in the past, try this stored connection first
+        if (!is_null($prefix)) {
+            if (isset($this->backends[$prefix])) {
+                $instance = $this->backends[$prefix];
+                if (!method_exists($instance, $method)
+                    && method_exists($this->getAccess($prefix), $method)) {
+                    $instance = $this->getAccess($prefix);
+                }
+                $result = call_user_func_array([$instance, $method], $parameters);
+                if ($result === $passOnWhen) {
+                    //not found here, reset cache to null if user vanished
+                    //because sometimes methods return false with a reason
+                    $userExists = call_user_func_array(
+                        [$this->backends[$prefix], 'userExistsOnLDAP'],
+                        [$uid]
+                    );
+                    if (!$userExists) {
+                        $this->writeToCache($cacheKey, null);
+                    }
+                }
+                return $result;
+            }
+        }
+        return false;
+    }
 
-	protected function activeBackends(): int {
-		return count($this->backends);
-	}
+    protected function activeBackends(): int {
+        return count($this->backends);
+    }
 
-	/**
-	 * Check if backend implements actions
-	 *
-	 * @param int $actions bitwise-or'ed actions
-	 * @return boolean
-	 *
-	 * Returns the supported actions as int to be
-	 * compared with \OC\User\Backend::CREATE_USER etc.
-	 */
-	public function implementsActions($actions) {
-		//it's the same across all our user backends obviously
-		return $this->refBackend->implementsActions($actions);
-	}
+    /**
+     * Check if backend implements actions
+     *
+     * @param int $actions bitwise-or'ed actions
+     * @return boolean
+     *
+     * Returns the supported actions as int to be
+     * compared with \OC\User\Backend::CREATE_USER etc.
+     */
+    public function implementsActions($actions) {
+        //it's the same across all our user backends obviously
+        return $this->refBackend->implementsActions($actions);
+    }
 
-	/**
-	 * Backend name to be shown in user management
-	 *
-	 * @return string the name of the backend to be shown
-	 */
-	public function getBackendName() {
-		return $this->refBackend->getBackendName();
-	}
+    /**
+     * Backend name to be shown in user management
+     *
+     * @return string the name of the backend to be shown
+     */
+    public function getBackendName() {
+        return $this->refBackend->getBackendName();
+    }
 
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param null|int $limit
-	 * @param null|int $offset
-	 * @return string[] an array of all uids
-	 */
-	public function getUsers($search = '', $limit = 10, $offset = 0) {
-		//we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
-		$users = [];
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->getUsers($search, $limit, $offset);
-			if (is_array($backendUsers)) {
-				$users = array_merge($users, $backendUsers);
-			}
-		}
-		return $users;
-	}
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param null|int $limit
+     * @param null|int $offset
+     * @return string[] an array of all uids
+     */
+    public function getUsers($search = '', $limit = 10, $offset = 0) {
+        //we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
+        $users = [];
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->getUsers($search, $limit, $offset);
+            if (is_array($backendUsers)) {
+                $users = array_merge($users, $backendUsers);
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * check if a user exists
-	 *
-	 * @param string $uid the username
-	 * @return boolean
-	 */
-	public function userExists($uid) {
-		$existsOnLDAP = false;
-		$existsLocally = $this->handleRequest($uid, 'userExists', [$uid]);
-		if ($existsLocally) {
-			$existsOnLDAP = $this->userExistsOnLDAP($uid);
-		}
-		if ($existsLocally && !$existsOnLDAP) {
-			try {
-				$user = $this->getLDAPAccess($uid)->userManager->get($uid);
-				if ($user instanceof User) {
-					$user->markUser();
-				}
-			} catch (\Exception $e) {
-				// ignore
-			}
-		}
-		return $existsLocally;
-	}
+    /**
+     * check if a user exists
+     *
+     * @param string $uid the username
+     * @return boolean
+     */
+    public function userExists($uid) {
+        $existsOnLDAP = false;
+        $existsLocally = $this->handleRequest($uid, 'userExists', [$uid]);
+        if ($existsLocally) {
+            $existsOnLDAP = $this->userExistsOnLDAP($uid);
+        }
+        if ($existsLocally && !$existsOnLDAP) {
+            try {
+                $user = $this->getLDAPAccess($uid)->userManager->get($uid);
+                if ($user instanceof User) {
+                    $user->markUser();
+                }
+            } catch (\Exception $e) {
+                // ignore
+            }
+        }
+        return $existsLocally;
+    }
 
-	/**
-	 * check if a user exists on LDAP
-	 *
-	 * @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
-	 * name or an instance of that user
-	 * @return boolean
-	 */
-	public function userExistsOnLDAP($user) {
-		$id = ($user instanceof User) ? $user->getUsername() : $user;
-		return $this->handleRequest($id, 'userExistsOnLDAP', [$user]);
-	}
+    /**
+     * check if a user exists on LDAP
+     *
+     * @param string|\OCA\User_LDAP\User\User $user either the Nextcloud user
+     * name or an instance of that user
+     * @return boolean
+     */
+    public function userExistsOnLDAP($user) {
+        $id = ($user instanceof User) ? $user->getUsername() : $user;
+        return $this->handleRequest($id, 'userExistsOnLDAP', [$user]);
+    }
 
-	/**
-	 * Check if the password is correct
-	 *
-	 * @param string $uid The username
-	 * @param string $password The password
-	 * @return bool
-	 *
-	 * Check if the password is correct without logging in the user
-	 */
-	public function checkPassword($uid, $password) {
-		return $this->handleRequest($uid, 'checkPassword', [$uid, $password]);
-	}
+    /**
+     * Check if the password is correct
+     *
+     * @param string $uid The username
+     * @param string $password The password
+     * @return bool
+     *
+     * Check if the password is correct without logging in the user
+     */
+    public function checkPassword($uid, $password) {
+        return $this->handleRequest($uid, 'checkPassword', [$uid, $password]);
+    }
 
-	/**
-	 * returns the username for the given login name, if available
-	 *
-	 * @param string $loginName
-	 * @return string|false
-	 */
-	public function loginName2UserName($loginName) {
-		$id = 'LOGINNAME,' . $loginName;
-		return $this->handleRequest($id, 'loginName2UserName', [$loginName]);
-	}
+    /**
+     * returns the username for the given login name, if available
+     *
+     * @param string $loginName
+     * @return string|false
+     */
+    public function loginName2UserName($loginName) {
+        $id = 'LOGINNAME,' . $loginName;
+        return $this->handleRequest($id, 'loginName2UserName', [$loginName]);
+    }
 
-	/**
-	 * returns the username for the given LDAP DN, if available
-	 *
-	 * @param string $dn
-	 * @return string|false with the username
-	 */
-	public function dn2UserName($dn) {
-		$id = 'DN,' . $dn;
-		return $this->handleRequest($id, 'dn2UserName', [$dn]);
-	}
+    /**
+     * returns the username for the given LDAP DN, if available
+     *
+     * @param string $dn
+     * @return string|false with the username
+     */
+    public function dn2UserName($dn) {
+        $id = 'DN,' . $dn;
+        return $this->handleRequest($id, 'dn2UserName', [$dn]);
+    }
 
-	/**
-	 * get the user's home directory
-	 *
-	 * @param string $uid the username
-	 * @return boolean
-	 */
-	public function getHome($uid) {
-		return $this->handleRequest($uid, 'getHome', [$uid]);
-	}
+    /**
+     * get the user's home directory
+     *
+     * @param string $uid the username
+     * @return boolean
+     */
+    public function getHome($uid) {
+        return $this->handleRequest($uid, 'getHome', [$uid]);
+    }
 
-	/**
-	 * get display name of the user
-	 *
-	 * @param string $uid user ID of the user
-	 * @return string display name
-	 */
-	public function getDisplayName($uid) {
-		return $this->handleRequest($uid, 'getDisplayName', [$uid]);
-	}
+    /**
+     * get display name of the user
+     *
+     * @param string $uid user ID of the user
+     * @return string display name
+     */
+    public function getDisplayName($uid) {
+        return $this->handleRequest($uid, 'getDisplayName', [$uid]);
+    }
 
-	/**
-	 * set display name of the user
-	 *
-	 * @param string $uid user ID of the user
-	 * @param string $displayName new display name
-	 * @return string display name
-	 */
-	public function setDisplayName($uid, $displayName) {
-		return $this->handleRequest($uid, 'setDisplayName', [$uid, $displayName]);
-	}
+    /**
+     * set display name of the user
+     *
+     * @param string $uid user ID of the user
+     * @param string $displayName new display name
+     * @return string display name
+     */
+    public function setDisplayName($uid, $displayName) {
+        return $this->handleRequest($uid, 'setDisplayName', [$uid, $displayName]);
+    }
 
-	/**
-	 * checks whether the user is allowed to change his avatar in Nextcloud
-	 *
-	 * @param string $uid the Nextcloud user name
-	 * @return boolean either the user can or cannot
-	 */
-	public function canChangeAvatar($uid) {
-		return $this->handleRequest($uid, 'canChangeAvatar', [$uid], true);
-	}
+    /**
+     * checks whether the user is allowed to change his avatar in Nextcloud
+     *
+     * @param string $uid the Nextcloud user name
+     * @return boolean either the user can or cannot
+     */
+    public function canChangeAvatar($uid) {
+        return $this->handleRequest($uid, 'canChangeAvatar', [$uid], true);
+    }
 
-	/**
-	 * Get a list of all display names and user ids.
-	 *
-	 * @param string $search
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null) {
-		//we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
-		$users = [];
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->getDisplayNames($search, $limit, $offset);
-			if (is_array($backendUsers)) {
-				$users = $users + $backendUsers;
-			}
-		}
-		return $users;
-	}
+    /**
+     * Get a list of all display names and user ids.
+     *
+     * @param string $search
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null) {
+        //we do it just as the /OC_User implementation: do not play around with limit and offset but ask all backends
+        $users = [];
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->getDisplayNames($search, $limit, $offset);
+            if (is_array($backendUsers)) {
+                $users = $users + $backendUsers;
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * delete a user
-	 *
-	 * @param string $uid The username of the user to delete
-	 * @return bool
-	 *
-	 * Deletes a user
-	 */
-	public function deleteUser($uid) {
-		return $this->handleRequest($uid, 'deleteUser', [$uid]);
-	}
+    /**
+     * delete a user
+     *
+     * @param string $uid The username of the user to delete
+     * @return bool
+     *
+     * Deletes a user
+     */
+    public function deleteUser($uid) {
+        return $this->handleRequest($uid, 'deleteUser', [$uid]);
+    }
 
-	/**
-	 * Set password
-	 *
-	 * @param string $uid The username
-	 * @param string $password The new password
-	 * @return bool
-	 *
-	 */
-	public function setPassword($uid, $password) {
-		return $this->handleRequest($uid, 'setPassword', [$uid, $password]);
-	}
+    /**
+     * Set password
+     *
+     * @param string $uid The username
+     * @param string $password The new password
+     * @return bool
+     *
+     */
+    public function setPassword($uid, $password) {
+        return $this->handleRequest($uid, 'setPassword', [$uid, $password]);
+    }
 
-	/**
-	 * @return bool
-	 */
-	public function hasUserListings() {
-		return $this->refBackend->hasUserListings();
-	}
+    /**
+     * @return bool
+     */
+    public function hasUserListings() {
+        return $this->refBackend->hasUserListings();
+    }
 
-	/**
-	 * Count the number of users
-	 *
-	 * @return int|bool
-	 */
-	public function countUsers() {
-		$users = false;
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->countUsers();
-			if ($backendUsers !== false) {
-				$users += $backendUsers;
-			}
-		}
-		return $users;
-	}
+    /**
+     * Count the number of users
+     *
+     * @return int|bool
+     */
+    public function countUsers() {
+        $users = false;
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->countUsers();
+            if ($backendUsers !== false) {
+                $users += $backendUsers;
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * Return access for LDAP interaction.
-	 *
-	 * @param string $uid
-	 * @return Access instance of Access for LDAP interaction
-	 */
-	public function getLDAPAccess($uid) {
-		return $this->handleRequest($uid, 'getLDAPAccess', [$uid]);
-	}
+    /**
+     * Return access for LDAP interaction.
+     *
+     * @param string $uid
+     * @return Access instance of Access for LDAP interaction
+     */
+    public function getLDAPAccess($uid) {
+        return $this->handleRequest($uid, 'getLDAPAccess', [$uid]);
+    }
 
-	/**
-	 * Return a new LDAP connection for the specified user.
-	 * The connection needs to be closed manually.
-	 *
-	 * @param string $uid
-	 * @return resource of the LDAP connection
-	 */
-	public function getNewLDAPConnection($uid) {
-		return $this->handleRequest($uid, 'getNewLDAPConnection', [$uid]);
-	}
+    /**
+     * Return a new LDAP connection for the specified user.
+     * The connection needs to be closed manually.
+     *
+     * @param string $uid
+     * @return resource of the LDAP connection
+     */
+    public function getNewLDAPConnection($uid) {
+        return $this->handleRequest($uid, 'getNewLDAPConnection', [$uid]);
+    }
 
-	/**
-	 * Creates a new user in LDAP
-	 *
-	 * @param $username
-	 * @param $password
-	 * @return bool
-	 */
-	public function createUser($username, $password) {
-		return $this->handleRequest($username, 'createUser', [$username, $password]);
-	}
+    /**
+     * Creates a new user in LDAP
+     *
+     * @param $username
+     * @param $password
+     * @return bool
+     */
+    public function createUser($username, $password) {
+        return $this->handleRequest($username, 'createUser', [$username, $password]);
+    }
 }

core/Migrations/Version21000Date20210309185127.php

Indentation +16 added lines, -16 removed lines

@@ -31,22 +31,22 @@
 use OCP\Migration\SimpleMigrationStep;
 
 class Version21000Date20210309185127 extends SimpleMigrationStep {
-	/**
-	 * @param IOutput $output
-	 * @param Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
-	 * @param array $options
-	 * @return null|ISchemaWrapper
-	 */
-	public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper {
-		/** @var ISchemaWrapper $schema */
-		$schema = $schemaClosure();
+    /**
+     * @param IOutput $output
+     * @param Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
+     * @param array $options
+     * @return null|ISchemaWrapper
+     */
+    public function changeSchema(IOutput $output, Closure $schemaClosure, array $options): ?ISchemaWrapper {
+        /** @var ISchemaWrapper $schema */
+        $schema = $schemaClosure();
 
-		$table = $schema->getTable('known_users');
-		if (!$table->hasIndex('ku_known_user')) {
-			$table->addIndex(['known_user'], 'ku_known_user');
-			return $schema;
-		}
+        $table = $schema->getTable('known_users');
+        if (!$table->hasIndex('ku_known_user')) {
+            $table->addIndex(['known_user'], 'ku_known_user');
+            return $schema;
+        }
 
-		return null;
-	}
+        return null;
+    }
 }

lib/public/User/Backend/ISearchKnownUsersBackend.php

Indentation +9 added lines, -9 removed lines

@@ -31,13 +31,13 @@
  */
 interface ISearchKnownUsersBackend {
 
-	/**
-	 * @param string $searcher
-	 * @param string $pattern
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array
-	 * @since 21.0.1
-	 */
-	public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array;
+    /**
+     * @param string $searcher
+     * @param string $pattern
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array
+     * @since 21.0.1
+     */
+    public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array;
 }

lib/public/User/Backend/IGetRealUIDBackend.php

Indentation +12 added lines, -12 removed lines

@@ -31,16 +31,16 @@
  */
 interface IGetRealUIDBackend {
 
-	/**
-	 * Some backends accept different UIDs than what is the internal UID to be used.
-	 * For example the database backend accepts different cased UIDs in all the functions
-	 * but the internal UID that is to be used should be correctly cased.
-	 *
-	 * This little function makes sure that the used UID will be correct hen using the user object
-	 *
-	 * @since 17.0.0
-	 * @param string $uid
-	 * @return string
-	 */
-	public function getRealUID(string $uid): string;
+    /**
+     * Some backends accept different UIDs than what is the internal UID to be used.
+     * For example the database backend accepts different cased UIDs in all the functions
+     * but the internal UID that is to be used should be correctly cased.
+     *
+     * This little function makes sure that the used UID will be correct hen using the user object
+     *
+     * @since 17.0.0
+     * @param string $uid
+     * @return string
+     */
+    public function getRealUID(string $uid): string;
 }

lib/public/IUserManager.php

Indentation +155 added lines, -155 removed lines

@@ -47,159 +47,159 @@
  * @since 8.0.0
  */
 interface IUserManager {
-	/**
-	 * register a user backend
-	 *
-	 * @param \OCP\UserInterface $backend
-	 * @since 8.0.0
-	 */
-	public function registerBackend($backend);
-
-	/**
-	 * Get the active backends
-	 * @return \OCP\UserInterface[]
-	 * @since 8.0.0
-	 */
-	public function getBackends();
-
-	/**
-	 * remove a user backend
-	 *
-	 * @param \OCP\UserInterface $backend
-	 * @since 8.0.0
-	 */
-	public function removeBackend($backend);
-
-	/**
-	 * remove all user backends
-	 * @since 8.0.0
-	 */
-	public function clearBackends() ;
-
-	/**
-	 * get a user by user id
-	 *
-	 * @param string $uid
-	 * @return \OCP\IUser|null Either the user or null if the specified user does not exist
-	 * @since 8.0.0
-	 */
-	public function get($uid);
-
-	/**
-	 * check if a user exists
-	 *
-	 * @param string $uid
-	 * @return bool
-	 * @since 8.0.0
-	 */
-	public function userExists($uid);
-
-	/**
-	 * Check if the password is valid for the user
-	 *
-	 * @param string $loginName
-	 * @param string $password
-	 * @return mixed the User object on success, false otherwise
-	 * @since 8.0.0
-	 */
-	public function checkPassword($loginName, $password);
-
-	/**
-	 * search by user id
-	 *
-	 * @param string $pattern
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\IUser[]
-	 * @since 8.0.0
-	 */
-	public function search($pattern, $limit = null, $offset = null);
-
-	/**
-	 * search by displayName
-	 *
-	 * @param string $pattern
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\IUser[]
-	 * @since 8.0.0
-	 */
-	public function searchDisplayName($pattern, $limit = null, $offset = null);
-
-	/**
-	 * Search known users (from phonebook sync) by displayName
-	 *
-	 * @param string $searcher
-	 * @param string $pattern
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return IUser[]
-	 * @since 21.0.1
-	 */
-	public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array;
-
-	/**
-	 * @param string $uid
-	 * @param string $password
-	 * @throws \InvalidArgumentException
-	 * @return bool|\OCP\IUser the created user or false
-	 * @since 8.0.0
-	 */
-	public function createUser($uid, $password);
-
-	/**
-	 * @param string $uid
-	 * @param string $password
-	 * @param UserInterface $backend
-	 * @return IUser|null
-	 * @throws \InvalidArgumentException
-	 * @since 12.0.0
-	 */
-	public function createUserFromBackend($uid, $password, UserInterface $backend);
-
-	/**
-	 * returns how many users per backend exist (if supported by backend)
-	 *
-	 * @return array an array of backend class as key and count number as value
-	 * @since 8.0.0
-	 */
-	public function countUsers();
-
-	/**
-	 * @param \Closure $callback
-	 * @psalm-param \Closure(\OCP\IUser):void $callback
-	 * @param string $search
-	 * @since 9.0.0
-	 */
-	public function callForAllUsers(\Closure $callback, $search = '');
-
-	/**
-	 * returns how many users have logged in once
-	 *
-	 * @return int
-	 * @since 11.0.0
-	 */
-	public function countDisabledUsers();
-
-	/**
-	 * returns how many users have logged in once
-	 *
-	 * @return int
-	 * @since 11.0.0
-	 */
-	public function countSeenUsers();
-
-	/**
-	 * @param \Closure $callback
-	 * @psalm-param \Closure(\OCP\IUser):?bool $callback
-	 * @since 11.0.0
-	 */
-	public function callForSeenUsers(\Closure $callback);
-
-	/**
-	 * @param string $email
-	 * @return IUser[]
-	 * @since 9.1.0
-	 */
-	public function getByEmail($email);
+    /**
+     * register a user backend
+     *
+     * @param \OCP\UserInterface $backend
+     * @since 8.0.0
+     */
+    public function registerBackend($backend);
+
+    /**
+     * Get the active backends
+     * @return \OCP\UserInterface[]
+     * @since 8.0.0
+     */
+    public function getBackends();
+
+    /**
+     * remove a user backend
+     *
+     * @param \OCP\UserInterface $backend
+     * @since 8.0.0
+     */
+    public function removeBackend($backend);
+
+    /**
+     * remove all user backends
+     * @since 8.0.0
+     */
+    public function clearBackends() ;
+
+    /**
+     * get a user by user id
+     *
+     * @param string $uid
+     * @return \OCP\IUser|null Either the user or null if the specified user does not exist
+     * @since 8.0.0
+     */
+    public function get($uid);
+
+    /**
+     * check if a user exists
+     *
+     * @param string $uid
+     * @return bool
+     * @since 8.0.0
+     */
+    public function userExists($uid);
+
+    /**
+     * Check if the password is valid for the user
+     *
+     * @param string $loginName
+     * @param string $password
+     * @return mixed the User object on success, false otherwise
+     * @since 8.0.0
+     */
+    public function checkPassword($loginName, $password);
+
+    /**
+     * search by user id
+     *
+     * @param string $pattern
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\IUser[]
+     * @since 8.0.0
+     */
+    public function search($pattern, $limit = null, $offset = null);
+
+    /**
+     * search by displayName
+     *
+     * @param string $pattern
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\IUser[]
+     * @since 8.0.0
+     */
+    public function searchDisplayName($pattern, $limit = null, $offset = null);
+
+    /**
+     * Search known users (from phonebook sync) by displayName
+     *
+     * @param string $searcher
+     * @param string $pattern
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return IUser[]
+     * @since 21.0.1
+     */
+    public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array;
+
+    /**
+     * @param string $uid
+     * @param string $password
+     * @throws \InvalidArgumentException
+     * @return bool|\OCP\IUser the created user or false
+     * @since 8.0.0
+     */
+    public function createUser($uid, $password);
+
+    /**
+     * @param string $uid
+     * @param string $password
+     * @param UserInterface $backend
+     * @return IUser|null
+     * @throws \InvalidArgumentException
+     * @since 12.0.0
+     */
+    public function createUserFromBackend($uid, $password, UserInterface $backend);
+
+    /**
+     * returns how many users per backend exist (if supported by backend)
+     *
+     * @return array an array of backend class as key and count number as value
+     * @since 8.0.0
+     */
+    public function countUsers();
+
+    /**
+     * @param \Closure $callback
+     * @psalm-param \Closure(\OCP\IUser):void $callback
+     * @param string $search
+     * @since 9.0.0
+     */
+    public function callForAllUsers(\Closure $callback, $search = '');
+
+    /**
+     * returns how many users have logged in once
+     *
+     * @return int
+     * @since 11.0.0
+     */
+    public function countDisabledUsers();
+
+    /**
+     * returns how many users have logged in once
+     *
+     * @return int
+     * @since 11.0.0
+     */
+    public function countSeenUsers();
+
+    /**
+     * @param \Closure $callback
+     * @psalm-param \Closure(\OCP\IUser):?bool $callback
+     * @since 11.0.0
+     */
+    public function callForSeenUsers(\Closure $callback);
+
+    /**
+     * @param string $email
+     * @return IUser[]
+     * @since 9.1.0
+     */
+    public function getByEmail($email);
 }

lib/public/UserInterface.php

Indentation +58 added lines, -58 removed lines

@@ -41,68 +41,68 @@
  */
 interface UserInterface {
 
-	/**
-	 * Check if backend implements actions
-	 * @param int $actions bitwise-or'ed actions
-	 * @return boolean
-	 *
-	 * Returns the supported actions as int to be
-	 * compared with \OC\User\Backend::CREATE_USER etc.
-	 * @since 4.5.0
-	 * @deprecated 14.0.0 Switch to the interfaces from OCP\User\Backend
-	 */
-	public function implementsActions($actions);
+    /**
+     * Check if backend implements actions
+     * @param int $actions bitwise-or'ed actions
+     * @return boolean
+     *
+     * Returns the supported actions as int to be
+     * compared with \OC\User\Backend::CREATE_USER etc.
+     * @since 4.5.0
+     * @deprecated 14.0.0 Switch to the interfaces from OCP\User\Backend
+     */
+    public function implementsActions($actions);
 
-	/**
-	 * delete a user
-	 * @param string $uid The username of the user to delete
-	 * @return bool
-	 * @since 4.5.0
-	 */
-	public function deleteUser($uid);
+    /**
+     * delete a user
+     * @param string $uid The username of the user to delete
+     * @return bool
+     * @since 4.5.0
+     */
+    public function deleteUser($uid);
 
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param null|int $limit
-	 * @param null|int $offset
-	 * @return string[] an array of all uids
-	 * @since 4.5.0
-	 */
-	public function getUsers($search = '', $limit = null, $offset = null);
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param null|int $limit
+     * @param null|int $offset
+     * @return string[] an array of all uids
+     * @since 4.5.0
+     */
+    public function getUsers($search = '', $limit = null, $offset = null);
 
-	/**
-	 * check if a user exists
-	 * @param string $uid the username
-	 * @return boolean
-	 * @since 4.5.0
-	 */
-	public function userExists($uid);
+    /**
+     * check if a user exists
+     * @param string $uid the username
+     * @return boolean
+     * @since 4.5.0
+     */
+    public function userExists($uid);
 
-	/**
-	 * get display name of the user
-	 * @param string $uid user ID of the user
-	 * @return string display name
-	 * @since 4.5.0
-	 */
-	public function getDisplayName($uid);
+    /**
+     * get display name of the user
+     * @param string $uid user ID of the user
+     * @return string display name
+     * @since 4.5.0
+     */
+    public function getDisplayName($uid);
 
-	/**
-	 * Get a list of all display names and user ids.
-	 *
-	 * @param string $search
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 * @since 4.5.0
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null);
+    /**
+     * Get a list of all display names and user ids.
+     *
+     * @param string $search
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     * @since 4.5.0
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null);
 
-	/**
-	 * Check if a user list is available or not
-	 * @return boolean if users can be listed or not
-	 * @since 4.5.0
-	 */
-	public function hasUserListings();
+    /**
+     * Check if a user list is available or not
+     * @return boolean if users can be listed or not
+     * @since 4.5.0
+     */
+    public function hasUserListings();
 }

lib/private/User/Database.php

Indentation +459 added lines, -459 removed lines

@@ -78,463 +78,463 @@
  * Class for user management in a SQL Database (e.g. MySQL, SQLite)
  */
 class Database extends ABackend implements
-	ICreateUserBackend,
-			   ISetPasswordBackend,
-			   ISetDisplayNameBackend,
-			   IGetDisplayNameBackend,
-			   ICheckPasswordBackend,
-			   IGetHomeBackend,
-			   ICountUsersBackend,
-			   ISearchKnownUsersBackend,
-			   IGetRealUIDBackend {
-	/** @var CappedMemoryCache */
-	private $cache;
-
-	/** @var IEventDispatcher */
-	private $eventDispatcher;
-
-	/** @var IDBConnection */
-	private $dbConn;
-
-	/** @var string */
-	private $table;
-
-	/**
-	 * \OC\User\Database constructor.
-	 *
-	 * @param IEventDispatcher $eventDispatcher
-	 * @param string $table
-	 */
-	public function __construct($eventDispatcher = null, $table = 'users') {
-		$this->cache = new CappedMemoryCache();
-		$this->table = $table;
-		$this->eventDispatcher = $eventDispatcher ? $eventDispatcher : \OC::$server->query(IEventDispatcher::class);
-	}
-
-	/**
-	 * FIXME: This function should not be required!
-	 */
-	private function fixDI() {
-		if ($this->dbConn === null) {
-			$this->dbConn = \OC::$server->getDatabaseConnection();
-		}
-	}
-
-	/**
-	 * Create a new user
-	 *
-	 * @param string $uid The username of the user to create
-	 * @param string $password The password of the new user
-	 * @return bool
-	 *
-	 * Creates a new user. Basic checking of username is done in OC_User
-	 * itself, not in its subclasses.
-	 */
-	public function createUser(string $uid, string $password): bool {
-		$this->fixDI();
-
-		if (!$this->userExists($uid)) {
-			$this->eventDispatcher->dispatchTyped(new ValidatePasswordPolicyEvent($password));
-
-			$qb = $this->dbConn->getQueryBuilder();
-			$qb->insert($this->table)
-				->values([
-					'uid' => $qb->createNamedParameter($uid),
-					'password' => $qb->createNamedParameter(\OC::$server->getHasher()->hash($password)),
-					'uid_lower' => $qb->createNamedParameter(mb_strtolower($uid)),
-				]);
-
-			$result = $qb->execute();
-
-			// Clear cache
-			unset($this->cache[$uid]);
-
-			return $result ? true : false;
-		}
-
-		return false;
-	}
-
-	/**
-	 * delete a user
-	 *
-	 * @param string $uid The username of the user to delete
-	 * @return bool
-	 *
-	 * Deletes a user
-	 */
-	public function deleteUser($uid) {
-		$this->fixDI();
-
-		// Delete user-group-relation
-		$query = $this->dbConn->getQueryBuilder();
-		$query->delete($this->table)
-			->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
-		$result = $query->execute();
-
-		if (isset($this->cache[$uid])) {
-			unset($this->cache[$uid]);
-		}
-
-		return $result ? true : false;
-	}
-
-	private function updatePassword(string $uid, string $passwordHash): bool {
-		$query = $this->dbConn->getQueryBuilder();
-		$query->update($this->table)
-			->set('password', $query->createNamedParameter($passwordHash))
-			->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
-		$result = $query->execute();
-
-		return $result ? true : false;
-	}
-
-	/**
-	 * Set password
-	 *
-	 * @param string $uid The username
-	 * @param string $password The new password
-	 * @return bool
-	 *
-	 * Change the password of a user
-	 */
-	public function setPassword(string $uid, string $password): bool {
-		$this->fixDI();
-
-		if ($this->userExists($uid)) {
-			$this->eventDispatcher->dispatchTyped(new ValidatePasswordPolicyEvent($password));
-
-			$hasher = \OC::$server->getHasher();
-			$hashedPassword = $hasher->hash($password);
-
-			return $this->updatePassword($uid, $hashedPassword);
-		}
-
-		return false;
-	}
-
-	/**
-	 * Set display name
-	 *
-	 * @param string $uid The username
-	 * @param string $displayName The new display name
-	 * @return bool
-	 *
-	 * Change the display name of a user
-	 */
-	public function setDisplayName(string $uid, string $displayName): bool {
-		$this->fixDI();
-
-		if ($this->userExists($uid)) {
-			$query = $this->dbConn->getQueryBuilder();
-			$query->update($this->table)
-				->set('displayname', $query->createNamedParameter($displayName))
-				->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
-			$query->execute();
-
-			$this->cache[$uid]['displayname'] = $displayName;
-
-			return true;
-		}
-
-		return false;
-	}
-
-	/**
-	 * get display name of the user
-	 *
-	 * @param string $uid user ID of the user
-	 * @return string display name
-	 */
-	public function getDisplayName($uid): string {
-		$uid = (string)$uid;
-		$this->loadUser($uid);
-		return empty($this->cache[$uid]['displayname']) ? $uid : $this->cache[$uid]['displayname'];
-	}
-
-	/**
-	 * Get a list of all display names and user ids.
-	 *
-	 * @param string $search
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array an array of all displayNames (value) and the corresponding uids (key)
-	 */
-	public function getDisplayNames($search = '', $limit = null, $offset = null) {
-		$limit = $this->fixLimit($limit);
-
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-
-		$query->select('uid', 'displayname')
-			->from($this->table, 'u')
-			->leftJoin('u', 'preferences', 'p', $query->expr()->andX(
-				$query->expr()->eq('userid', 'uid'),
-				$query->expr()->eq('appid', $query->expr()->literal('settings')),
-				$query->expr()->eq('configkey', $query->expr()->literal('email')))
-			)
-			// sqlite doesn't like re-using a single named parameter here
-			->where($query->expr()->iLike('uid', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
-			->orWhere($query->expr()->iLike('displayname', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
-			->orWhere($query->expr()->iLike('configvalue', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
-			->orderBy($query->func()->lower('displayname'), 'ASC')
-			->addOrderBy('uid_lower', 'ASC')
-			->setMaxResults($limit)
-			->setFirstResult($offset);
-
-		$result = $query->execute();
-		$displayNames = [];
-		while ($row = $result->fetch()) {
-			$displayNames[(string)$row['uid']] = (string)$row['displayname'];
-		}
-
-		return $displayNames;
-	}
-
-	/**
-	 * @param string $searcher
-	 * @param string $pattern
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return array
-	 * @since 21.0.1
-	 */
-	public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array {
-		$limit = $this->fixLimit($limit);
-
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-
-		$query->select('u.uid', 'u.displayname')
-			->from($this->table, 'u')
-			->leftJoin('u', 'known_users', 'k', $query->expr()->andX(
-				$query->expr()->eq('k.known_user', 'u.uid'),
-				$query->expr()->eq('k.known_to', $query->createNamedParameter($searcher))
-			))
-			->where($query->expr()->eq('k.known_to', $query->createNamedParameter($searcher)))
-			->andWhere($query->expr()->orX(
-				$query->expr()->iLike('u.uid', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%')),
-				$query->expr()->iLike('u.displayname', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%'))
-			))
-			->orderBy('u.displayname', 'ASC')
-			->addOrderBy('u.uid_lower', 'ASC')
-			->setMaxResults($limit)
-			->setFirstResult($offset);
-
-		$result = $query->execute();
-		$displayNames = [];
-		while ($row = $result->fetch()) {
-			$displayNames[(string)$row['uid']] = (string)$row['displayname'];
-		}
-
-		return $displayNames;
-	}
-
-	/**
-	 * Check if the password is correct
-	 *
-	 * @param string $loginName The loginname
-	 * @param string $password The password
-	 * @return string
-	 *
-	 * Check if the password is correct without logging in the user
-	 * returns the user id or false
-	 */
-	public function checkPassword(string $loginName, string $password) {
-		$this->fixDI();
-
-		$qb = $this->dbConn->getQueryBuilder();
-		$qb->select('uid', 'password')
-			->from($this->table)
-			->where(
-				$qb->expr()->eq(
-					'uid_lower', $qb->createNamedParameter(mb_strtolower($loginName))
-				)
-			);
-		$result = $qb->execute();
-		$row = $result->fetch();
-		$result->closeCursor();
-
-		if ($row) {
-			$storedHash = $row['password'];
-			$newHash = '';
-			if (\OC::$server->getHasher()->verify($password, $storedHash, $newHash)) {
-				if (!empty($newHash)) {
-					$this->updatePassword($loginName, $newHash);
-				}
-				return (string)$row['uid'];
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Load an user in the cache
-	 *
-	 * @param string $uid the username
-	 * @return boolean true if user was found, false otherwise
-	 */
-	private function loadUser($uid) {
-		$this->fixDI();
-
-		$uid = (string)$uid;
-		if (!isset($this->cache[$uid])) {
-			//guests $uid could be NULL or ''
-			if ($uid === '') {
-				$this->cache[$uid] = false;
-				return true;
-			}
-
-			$qb = $this->dbConn->getQueryBuilder();
-			$qb->select('uid', 'displayname')
-				->from($this->table)
-				->where(
-					$qb->expr()->eq(
-						'uid_lower', $qb->createNamedParameter(mb_strtolower($uid))
-					)
-				);
-			$result = $qb->execute();
-			$row = $result->fetch();
-			$result->closeCursor();
-
-			$this->cache[$uid] = false;
-
-			// "uid" is primary key, so there can only be a single result
-			if ($row !== false) {
-				$this->cache[$uid]['uid'] = (string)$row['uid'];
-				$this->cache[$uid]['displayname'] = (string)$row['displayname'];
-			} else {
-				return false;
-			}
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get a list of all users
-	 *
-	 * @param string $search
-	 * @param null|int $limit
-	 * @param null|int $offset
-	 * @return string[] an array of all uids
-	 */
-	public function getUsers($search = '', $limit = null, $offset = null) {
-		$limit = $this->fixLimit($limit);
-
-		$users = $this->getDisplayNames($search, $limit, $offset);
-		$userIds = array_map(function ($uid) {
-			return (string)$uid;
-		}, array_keys($users));
-		sort($userIds, SORT_STRING | SORT_FLAG_CASE);
-		return $userIds;
-	}
-
-	/**
-	 * check if a user exists
-	 *
-	 * @param string $uid the username
-	 * @return boolean
-	 */
-	public function userExists($uid) {
-		$this->loadUser($uid);
-		return $this->cache[$uid] !== false;
-	}
-
-	/**
-	 * get the user's home directory
-	 *
-	 * @param string $uid the username
-	 * @return string|false
-	 */
-	public function getHome(string $uid) {
-		if ($this->userExists($uid)) {
-			return \OC::$server->getConfig()->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data') . '/' . $uid;
-		}
-
-		return false;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function hasUserListings() {
-		return true;
-	}
-
-	/**
-	 * counts the users in the database
-	 *
-	 * @return int|bool
-	 */
-	public function countUsers() {
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-		$query->select($query->func()->count('uid'))
-			->from($this->table);
-		$result = $query->execute();
-
-		return $result->fetchOne();
-	}
-
-	/**
-	 * returns the username for the given login name in the correct casing
-	 *
-	 * @param string $loginName
-	 * @return string|false
-	 */
-	public function loginName2UserName($loginName) {
-		if ($this->userExists($loginName)) {
-			return $this->cache[$loginName]['uid'];
-		}
-
-		return false;
-	}
-
-	/**
-	 * Backend name to be shown in user management
-	 *
-	 * @return string the name of the backend to be shown
-	 */
-	public function getBackendName() {
-		return 'Database';
-	}
-
-	public static function preLoginNameUsedAsUserName($param) {
-		if (!isset($param['uid'])) {
-			throw new \Exception('key uid is expected to be set in $param');
-		}
-
-		$backends = \OC::$server->getUserManager()->getBackends();
-		foreach ($backends as $backend) {
-			if ($backend instanceof Database) {
-				/** @var \OC\User\Database $backend */
-				$uid = $backend->loginName2UserName($param['uid']);
-				if ($uid !== false) {
-					$param['uid'] = $uid;
-					return;
-				}
-			}
-		}
-	}
-
-	public function getRealUID(string $uid): string {
-		if (!$this->userExists($uid)) {
-			throw new \RuntimeException($uid . ' does not exist');
-		}
-
-		return $this->cache[$uid]['uid'];
-	}
-
-	private function fixLimit($limit) {
-		if (is_int($limit) && $limit >= 0) {
-			return $limit;
-		}
-
-		return null;
-	}
+    ICreateUserBackend,
+                ISetPasswordBackend,
+                ISetDisplayNameBackend,
+                IGetDisplayNameBackend,
+                ICheckPasswordBackend,
+                IGetHomeBackend,
+                ICountUsersBackend,
+                ISearchKnownUsersBackend,
+                IGetRealUIDBackend {
+    /** @var CappedMemoryCache */
+    private $cache;
+
+    /** @var IEventDispatcher */
+    private $eventDispatcher;
+
+    /** @var IDBConnection */
+    private $dbConn;
+
+    /** @var string */
+    private $table;
+
+    /**
+     * \OC\User\Database constructor.
+     *
+     * @param IEventDispatcher $eventDispatcher
+     * @param string $table
+     */
+    public function __construct($eventDispatcher = null, $table = 'users') {
+        $this->cache = new CappedMemoryCache();
+        $this->table = $table;
+        $this->eventDispatcher = $eventDispatcher ? $eventDispatcher : \OC::$server->query(IEventDispatcher::class);
+    }
+
+    /**
+     * FIXME: This function should not be required!
+     */
+    private function fixDI() {
+        if ($this->dbConn === null) {
+            $this->dbConn = \OC::$server->getDatabaseConnection();
+        }
+    }
+
+    /**
+     * Create a new user
+     *
+     * @param string $uid The username of the user to create
+     * @param string $password The password of the new user
+     * @return bool
+     *
+     * Creates a new user. Basic checking of username is done in OC_User
+     * itself, not in its subclasses.
+     */
+    public function createUser(string $uid, string $password): bool {
+        $this->fixDI();
+
+        if (!$this->userExists($uid)) {
+            $this->eventDispatcher->dispatchTyped(new ValidatePasswordPolicyEvent($password));
+
+            $qb = $this->dbConn->getQueryBuilder();
+            $qb->insert($this->table)
+                ->values([
+                    'uid' => $qb->createNamedParameter($uid),
+                    'password' => $qb->createNamedParameter(\OC::$server->getHasher()->hash($password)),
+                    'uid_lower' => $qb->createNamedParameter(mb_strtolower($uid)),
+                ]);
+
+            $result = $qb->execute();
+
+            // Clear cache
+            unset($this->cache[$uid]);
+
+            return $result ? true : false;
+        }
+
+        return false;
+    }
+
+    /**
+     * delete a user
+     *
+     * @param string $uid The username of the user to delete
+     * @return bool
+     *
+     * Deletes a user
+     */
+    public function deleteUser($uid) {
+        $this->fixDI();
+
+        // Delete user-group-relation
+        $query = $this->dbConn->getQueryBuilder();
+        $query->delete($this->table)
+            ->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
+        $result = $query->execute();
+
+        if (isset($this->cache[$uid])) {
+            unset($this->cache[$uid]);
+        }
+
+        return $result ? true : false;
+    }
+
+    private function updatePassword(string $uid, string $passwordHash): bool {
+        $query = $this->dbConn->getQueryBuilder();
+        $query->update($this->table)
+            ->set('password', $query->createNamedParameter($passwordHash))
+            ->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
+        $result = $query->execute();
+
+        return $result ? true : false;
+    }
+
+    /**
+     * Set password
+     *
+     * @param string $uid The username
+     * @param string $password The new password
+     * @return bool
+     *
+     * Change the password of a user
+     */
+    public function setPassword(string $uid, string $password): bool {
+        $this->fixDI();
+
+        if ($this->userExists($uid)) {
+            $this->eventDispatcher->dispatchTyped(new ValidatePasswordPolicyEvent($password));
+
+            $hasher = \OC::$server->getHasher();
+            $hashedPassword = $hasher->hash($password);
+
+            return $this->updatePassword($uid, $hashedPassword);
+        }
+
+        return false;
+    }
+
+    /**
+     * Set display name
+     *
+     * @param string $uid The username
+     * @param string $displayName The new display name
+     * @return bool
+     *
+     * Change the display name of a user
+     */
+    public function setDisplayName(string $uid, string $displayName): bool {
+        $this->fixDI();
+
+        if ($this->userExists($uid)) {
+            $query = $this->dbConn->getQueryBuilder();
+            $query->update($this->table)
+                ->set('displayname', $query->createNamedParameter($displayName))
+                ->where($query->expr()->eq('uid_lower', $query->createNamedParameter(mb_strtolower($uid))));
+            $query->execute();
+
+            $this->cache[$uid]['displayname'] = $displayName;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * get display name of the user
+     *
+     * @param string $uid user ID of the user
+     * @return string display name
+     */
+    public function getDisplayName($uid): string {
+        $uid = (string)$uid;
+        $this->loadUser($uid);
+        return empty($this->cache[$uid]['displayname']) ? $uid : $this->cache[$uid]['displayname'];
+    }
+
+    /**
+     * Get a list of all display names and user ids.
+     *
+     * @param string $search
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array an array of all displayNames (value) and the corresponding uids (key)
+     */
+    public function getDisplayNames($search = '', $limit = null, $offset = null) {
+        $limit = $this->fixLimit($limit);
+
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+
+        $query->select('uid', 'displayname')
+            ->from($this->table, 'u')
+            ->leftJoin('u', 'preferences', 'p', $query->expr()->andX(
+                $query->expr()->eq('userid', 'uid'),
+                $query->expr()->eq('appid', $query->expr()->literal('settings')),
+                $query->expr()->eq('configkey', $query->expr()->literal('email')))
+            )
+            // sqlite doesn't like re-using a single named parameter here
+            ->where($query->expr()->iLike('uid', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
+            ->orWhere($query->expr()->iLike('displayname', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
+            ->orWhere($query->expr()->iLike('configvalue', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
+            ->orderBy($query->func()->lower('displayname'), 'ASC')
+            ->addOrderBy('uid_lower', 'ASC')
+            ->setMaxResults($limit)
+            ->setFirstResult($offset);
+
+        $result = $query->execute();
+        $displayNames = [];
+        while ($row = $result->fetch()) {
+            $displayNames[(string)$row['uid']] = (string)$row['displayname'];
+        }
+
+        return $displayNames;
+    }
+
+    /**
+     * @param string $searcher
+     * @param string $pattern
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return array
+     * @since 21.0.1
+     */
+    public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array {
+        $limit = $this->fixLimit($limit);
+
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+
+        $query->select('u.uid', 'u.displayname')
+            ->from($this->table, 'u')
+            ->leftJoin('u', 'known_users', 'k', $query->expr()->andX(
+                $query->expr()->eq('k.known_user', 'u.uid'),
+                $query->expr()->eq('k.known_to', $query->createNamedParameter($searcher))
+            ))
+            ->where($query->expr()->eq('k.known_to', $query->createNamedParameter($searcher)))
+            ->andWhere($query->expr()->orX(
+                $query->expr()->iLike('u.uid', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%')),
+                $query->expr()->iLike('u.displayname', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%'))
+            ))
+            ->orderBy('u.displayname', 'ASC')
+            ->addOrderBy('u.uid_lower', 'ASC')
+            ->setMaxResults($limit)
+            ->setFirstResult($offset);
+
+        $result = $query->execute();
+        $displayNames = [];
+        while ($row = $result->fetch()) {
+            $displayNames[(string)$row['uid']] = (string)$row['displayname'];
+        }
+
+        return $displayNames;
+    }
+
+    /**
+     * Check if the password is correct
+     *
+     * @param string $loginName The loginname
+     * @param string $password The password
+     * @return string
+     *
+     * Check if the password is correct without logging in the user
+     * returns the user id or false
+     */
+    public function checkPassword(string $loginName, string $password) {
+        $this->fixDI();
+
+        $qb = $this->dbConn->getQueryBuilder();
+        $qb->select('uid', 'password')
+            ->from($this->table)
+            ->where(
+                $qb->expr()->eq(
+                    'uid_lower', $qb->createNamedParameter(mb_strtolower($loginName))
+                )
+            );
+        $result = $qb->execute();
+        $row = $result->fetch();
+        $result->closeCursor();
+
+        if ($row) {
+            $storedHash = $row['password'];
+            $newHash = '';
+            if (\OC::$server->getHasher()->verify($password, $storedHash, $newHash)) {
+                if (!empty($newHash)) {
+                    $this->updatePassword($loginName, $newHash);
+                }
+                return (string)$row['uid'];
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Load an user in the cache
+     *
+     * @param string $uid the username
+     * @return boolean true if user was found, false otherwise
+     */
+    private function loadUser($uid) {
+        $this->fixDI();
+
+        $uid = (string)$uid;
+        if (!isset($this->cache[$uid])) {
+            //guests $uid could be NULL or ''
+            if ($uid === '') {
+                $this->cache[$uid] = false;
+                return true;
+            }
+
+            $qb = $this->dbConn->getQueryBuilder();
+            $qb->select('uid', 'displayname')
+                ->from($this->table)
+                ->where(
+                    $qb->expr()->eq(
+                        'uid_lower', $qb->createNamedParameter(mb_strtolower($uid))
+                    )
+                );
+            $result = $qb->execute();
+            $row = $result->fetch();
+            $result->closeCursor();
+
+            $this->cache[$uid] = false;
+
+            // "uid" is primary key, so there can only be a single result
+            if ($row !== false) {
+                $this->cache[$uid]['uid'] = (string)$row['uid'];
+                $this->cache[$uid]['displayname'] = (string)$row['displayname'];
+            } else {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Get a list of all users
+     *
+     * @param string $search
+     * @param null|int $limit
+     * @param null|int $offset
+     * @return string[] an array of all uids
+     */
+    public function getUsers($search = '', $limit = null, $offset = null) {
+        $limit = $this->fixLimit($limit);
+
+        $users = $this->getDisplayNames($search, $limit, $offset);
+        $userIds = array_map(function ($uid) {
+            return (string)$uid;
+        }, array_keys($users));
+        sort($userIds, SORT_STRING | SORT_FLAG_CASE);
+        return $userIds;
+    }
+
+    /**
+     * check if a user exists
+     *
+     * @param string $uid the username
+     * @return boolean
+     */
+    public function userExists($uid) {
+        $this->loadUser($uid);
+        return $this->cache[$uid] !== false;
+    }
+
+    /**
+     * get the user's home directory
+     *
+     * @param string $uid the username
+     * @return string|false
+     */
+    public function getHome(string $uid) {
+        if ($this->userExists($uid)) {
+            return \OC::$server->getConfig()->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data') . '/' . $uid;
+        }
+
+        return false;
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasUserListings() {
+        return true;
+    }
+
+    /**
+     * counts the users in the database
+     *
+     * @return int|bool
+     */
+    public function countUsers() {
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+        $query->select($query->func()->count('uid'))
+            ->from($this->table);
+        $result = $query->execute();
+
+        return $result->fetchOne();
+    }
+
+    /**
+     * returns the username for the given login name in the correct casing
+     *
+     * @param string $loginName
+     * @return string|false
+     */
+    public function loginName2UserName($loginName) {
+        if ($this->userExists($loginName)) {
+            return $this->cache[$loginName]['uid'];
+        }
+
+        return false;
+    }
+
+    /**
+     * Backend name to be shown in user management
+     *
+     * @return string the name of the backend to be shown
+     */
+    public function getBackendName() {
+        return 'Database';
+    }
+
+    public static function preLoginNameUsedAsUserName($param) {
+        if (!isset($param['uid'])) {
+            throw new \Exception('key uid is expected to be set in $param');
+        }
+
+        $backends = \OC::$server->getUserManager()->getBackends();
+        foreach ($backends as $backend) {
+            if ($backend instanceof Database) {
+                /** @var \OC\User\Database $backend */
+                $uid = $backend->loginName2UserName($param['uid']);
+                if ($uid !== false) {
+                    $param['uid'] = $uid;
+                    return;
+                }
+            }
+        }
+    }
+
+    public function getRealUID(string $uid): string {
+        if (!$this->userExists($uid)) {
+            throw new \RuntimeException($uid . ' does not exist');
+        }
+
+        return $this->cache[$uid]['uid'];
+    }
+
+    private function fixLimit($limit) {
+        if (is_int($limit) && $limit >= 0) {
+            return $limit;
+        }
+
+        return null;
+    }
 }

Spacing +16 added lines, -16 removed lines

@@ -247,7 +247,7 @@ 
 	 * @return string display name
 	 */
 	public function getDisplayName($uid): string {
-		$uid = (string)$uid;
+		$uid = (string) $uid;
 		$this->loadUser($uid);
 		return empty($this->cache[$uid]['displayname']) ? $uid : $this->cache[$uid]['displayname'];
 	}
@@ -275,9 +275,9 @@ 
 				$query->expr()->eq('configkey', $query->expr()->literal('email')))
 			)
 			// sqlite doesn't like re-using a single named parameter here
-			->where($query->expr()->iLike('uid', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
-			->orWhere($query->expr()->iLike('displayname', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
-			->orWhere($query->expr()->iLike('configvalue', $query->createPositionalParameter('%' . $this->dbConn->escapeLikeParameter($search) . '%')))
+			->where($query->expr()->iLike('uid', $query->createPositionalParameter('%'.$this->dbConn->escapeLikeParameter($search).'%')))
+			->orWhere($query->expr()->iLike('displayname', $query->createPositionalParameter('%'.$this->dbConn->escapeLikeParameter($search).'%')))
+			->orWhere($query->expr()->iLike('configvalue', $query->createPositionalParameter('%'.$this->dbConn->escapeLikeParameter($search).'%')))
 			->orderBy($query->func()->lower('displayname'), 'ASC')
 			->addOrderBy('uid_lower', 'ASC')
 			->setMaxResults($limit)
@@ -286,7 +286,7 @@ 
 		$result = $query->execute();
 		$displayNames = [];
 		while ($row = $result->fetch()) {
-			$displayNames[(string)$row['uid']] = (string)$row['displayname'];
+			$displayNames[(string) $row['uid']] = (string) $row['displayname'];
 		}
 
 		return $displayNames;
@@ -315,8 +315,8 @@ 
 			))
 			->where($query->expr()->eq('k.known_to', $query->createNamedParameter($searcher)))
 			->andWhere($query->expr()->orX(
-				$query->expr()->iLike('u.uid', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%')),
-				$query->expr()->iLike('u.displayname', $query->createNamedParameter('%' . $this->dbConn->escapeLikeParameter($pattern) . '%'))
+				$query->expr()->iLike('u.uid', $query->createNamedParameter('%'.$this->dbConn->escapeLikeParameter($pattern).'%')),
+				$query->expr()->iLike('u.displayname', $query->createNamedParameter('%'.$this->dbConn->escapeLikeParameter($pattern).'%'))
 			))
 			->orderBy('u.displayname', 'ASC')
 			->addOrderBy('u.uid_lower', 'ASC')
@@ -326,7 +326,7 @@ 
 		$result = $query->execute();
 		$displayNames = [];
 		while ($row = $result->fetch()) {
-			$displayNames[(string)$row['uid']] = (string)$row['displayname'];
+			$displayNames[(string) $row['uid']] = (string) $row['displayname'];
 		}
 
 		return $displayNames;
@@ -364,7 +364,7 @@ 
 				if (!empty($newHash)) {
 					$this->updatePassword($loginName, $newHash);
 				}
-				return (string)$row['uid'];
+				return (string) $row['uid'];
 			}
 		}
 
@@ -380,7 +380,7 @@ 
 	private function loadUser($uid) {
 		$this->fixDI();
 
-		$uid = (string)$uid;
+		$uid = (string) $uid;
 		if (!isset($this->cache[$uid])) {
 			//guests $uid could be NULL or ''
 			if ($uid === '') {
@@ -404,8 +404,8 @@ 
 
 			// "uid" is primary key, so there can only be a single result
 			if ($row !== false) {
-				$this->cache[$uid]['uid'] = (string)$row['uid'];
-				$this->cache[$uid]['displayname'] = (string)$row['displayname'];
+				$this->cache[$uid]['uid'] = (string) $row['uid'];
+				$this->cache[$uid]['displayname'] = (string) $row['displayname'];
 			} else {
 				return false;
 			}
@@ -426,8 +426,8 @@ 
 		$limit = $this->fixLimit($limit);
 
 		$users = $this->getDisplayNames($search, $limit, $offset);
-		$userIds = array_map(function ($uid) {
-			return (string)$uid;
+		$userIds = array_map(function($uid) {
+			return (string) $uid;
 		}, array_keys($users));
 		sort($userIds, SORT_STRING | SORT_FLAG_CASE);
 		return $userIds;
@@ -452,7 +452,7 @@ 
 	 */
 	public function getHome(string $uid) {
 		if ($this->userExists($uid)) {
-			return \OC::$server->getConfig()->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data') . '/' . $uid;
+			return \OC::$server->getConfig()->getSystemValue('datadirectory', \OC::$SERVERROOT.'/data').'/'.$uid;
 		}
 
 		return false;
@@ -524,7 +524,7 @@ 
 
 	public function getRealUID(string $uid): string {
 		if (!$this->userExists($uid)) {
-			throw new \RuntimeException($uid . ' does not exist');
+			throw new \RuntimeException($uid.' does not exist');
 		}
 
 		return $this->cache[$uid]['uid'];

lib/private/User/Manager.php

Indentation +658 added lines, -658 removed lines

@@ -71,662 +71,662 @@
  * @package OC\User
  */
 class Manager extends PublicEmitter implements IUserManager {
-	/**
-	 * @var \OCP\UserInterface[] $backends
-	 */
-	private $backends = [];
-
-	/**
-	 * @var \OC\User\User[] $cachedUsers
-	 */
-	private $cachedUsers = [];
-
-	/** @var IConfig */
-	private $config;
-
-	/** @var EventDispatcherInterface */
-	private $dispatcher;
-
-	/** @var ICache */
-	private $cache;
-
-	/** @var IEventDispatcher */
-	private $eventDispatcher;
-
-	public function __construct(IConfig $config,
-								EventDispatcherInterface $oldDispatcher,
-								ICacheFactory $cacheFactory,
-								IEventDispatcher $eventDispatcher) {
-		$this->config = $config;
-		$this->dispatcher = $oldDispatcher;
-		$this->cache = $cacheFactory->createDistributed('user_backend_map');
-		$cachedUsers = &$this->cachedUsers;
-		$this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
-			/** @var \OC\User\User $user */
-			unset($cachedUsers[$user->getUID()]);
-		});
-		$this->eventDispatcher = $eventDispatcher;
-	}
-
-	/**
-	 * Get the active backends
-	 * @return \OCP\UserInterface[]
-	 */
-	public function getBackends() {
-		return $this->backends;
-	}
-
-	/**
-	 * register a user backend
-	 *
-	 * @param \OCP\UserInterface $backend
-	 */
-	public function registerBackend($backend) {
-		$this->backends[] = $backend;
-	}
-
-	/**
-	 * remove a user backend
-	 *
-	 * @param \OCP\UserInterface $backend
-	 */
-	public function removeBackend($backend) {
-		$this->cachedUsers = [];
-		if (($i = array_search($backend, $this->backends)) !== false) {
-			unset($this->backends[$i]);
-		}
-	}
-
-	/**
-	 * remove all user backends
-	 */
-	public function clearBackends() {
-		$this->cachedUsers = [];
-		$this->backends = [];
-	}
-
-	/**
-	 * get a user by user id
-	 *
-	 * @param string $uid
-	 * @return \OC\User\User|null Either the user or null if the specified user does not exist
-	 */
-	public function get($uid) {
-		if (is_null($uid) || $uid === '' || $uid === false) {
-			return null;
-		}
-		if (isset($this->cachedUsers[$uid])) { //check the cache first to prevent having to loop over the backends
-			return $this->cachedUsers[$uid];
-		}
-
-		$cachedBackend = $this->cache->get($uid);
-		if ($cachedBackend !== null && isset($this->backends[$cachedBackend])) {
-			// Cache has the info of the user backend already, so ask that one directly
-			$backend = $this->backends[$cachedBackend];
-			if ($backend->userExists($uid)) {
-				return $this->getUserObject($uid, $backend);
-			}
-		}
-
-		foreach ($this->backends as $i => $backend) {
-			if ($i === $cachedBackend) {
-				// Tried that one already
-				continue;
-			}
-
-			if ($backend->userExists($uid)) {
-				$this->cache->set($uid, $i, 300);
-				return $this->getUserObject($uid, $backend);
-			}
-		}
-		return null;
-	}
-
-	/**
-	 * get or construct the user object
-	 *
-	 * @param string $uid
-	 * @param \OCP\UserInterface $backend
-	 * @param bool $cacheUser If false the newly created user object will not be cached
-	 * @return \OC\User\User
-	 */
-	protected function getUserObject($uid, $backend, $cacheUser = true) {
-		if ($backend instanceof IGetRealUIDBackend) {
-			$uid = $backend->getRealUID($uid);
-		}
-
-		if (isset($this->cachedUsers[$uid])) {
-			return $this->cachedUsers[$uid];
-		}
-
-		$user = new User($uid, $backend, $this->dispatcher, $this, $this->config);
-		if ($cacheUser) {
-			$this->cachedUsers[$uid] = $user;
-		}
-		return $user;
-	}
-
-	/**
-	 * check if a user exists
-	 *
-	 * @param string $uid
-	 * @return bool
-	 */
-	public function userExists($uid) {
-		$user = $this->get($uid);
-		return ($user !== null);
-	}
-
-	/**
-	 * 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) {
-		$result = $this->checkPasswordNoLogging($loginName, $password);
-
-		if ($result === false) {
-			\OC::$server->getLogger()->warning('Login failed: \''. $loginName .'\' (Remote IP: \''. \OC::$server->getRequest()->getRemoteAddress(). '\')', ['app' => 'core']);
-		}
-
-		return $result;
-	}
-
-	/**
-	 * Check if the password is valid for the user
-	 *
-	 * @internal
-	 * @param string $loginName
-	 * @param string $password
-	 * @return IUser|false the User object on success, false otherwise
-	 */
-	public function checkPasswordNoLogging($loginName, $password) {
-		$loginName = str_replace("\0", '', $loginName);
-		$password = str_replace("\0", '', $password);
-
-		foreach ($this->backends as $backend) {
-			if ($backend->implementsActions(Backend::CHECK_PASSWORD)) {
-				$uid = $backend->checkPassword($loginName, $password);
-				if ($uid !== false) {
-					return $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		// since http basic auth doesn't provide a standard way of handling non ascii password we allow password to be urlencoded
-		// we only do this decoding after using the plain password fails to maintain compatibility with any password that happens
-		// to contains urlencoded patterns by "accident".
-		$password = urldecode($password);
-
-		foreach ($this->backends as $backend) {
-			if ($backend->implementsActions(Backend::CHECK_PASSWORD)) {
-				$uid = $backend->checkPassword($loginName, $password);
-				if ($uid !== false) {
-					return $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * 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 = [];
-		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);
-				}
-			}
-		}
-
-		uasort($users, function ($a, $b) {
-			/**
-			 * @var \OC\User\User $a
-			 * @var \OC\User\User $b
-			 */
-			return strcasecmp($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 = [];
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
-			if (is_array($backendUsers)) {
-				foreach ($backendUsers as $uid => $displayName) {
-					$users[] = $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		usort($users, function ($a, $b) {
-			/**
-			 * @var \OC\User\User $a
-			 * @var \OC\User\User $b
-			 */
-			return strcasecmp($a->getDisplayName(), $b->getDisplayName());
-		});
-		return $users;
-	}
-
-	/**
-	 * Search known users (from phonebook sync) by displayName
-	 *
-	 * @param string $searcher
-	 * @param string $pattern
-	 * @param int|null $limit
-	 * @param int|null $offset
-	 * @return IUser[]
-	 */
-	public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array {
-		$users = [];
-		foreach ($this->backends as $backend) {
-			if ($backend instanceof ISearchKnownUsersBackend) {
-				$backendUsers = $backend->searchKnownUsersByDisplayName($searcher, $pattern, $limit, $offset);
-			} else {
-				// Better than nothing, but filtering after pagination can remove lots of results.
-				$backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
-			}
-			if (is_array($backendUsers)) {
-				foreach ($backendUsers as $uid => $displayName) {
-					$users[] = $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		usort($users, function ($a, $b) {
-			/**
-			 * @var IUser $a
-			 * @var IUser $b
-			 */
-			return strcasecmp($a->getDisplayName(), $b->getDisplayName());
-		});
-		return $users;
-	}
-
-	/**
-	 * @param string $uid
-	 * @param string $password
-	 * @throws \InvalidArgumentException
-	 * @return bool|IUser the created user or false
-	 */
-	public function createUser($uid, $password) {
-		// DI injection is not used here as IRegistry needs the user manager itself for user count and thus it would create a cyclic dependency
-		if (\OC::$server->get(IRegistry::class)->delegateIsHardUserLimitReached()) {
-			$l = \OC::$server->getL10N('lib');
-			throw new HintException($l->t('The user limit has been reached and the user was not created.'));
-		}
-
-		$localBackends = [];
-		foreach ($this->backends as $backend) {
-			if ($backend instanceof Database) {
-				// First check if there is another user backend
-				$localBackends[] = $backend;
-				continue;
-			}
-
-			if ($backend->implementsActions(Backend::CREATE_USER)) {
-				return $this->createUserFromBackend($uid, $password, $backend);
-			}
-		}
-
-		foreach ($localBackends as $backend) {
-			if ($backend->implementsActions(Backend::CREATE_USER)) {
-				return $this->createUserFromBackend($uid, $password, $backend);
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * @param string $uid
-	 * @param string $password
-	 * @param UserInterface $backend
-	 * @return IUser|null
-	 * @throws \InvalidArgumentException
-	 */
-	public function createUserFromBackend($uid, $password, UserInterface $backend) {
-		$l = \OC::$server->getL10N('lib');
-
-		// Check the name for bad characters
-		// Allowed are: "a-z", "A-Z", "0-9" and "_.@-'"
-		if (preg_match('/[^a-zA-Z0-9 _.@\-\']/', $uid)) {
-			throw new \InvalidArgumentException($l->t('Only the following characters are allowed in a username:'
-				. ' "a-z", "A-Z", "0-9", and "_.@-\'"'));
-		}
-
-		// No empty username
-		if (trim($uid) === '') {
-			throw new \InvalidArgumentException($l->t('A valid username must be provided'));
-		}
-
-		// No whitespace at the beginning or at the end
-		if (trim($uid) !== $uid) {
-			throw new \InvalidArgumentException($l->t('Username contains whitespace at the beginning or at the end'));
-		}
-
-		// Username only consists of 1 or 2 dots (directory traversal)
-		if ($uid === '.' || $uid === '..') {
-			throw new \InvalidArgumentException($l->t('Username must not consist of dots only'));
-		}
-
-		if (!$this->verifyUid($uid)) {
-			throw new \InvalidArgumentException($l->t('Username is invalid because files already exist for this user'));
-		}
-
-		// No empty password
-		if (trim($password) === '') {
-			throw new \InvalidArgumentException($l->t('A valid password must be provided'));
-		}
-
-		// Check if user already exists
-		if ($this->userExists($uid)) {
-			throw new \InvalidArgumentException($l->t('The username is already being used'));
-		}
-
-		/** @deprecated 21.0.0 use BeforeUserCreatedEvent event with the IEventDispatcher instead */
-		$this->emit('\OC\User', 'preCreateUser', [$uid, $password]);
-		$this->eventDispatcher->dispatchTyped(new BeforeUserCreatedEvent($uid, $password));
-		$state = $backend->createUser($uid, $password);
-		if ($state === false) {
-			throw new \InvalidArgumentException($l->t('Could not create user'));
-		}
-		$user = $this->getUserObject($uid, $backend);
-		if ($user instanceof IUser) {
-			/** @deprecated 21.0.0 use UserCreatedEvent event with the IEventDispatcher instead */
-			$this->emit('\OC\User', 'postCreateUser', [$user, $password]);
-			$this->eventDispatcher->dispatchTyped(new UserCreatedEvent($user, $password));
-		}
-		return $user;
-	}
-
-	/**
-	 * returns how many users per backend exist (if supported by backend)
-	 *
-	 * @param boolean $hasLoggedIn when true only users that have a lastLogin
-	 *                entry in the preferences table will be affected
-	 * @return array|int an array of backend class as key and count number as value
-	 *                if $hasLoggedIn is true only an int is returned
-	 */
-	public function countUsers($hasLoggedIn = false) {
-		if ($hasLoggedIn) {
-			return $this->countSeenUsers();
-		}
-		$userCountStatistics = [];
-		foreach ($this->backends as $backend) {
-			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;
-	}
-
-	/**
-	 * returns how many users per backend exist in the requested groups (if supported by backend)
-	 *
-	 * @param IGroup[] $groups an array of gid to search in
-	 * @return array|int an array of backend class as key and count number as value
-	 *                if $hasLoggedIn is true only an int is returned
-	 */
-	public function countUsersOfGroups(array $groups) {
-		$users = [];
-		foreach ($groups as $group) {
-			$usersIds = array_map(function ($user) {
-				return $user->getUID();
-			}, $group->getUsers());
-			$users = array_merge($users, $usersIds);
-		}
-		return count(array_unique($users));
-	}
-
-	/**
-	 * 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
-	 * @param boolean $onlySeen when true only users that have a lastLogin entry
-	 *                in the preferences table will be affected
-	 * @since 9.0.0
-	 */
-	public function callForAllUsers(\Closure $callback, $search = '', $onlySeen = false) {
-		if ($onlySeen) {
-			$this->callForSeenUsers($callback);
-		} else {
-			foreach ($this->getBackends() as $backend) {
-				$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);
-			}
-		}
-	}
-
-	/**
-	 * returns how many users are disabled
-	 *
-	 * @return int
-	 * @since 12.0.0
-	 */
-	public function countDisabledUsers(): int {
-		$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$queryBuilder->select($queryBuilder->func()->count('*'))
-			->from('preferences')
-			->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
-			->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
-			->andWhere($queryBuilder->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR));
-
-
-		$result = $queryBuilder->execute();
-		$count = $result->fetchOne();
-		$result->closeCursor();
-
-		if ($count !== false) {
-			$count = (int)$count;
-		} else {
-			$count = 0;
-		}
-
-		return $count;
-	}
-
-	/**
-	 * returns how many users are disabled in the requested groups
-	 *
-	 * @param array $groups groupids to search
-	 * @return int
-	 * @since 14.0.0
-	 */
-	public function countDisabledUsersOfGroups(array $groups): int {
-		$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$queryBuilder->select($queryBuilder->createFunction('COUNT(DISTINCT ' . $queryBuilder->getColumnName('uid') . ')'))
-			->from('preferences', 'p')
-			->innerJoin('p', 'group_user', 'g', $queryBuilder->expr()->eq('p.userid', 'g.uid'))
-			->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
-			->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
-			->andWhere($queryBuilder->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR))
-			->andWhere($queryBuilder->expr()->in('gid', $queryBuilder->createNamedParameter($groups, IQueryBuilder::PARAM_STR_ARRAY)));
-
-		$result = $queryBuilder->execute();
-		$count = $result->fetchOne();
-		$result->closeCursor();
-
-		if ($count !== false) {
-			$count = (int)$count;
-		} else {
-			$count = 0;
-		}
-
-		return $count;
-	}
-
-	/**
-	 * returns how many users have logged in once
-	 *
-	 * @return int
-	 * @since 11.0.0
-	 */
-	public function countSeenUsers() {
-		$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$queryBuilder->select($queryBuilder->func()->count('*'))
-			->from('preferences')
-			->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('login')))
-			->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('lastLogin')))
-			->andWhere($queryBuilder->expr()->isNotNull('configvalue'));
-
-		$query = $queryBuilder->execute();
-
-		$result = (int)$query->fetchOne();
-		$query->closeCursor();
-
-		return $result;
-	}
-
-	/**
-	 * @param \Closure $callback
-	 * @psalm-param \Closure(\OCP\IUser):?bool $callback
-	 * @since 11.0.0
-	 */
-	public function callForSeenUsers(\Closure $callback) {
-		$limit = 1000;
-		$offset = 0;
-		do {
-			$userIds = $this->getSeenUserIds($limit, $offset);
-			$offset += $limit;
-			foreach ($userIds as $userId) {
-				foreach ($this->backends as $backend) {
-					if ($backend->userExists($userId)) {
-						$user = $this->getUserObject($userId, $backend, false);
-						$return = $callback($user);
-						if ($return === false) {
-							return;
-						}
-						break;
-					}
-				}
-			}
-		} while (count($userIds) >= $limit);
-	}
-
-	/**
-	 * Getting all userIds that have a listLogin value requires checking the
-	 * value in php because on oracle you cannot use a clob in a where clause,
-	 * preventing us from doing a not null or length(value) > 0 check.
-	 *
-	 * @param int $limit
-	 * @param int $offset
-	 * @return string[] with user ids
-	 */
-	private function getSeenUserIds($limit = null, $offset = null) {
-		$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$queryBuilder->select(['userid'])
-			->from('preferences')
-			->where($queryBuilder->expr()->eq(
-				'appid', $queryBuilder->createNamedParameter('login'))
-			)
-			->andWhere($queryBuilder->expr()->eq(
-				'configkey', $queryBuilder->createNamedParameter('lastLogin'))
-			)
-			->andWhere($queryBuilder->expr()->isNotNull('configvalue')
-			);
-
-		if ($limit !== null) {
-			$queryBuilder->setMaxResults($limit);
-		}
-		if ($offset !== null) {
-			$queryBuilder->setFirstResult($offset);
-		}
-		$query = $queryBuilder->execute();
-		$result = [];
-
-		while ($row = $query->fetch()) {
-			$result[] = $row['userid'];
-		}
-
-		$query->closeCursor();
-
-		return $result;
-	}
-
-	/**
-	 * @param string $email
-	 * @return IUser[]
-	 * @since 9.1.0
-	 */
-	public function getByEmail($email) {
-		$userIds = $this->config->getUsersForUserValueCaseInsensitive('settings', 'email', $email);
-
-		$users = array_map(function ($uid) {
-			return $this->get($uid);
-		}, $userIds);
-
-		return array_values(array_filter($users, function ($u) {
-			return ($u instanceof IUser);
-		}));
-	}
-
-	private function verifyUid(string $uid): bool {
-		$appdata = 'appdata_' . $this->config->getSystemValueString('instanceid');
-
-		if (\in_array($uid, [
-			'.htaccess',
-			'files_external',
-			'__groupfolders',
-			'.ocdata',
-			'owncloud.log',
-			'nextcloud.log',
-			$appdata], true)) {
-			return false;
-		}
-
-		$dataDirectory = $this->config->getSystemValueString('datadirectory', \OC::$SERVERROOT . '/data');
-
-		return !file_exists(rtrim($dataDirectory, '/') . '/' . $uid);
-	}
+    /**
+     * @var \OCP\UserInterface[] $backends
+     */
+    private $backends = [];
+
+    /**
+     * @var \OC\User\User[] $cachedUsers
+     */
+    private $cachedUsers = [];
+
+    /** @var IConfig */
+    private $config;
+
+    /** @var EventDispatcherInterface */
+    private $dispatcher;
+
+    /** @var ICache */
+    private $cache;
+
+    /** @var IEventDispatcher */
+    private $eventDispatcher;
+
+    public function __construct(IConfig $config,
+                                EventDispatcherInterface $oldDispatcher,
+                                ICacheFactory $cacheFactory,
+                                IEventDispatcher $eventDispatcher) {
+        $this->config = $config;
+        $this->dispatcher = $oldDispatcher;
+        $this->cache = $cacheFactory->createDistributed('user_backend_map');
+        $cachedUsers = &$this->cachedUsers;
+        $this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
+            /** @var \OC\User\User $user */
+            unset($cachedUsers[$user->getUID()]);
+        });
+        $this->eventDispatcher = $eventDispatcher;
+    }
+
+    /**
+     * Get the active backends
+     * @return \OCP\UserInterface[]
+     */
+    public function getBackends() {
+        return $this->backends;
+    }
+
+    /**
+     * register a user backend
+     *
+     * @param \OCP\UserInterface $backend
+     */
+    public function registerBackend($backend) {
+        $this->backends[] = $backend;
+    }
+
+    /**
+     * remove a user backend
+     *
+     * @param \OCP\UserInterface $backend
+     */
+    public function removeBackend($backend) {
+        $this->cachedUsers = [];
+        if (($i = array_search($backend, $this->backends)) !== false) {
+            unset($this->backends[$i]);
+        }
+    }
+
+    /**
+     * remove all user backends
+     */
+    public function clearBackends() {
+        $this->cachedUsers = [];
+        $this->backends = [];
+    }
+
+    /**
+     * get a user by user id
+     *
+     * @param string $uid
+     * @return \OC\User\User|null Either the user or null if the specified user does not exist
+     */
+    public function get($uid) {
+        if (is_null($uid) || $uid === '' || $uid === false) {
+            return null;
+        }
+        if (isset($this->cachedUsers[$uid])) { //check the cache first to prevent having to loop over the backends
+            return $this->cachedUsers[$uid];
+        }
+
+        $cachedBackend = $this->cache->get($uid);
+        if ($cachedBackend !== null && isset($this->backends[$cachedBackend])) {
+            // Cache has the info of the user backend already, so ask that one directly
+            $backend = $this->backends[$cachedBackend];
+            if ($backend->userExists($uid)) {
+                return $this->getUserObject($uid, $backend);
+            }
+        }
+
+        foreach ($this->backends as $i => $backend) {
+            if ($i === $cachedBackend) {
+                // Tried that one already
+                continue;
+            }
+
+            if ($backend->userExists($uid)) {
+                $this->cache->set($uid, $i, 300);
+                return $this->getUserObject($uid, $backend);
+            }
+        }
+        return null;
+    }
+
+    /**
+     * get or construct the user object
+     *
+     * @param string $uid
+     * @param \OCP\UserInterface $backend
+     * @param bool $cacheUser If false the newly created user object will not be cached
+     * @return \OC\User\User
+     */
+    protected function getUserObject($uid, $backend, $cacheUser = true) {
+        if ($backend instanceof IGetRealUIDBackend) {
+            $uid = $backend->getRealUID($uid);
+        }
+
+        if (isset($this->cachedUsers[$uid])) {
+            return $this->cachedUsers[$uid];
+        }
+
+        $user = new User($uid, $backend, $this->dispatcher, $this, $this->config);
+        if ($cacheUser) {
+            $this->cachedUsers[$uid] = $user;
+        }
+        return $user;
+    }
+
+    /**
+     * check if a user exists
+     *
+     * @param string $uid
+     * @return bool
+     */
+    public function userExists($uid) {
+        $user = $this->get($uid);
+        return ($user !== null);
+    }
+
+    /**
+     * 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) {
+        $result = $this->checkPasswordNoLogging($loginName, $password);
+
+        if ($result === false) {
+            \OC::$server->getLogger()->warning('Login failed: \''. $loginName .'\' (Remote IP: \''. \OC::$server->getRequest()->getRemoteAddress(). '\')', ['app' => 'core']);
+        }
+
+        return $result;
+    }
+
+    /**
+     * Check if the password is valid for the user
+     *
+     * @internal
+     * @param string $loginName
+     * @param string $password
+     * @return IUser|false the User object on success, false otherwise
+     */
+    public function checkPasswordNoLogging($loginName, $password) {
+        $loginName = str_replace("\0", '', $loginName);
+        $password = str_replace("\0", '', $password);
+
+        foreach ($this->backends as $backend) {
+            if ($backend->implementsActions(Backend::CHECK_PASSWORD)) {
+                $uid = $backend->checkPassword($loginName, $password);
+                if ($uid !== false) {
+                    return $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        // since http basic auth doesn't provide a standard way of handling non ascii password we allow password to be urlencoded
+        // we only do this decoding after using the plain password fails to maintain compatibility with any password that happens
+        // to contains urlencoded patterns by "accident".
+        $password = urldecode($password);
+
+        foreach ($this->backends as $backend) {
+            if ($backend->implementsActions(Backend::CHECK_PASSWORD)) {
+                $uid = $backend->checkPassword($loginName, $password);
+                if ($uid !== false) {
+                    return $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * 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 = [];
+        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);
+                }
+            }
+        }
+
+        uasort($users, function ($a, $b) {
+            /**
+             * @var \OC\User\User $a
+             * @var \OC\User\User $b
+             */
+            return strcasecmp($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 = [];
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
+            if (is_array($backendUsers)) {
+                foreach ($backendUsers as $uid => $displayName) {
+                    $users[] = $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        usort($users, function ($a, $b) {
+            /**
+             * @var \OC\User\User $a
+             * @var \OC\User\User $b
+             */
+            return strcasecmp($a->getDisplayName(), $b->getDisplayName());
+        });
+        return $users;
+    }
+
+    /**
+     * Search known users (from phonebook sync) by displayName
+     *
+     * @param string $searcher
+     * @param string $pattern
+     * @param int|null $limit
+     * @param int|null $offset
+     * @return IUser[]
+     */
+    public function searchKnownUsersByDisplayName(string $searcher, string $pattern, ?int $limit = null, ?int $offset = null): array {
+        $users = [];
+        foreach ($this->backends as $backend) {
+            if ($backend instanceof ISearchKnownUsersBackend) {
+                $backendUsers = $backend->searchKnownUsersByDisplayName($searcher, $pattern, $limit, $offset);
+            } else {
+                // Better than nothing, but filtering after pagination can remove lots of results.
+                $backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
+            }
+            if (is_array($backendUsers)) {
+                foreach ($backendUsers as $uid => $displayName) {
+                    $users[] = $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        usort($users, function ($a, $b) {
+            /**
+             * @var IUser $a
+             * @var IUser $b
+             */
+            return strcasecmp($a->getDisplayName(), $b->getDisplayName());
+        });
+        return $users;
+    }
+
+    /**
+     * @param string $uid
+     * @param string $password
+     * @throws \InvalidArgumentException
+     * @return bool|IUser the created user or false
+     */
+    public function createUser($uid, $password) {
+        // DI injection is not used here as IRegistry needs the user manager itself for user count and thus it would create a cyclic dependency
+        if (\OC::$server->get(IRegistry::class)->delegateIsHardUserLimitReached()) {
+            $l = \OC::$server->getL10N('lib');
+            throw new HintException($l->t('The user limit has been reached and the user was not created.'));
+        }
+
+        $localBackends = [];
+        foreach ($this->backends as $backend) {
+            if ($backend instanceof Database) {
+                // First check if there is another user backend
+                $localBackends[] = $backend;
+                continue;
+            }
+
+            if ($backend->implementsActions(Backend::CREATE_USER)) {
+                return $this->createUserFromBackend($uid, $password, $backend);
+            }
+        }
+
+        foreach ($localBackends as $backend) {
+            if ($backend->implementsActions(Backend::CREATE_USER)) {
+                return $this->createUserFromBackend($uid, $password, $backend);
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param string $uid
+     * @param string $password
+     * @param UserInterface $backend
+     * @return IUser|null
+     * @throws \InvalidArgumentException
+     */
+    public function createUserFromBackend($uid, $password, UserInterface $backend) {
+        $l = \OC::$server->getL10N('lib');
+
+        // Check the name for bad characters
+        // Allowed are: "a-z", "A-Z", "0-9" and "_.@-'"
+        if (preg_match('/[^a-zA-Z0-9 _.@\-\']/', $uid)) {
+            throw new \InvalidArgumentException($l->t('Only the following characters are allowed in a username:'
+                . ' "a-z", "A-Z", "0-9", and "_.@-\'"'));
+        }
+
+        // No empty username
+        if (trim($uid) === '') {
+            throw new \InvalidArgumentException($l->t('A valid username must be provided'));
+        }
+
+        // No whitespace at the beginning or at the end
+        if (trim($uid) !== $uid) {
+            throw new \InvalidArgumentException($l->t('Username contains whitespace at the beginning or at the end'));
+        }
+
+        // Username only consists of 1 or 2 dots (directory traversal)
+        if ($uid === '.' || $uid === '..') {
+            throw new \InvalidArgumentException($l->t('Username must not consist of dots only'));
+        }
+
+        if (!$this->verifyUid($uid)) {
+            throw new \InvalidArgumentException($l->t('Username is invalid because files already exist for this user'));
+        }
+
+        // No empty password
+        if (trim($password) === '') {
+            throw new \InvalidArgumentException($l->t('A valid password must be provided'));
+        }
+
+        // Check if user already exists
+        if ($this->userExists($uid)) {
+            throw new \InvalidArgumentException($l->t('The username is already being used'));
+        }
+
+        /** @deprecated 21.0.0 use BeforeUserCreatedEvent event with the IEventDispatcher instead */
+        $this->emit('\OC\User', 'preCreateUser', [$uid, $password]);
+        $this->eventDispatcher->dispatchTyped(new BeforeUserCreatedEvent($uid, $password));
+        $state = $backend->createUser($uid, $password);
+        if ($state === false) {
+            throw new \InvalidArgumentException($l->t('Could not create user'));
+        }
+        $user = $this->getUserObject($uid, $backend);
+        if ($user instanceof IUser) {
+            /** @deprecated 21.0.0 use UserCreatedEvent event with the IEventDispatcher instead */
+            $this->emit('\OC\User', 'postCreateUser', [$user, $password]);
+            $this->eventDispatcher->dispatchTyped(new UserCreatedEvent($user, $password));
+        }
+        return $user;
+    }
+
+    /**
+     * returns how many users per backend exist (if supported by backend)
+     *
+     * @param boolean $hasLoggedIn when true only users that have a lastLogin
+     *                entry in the preferences table will be affected
+     * @return array|int an array of backend class as key and count number as value
+     *                if $hasLoggedIn is true only an int is returned
+     */
+    public function countUsers($hasLoggedIn = false) {
+        if ($hasLoggedIn) {
+            return $this->countSeenUsers();
+        }
+        $userCountStatistics = [];
+        foreach ($this->backends as $backend) {
+            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;
+    }
+
+    /**
+     * returns how many users per backend exist in the requested groups (if supported by backend)
+     *
+     * @param IGroup[] $groups an array of gid to search in
+     * @return array|int an array of backend class as key and count number as value
+     *                if $hasLoggedIn is true only an int is returned
+     */
+    public function countUsersOfGroups(array $groups) {
+        $users = [];
+        foreach ($groups as $group) {
+            $usersIds = array_map(function ($user) {
+                return $user->getUID();
+            }, $group->getUsers());
+            $users = array_merge($users, $usersIds);
+        }
+        return count(array_unique($users));
+    }
+
+    /**
+     * 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
+     * @param boolean $onlySeen when true only users that have a lastLogin entry
+     *                in the preferences table will be affected
+     * @since 9.0.0
+     */
+    public function callForAllUsers(\Closure $callback, $search = '', $onlySeen = false) {
+        if ($onlySeen) {
+            $this->callForSeenUsers($callback);
+        } else {
+            foreach ($this->getBackends() as $backend) {
+                $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);
+            }
+        }
+    }
+
+    /**
+     * returns how many users are disabled
+     *
+     * @return int
+     * @since 12.0.0
+     */
+    public function countDisabledUsers(): int {
+        $queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $queryBuilder->select($queryBuilder->func()->count('*'))
+            ->from('preferences')
+            ->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
+            ->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
+            ->andWhere($queryBuilder->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR));
+
+
+        $result = $queryBuilder->execute();
+        $count = $result->fetchOne();
+        $result->closeCursor();
+
+        if ($count !== false) {
+            $count = (int)$count;
+        } else {
+            $count = 0;
+        }
+
+        return $count;
+    }
+
+    /**
+     * returns how many users are disabled in the requested groups
+     *
+     * @param array $groups groupids to search
+     * @return int
+     * @since 14.0.0
+     */
+    public function countDisabledUsersOfGroups(array $groups): int {
+        $queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $queryBuilder->select($queryBuilder->createFunction('COUNT(DISTINCT ' . $queryBuilder->getColumnName('uid') . ')'))
+            ->from('preferences', 'p')
+            ->innerJoin('p', 'group_user', 'g', $queryBuilder->expr()->eq('p.userid', 'g.uid'))
+            ->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
+            ->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
+            ->andWhere($queryBuilder->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR))
+            ->andWhere($queryBuilder->expr()->in('gid', $queryBuilder->createNamedParameter($groups, IQueryBuilder::PARAM_STR_ARRAY)));
+
+        $result = $queryBuilder->execute();
+        $count = $result->fetchOne();
+        $result->closeCursor();
+
+        if ($count !== false) {
+            $count = (int)$count;
+        } else {
+            $count = 0;
+        }
+
+        return $count;
+    }
+
+    /**
+     * returns how many users have logged in once
+     *
+     * @return int
+     * @since 11.0.0
+     */
+    public function countSeenUsers() {
+        $queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $queryBuilder->select($queryBuilder->func()->count('*'))
+            ->from('preferences')
+            ->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('login')))
+            ->andWhere($queryBuilder->expr()->eq('configkey', $queryBuilder->createNamedParameter('lastLogin')))
+            ->andWhere($queryBuilder->expr()->isNotNull('configvalue'));
+
+        $query = $queryBuilder->execute();
+
+        $result = (int)$query->fetchOne();
+        $query->closeCursor();
+
+        return $result;
+    }
+
+    /**
+     * @param \Closure $callback
+     * @psalm-param \Closure(\OCP\IUser):?bool $callback
+     * @since 11.0.0
+     */
+    public function callForSeenUsers(\Closure $callback) {
+        $limit = 1000;
+        $offset = 0;
+        do {
+            $userIds = $this->getSeenUserIds($limit, $offset);
+            $offset += $limit;
+            foreach ($userIds as $userId) {
+                foreach ($this->backends as $backend) {
+                    if ($backend->userExists($userId)) {
+                        $user = $this->getUserObject($userId, $backend, false);
+                        $return = $callback($user);
+                        if ($return === false) {
+                            return;
+                        }
+                        break;
+                    }
+                }
+            }
+        } while (count($userIds) >= $limit);
+    }
+
+    /**
+     * Getting all userIds that have a listLogin value requires checking the
+     * value in php because on oracle you cannot use a clob in a where clause,
+     * preventing us from doing a not null or length(value) > 0 check.
+     *
+     * @param int $limit
+     * @param int $offset
+     * @return string[] with user ids
+     */
+    private function getSeenUserIds($limit = null, $offset = null) {
+        $queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $queryBuilder->select(['userid'])
+            ->from('preferences')
+            ->where($queryBuilder->expr()->eq(
+                'appid', $queryBuilder->createNamedParameter('login'))
+            )
+            ->andWhere($queryBuilder->expr()->eq(
+                'configkey', $queryBuilder->createNamedParameter('lastLogin'))
+            )
+            ->andWhere($queryBuilder->expr()->isNotNull('configvalue')
+            );
+
+        if ($limit !== null) {
+            $queryBuilder->setMaxResults($limit);
+        }
+        if ($offset !== null) {
+            $queryBuilder->setFirstResult($offset);
+        }
+        $query = $queryBuilder->execute();
+        $result = [];
+
+        while ($row = $query->fetch()) {
+            $result[] = $row['userid'];
+        }
+
+        $query->closeCursor();
+
+        return $result;
+    }
+
+    /**
+     * @param string $email
+     * @return IUser[]
+     * @since 9.1.0
+     */
+    public function getByEmail($email) {
+        $userIds = $this->config->getUsersForUserValueCaseInsensitive('settings', 'email', $email);
+
+        $users = array_map(function ($uid) {
+            return $this->get($uid);
+        }, $userIds);
+
+        return array_values(array_filter($users, function ($u) {
+            return ($u instanceof IUser);
+        }));
+    }
+
+    private function verifyUid(string $uid): bool {
+        $appdata = 'appdata_' . $this->config->getSystemValueString('instanceid');
+
+        if (\in_array($uid, [
+            '.htaccess',
+            'files_external',
+            '__groupfolders',
+            '.ocdata',
+            'owncloud.log',
+            'nextcloud.log',
+            $appdata], true)) {
+            return false;
+        }
+
+        $dataDirectory = $this->config->getSystemValueString('datadirectory', \OC::$SERVERROOT . '/data');
+
+        return !file_exists(rtrim($dataDirectory, '/') . '/' . $uid);
+    }
 }

Spacing +15 added lines, -15 removed lines

@@ -101,7 +101,7 @@ 
 		$this->dispatcher = $oldDispatcher;
 		$this->cache = $cacheFactory->createDistributed('user_backend_map');
 		$cachedUsers = &$this->cachedUsers;
-		$this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
+		$this->listen('\OC\User', 'postDelete', function($user) use (&$cachedUsers) {
 			/** @var \OC\User\User $user */
 			unset($cachedUsers[$user->getUID()]);
 		});
@@ -228,7 +228,7 @@ 
 		$result = $this->checkPasswordNoLogging($loginName, $password);
 
 		if ($result === false) {
-			\OC::$server->getLogger()->warning('Login failed: \''. $loginName .'\' (Remote IP: \''. \OC::$server->getRequest()->getRemoteAddress(). '\')', ['app' => 'core']);
+			\OC::$server->getLogger()->warning('Login failed: \''.$loginName.'\' (Remote IP: \''.\OC::$server->getRequest()->getRemoteAddress().'\')', ['app' => 'core']);
 		}
 
 		return $result;
@@ -291,7 +291,7 @@ 
 			}
 		}
 
-		uasort($users, function ($a, $b) {
+		uasort($users, function($a, $b) {
 			/**
 			 * @var \OC\User\User $a
 			 * @var \OC\User\User $b
@@ -320,7 +320,7 @@ 
 			}
 		}
 
-		usort($users, function ($a, $b) {
+		usort($users, function($a, $b) {
 			/**
 			 * @var \OC\User\User $a
 			 * @var \OC\User\User $b
@@ -355,7 +355,7 @@ 
 			}
 		}
 
-		usort($users, function ($a, $b) {
+		usort($users, function($a, $b) {
 			/**
 			 * @var IUser $a
 			 * @var IUser $b
@@ -505,7 +505,7 @@ 
 	public function countUsersOfGroups(array $groups) {
 		$users = [];
 		foreach ($groups as $group) {
-			$usersIds = array_map(function ($user) {
+			$usersIds = array_map(function($user) {
 				return $user->getUID();
 			}, $group->getUsers());
 			$users = array_merge($users, $usersIds);
@@ -568,7 +568,7 @@ 
 		$result->closeCursor();
 
 		if ($count !== false) {
-			$count = (int)$count;
+			$count = (int) $count;
 		} else {
 			$count = 0;
 		}
@@ -585,7 +585,7 @@ 
 	 */
 	public function countDisabledUsersOfGroups(array $groups): int {
 		$queryBuilder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$queryBuilder->select($queryBuilder->createFunction('COUNT(DISTINCT ' . $queryBuilder->getColumnName('uid') . ')'))
+		$queryBuilder->select($queryBuilder->createFunction('COUNT(DISTINCT '.$queryBuilder->getColumnName('uid').')'))
 			->from('preferences', 'p')
 			->innerJoin('p', 'group_user', 'g', $queryBuilder->expr()->eq('p.userid', 'g.uid'))
 			->where($queryBuilder->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
@@ -598,7 +598,7 @@ 
 		$result->closeCursor();
 
 		if ($count !== false) {
-			$count = (int)$count;
+			$count = (int) $count;
 		} else {
 			$count = 0;
 		}
@@ -622,7 +622,7 @@ 
 
 		$query = $queryBuilder->execute();
 
-		$result = (int)$query->fetchOne();
+		$result = (int) $query->fetchOne();
 		$query->closeCursor();
 
 		return $result;
@@ -702,17 +702,17 @@ 
 	public function getByEmail($email) {
 		$userIds = $this->config->getUsersForUserValueCaseInsensitive('settings', 'email', $email);
 
-		$users = array_map(function ($uid) {
+		$users = array_map(function($uid) {
 			return $this->get($uid);
 		}, $userIds);
 
-		return array_values(array_filter($users, function ($u) {
+		return array_values(array_filter($users, function($u) {
 			return ($u instanceof IUser);
 		}));
 	}
 
 	private function verifyUid(string $uid): bool {
-		$appdata = 'appdata_' . $this->config->getSystemValueString('instanceid');
+		$appdata = 'appdata_'.$this->config->getSystemValueString('instanceid');
 
 		if (\in_array($uid, [
 			'.htaccess',
@@ -725,8 +725,8 @@ 
 			return false;
 		}
 
-		$dataDirectory = $this->config->getSystemValueString('datadirectory', \OC::$SERVERROOT . '/data');
+		$dataDirectory = $this->config->getSystemValueString('datadirectory', \OC::$SERVERROOT.'/data');
 
-		return !file_exists(rtrim($dataDirectory, '/') . '/' . $uid);
+		return !file_exists(rtrim($dataDirectory, '/').'/'.$uid);
 	}
 }