nextcloud / server

lib/public/IUserManager.php

Indentation +133 added lines, -133 removed lines

@@ -41,137 +41,137 @@
  * @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);
-
-	/**
-	 * @param string $uid
-	 * @param string $password
-	 * @throws \InvalidArgumentException
-	 * @return bool|\OCP\IUser the created user of 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
-	 * @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 countSeenUsers();
-
-	/**
-	 * @param \Closure $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);
+
+    /**
+     * @param string $uid
+     * @param string $password
+     * @throws \InvalidArgumentException
+     * @return bool|\OCP\IUser the created user of 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
+     * @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 countSeenUsers();
+
+    /**
+     * @param \Closure $callback
+     * @since 11.0.0
+     */
+    public function callForSeenUsers(\Closure $callback);
+
+    /**
+     * @param string $email
+     * @return IUser[]
+     * @since 9.1.0
+     */
+    public function getByEmail($email);
 }

lib/private/Group/MetaData.php

Spacing +6 added lines, -6 removed lines

@@ -66,7 +66,7 @@ 
 			IUserSession $userSession
 			) {
 		$this->user = $user;
-		$this->isAdmin = (bool)$isAdmin;
+		$this->isAdmin = (bool) $isAdmin;
 		$this->groupManager = $groupManager;
 		$this->userManager = $userManager;
 		$this->userSession = $userSession;
@@ -83,8 +83,8 @@ 
 	 * @return array
 	 */
 	public function get($groupSearch = '', $userSearch = '') {
-		$key = $groupSearch . '::' . $userSearch;
-		if(isset($this->metaData[$key])) {
+		$key = $groupSearch.'::'.$userSearch;
+		if (isset($this->metaData[$key])) {
 			return $this->metaData[$key];
 		}
 
@@ -95,7 +95,7 @@ 
 		$sortAdminGroupsIndex = 0;
 		$sortAdminGroupsKeys = array();
 
-		foreach($this->getGroups($groupSearch) as $group) {
+		foreach ($this->getGroups($groupSearch) as $group) {
 			$groupMetaData = $this->generateGroupMetaData($group, $userSearch);
 			if (strtolower($group->getGID()) !== 'admin') {
 				$this->addEntry(
@@ -193,11 +193,11 @@ 
 	 * @return \OCP\IGroup[]
 	 */
 	protected function getGroups($search = '') {
-		if($this->isAdmin) {
+		if ($this->isAdmin) {
 			return $this->groupManager->search($search);
 		} else {
 			$userObject = $this->userSession->getUser();
-			if($userObject !== null) {
+			if ($userObject !== null) {
 				$groups = $this->groupManager->getSubAdmin()->getSubAdminsGroups($userObject);
 			} else {
 				$groups = [];

Indentation +174 added lines, -174 removed lines

@@ -32,178 +32,178 @@
 use OCP\IUserManager;
 
 class MetaData {
-	const SORT_NONE = 0;
-	const SORT_USERCOUNT = 1; // May have performance issues on LDAP backends
-	const SORT_GROUPNAME = 2;
-
-	/** @var string */
-	protected $user;
-	/** @var bool */
-	protected $isAdmin;
-	/** @var array */
-	protected $metaData = array();
-	/** @var IGroupManager */
-	protected $groupManager;
-	/** @var IUserManager */
-	protected $userManager;
-	/** @var bool */
-	protected $sorting = false;
-	/** @var IUserSession */
-	protected $userSession;
-
-	/**
-	 * @param string $user the uid of the current user
-	 * @param bool $isAdmin whether the current users is an admin
-	 * @param IGroupManager $groupManager
-	 * @param IUserManager $userManager
-	 * @param IUserSession $userSession
-	 */
-	public function __construct(
-			$user,
-			$isAdmin,
-			IGroupManager $groupManager,
-			IUserManager $userManager,
-			IUserSession $userSession
-			) {
-		$this->user = $user;
-		$this->isAdmin = (bool)$isAdmin;
-		$this->groupManager = $groupManager;
-		$this->userManager = $userManager;
-		$this->userSession = $userSession;
-	}
-
-	/**
-	 * returns an array with meta data about all available groups
-	 * the array is structured as follows:
-	 * [0] array containing meta data about admin groups
-	 * [1] array containing meta data about unprivileged groups
-	 * @param string $groupSearch only effective when instance was created with
-	 * isAdmin being true
-	 * @param string $userSearch the pattern users are search for
-	 * @return array
-	 */
-	public function get($groupSearch = '', $userSearch = '') {
-		$key = $groupSearch . '::' . $userSearch;
-		if(isset($this->metaData[$key])) {
-			return $this->metaData[$key];
-		}
-
-		$adminGroups = array();
-		$groups = array();
-		$sortGroupsIndex = 0;
-		$sortGroupsKeys = array();
-		$sortAdminGroupsIndex = 0;
-		$sortAdminGroupsKeys = array();
-
-		foreach($this->getGroups($groupSearch) as $group) {
-			$groupMetaData = $this->generateGroupMetaData($group, $userSearch);
-			if (strtolower($group->getGID()) !== 'admin') {
-				$this->addEntry(
-					$groups,
-					$sortGroupsKeys,
-					$sortGroupsIndex,
-					$groupMetaData);
-			} else {
-				//admin group is hard coded to 'admin' for now. In future,
-				//backends may define admin groups too. Then the if statement
-				//has to be adjusted accordingly.
-				$this->addEntry(
-					$adminGroups,
-					$sortAdminGroupsKeys,
-					$sortAdminGroupsIndex,
-					$groupMetaData);
-			}
-		}
-
-		//whether sorting is necessary is will be checked in sort()
-		$this->sort($groups, $sortGroupsKeys);
-		$this->sort($adminGroups, $sortAdminGroupsKeys);
-
-		$this->metaData[$key] = array($adminGroups, $groups);
-		return $this->metaData[$key];
-	}
-
-	/**
-	 * sets the sort mode, see SORT_* constants for supported modes
-	 *
-	 * @param int $sortMode
-	 */
-	public function setSorting($sortMode) {
-		switch ($sortMode) {
-			case self::SORT_USERCOUNT:
-			case self::SORT_GROUPNAME:
-				$this->sorting = $sortMode;
-				break;
-
-			default:
-				$this->sorting = self::SORT_NONE;
-		}
-	}
-
-	/**
-	 * adds an group entry to the resulting array
-	 * @param array $entries the resulting array, by reference
-	 * @param array $sortKeys the sort key array, by reference
-	 * @param int $sortIndex the sort key index, by reference
-	 * @param array $data the group's meta data as returned by generateGroupMetaData()
-	 */
-	private function addEntry(&$entries, &$sortKeys, &$sortIndex, $data) {
-		$entries[] = $data;
-		if ($this->sorting === self::SORT_USERCOUNT) {
-			$sortKeys[$sortIndex] = $data['usercount'];
-			$sortIndex++;
-		} else if ($this->sorting === self::SORT_GROUPNAME) {
-			$sortKeys[$sortIndex] = $data['name'];
-			$sortIndex++;
-		}
-	}
-
-	/**
-	 * creates an array containing the group meta data
-	 * @param \OCP\IGroup $group
-	 * @param string $userSearch
-	 * @return array with the keys 'id', 'name', 'usercount' and 'disabled'
-	 */
-	private function generateGroupMetaData(\OCP\IGroup $group, $userSearch) {
-		return array(
-				'id' => $group->getGID(),
-				'name' => $group->getDisplayName(),
-				'usercount' => $this->sorting === self::SORT_USERCOUNT ? $group->count($userSearch) : 0,
-				'disabled' => $group->countDisabled()
-			);
-	}
-
-	/**
-	 * sorts the result array, if applicable
-	 * @param array $entries the result array, by reference
-	 * @param array $sortKeys the array containing the sort keys
-	 * @param return null
-	 */
-	private function sort(&$entries, $sortKeys) {
-		if ($this->sorting === self::SORT_USERCOUNT) {
-			array_multisort($sortKeys, SORT_DESC, $entries);
-		} else if ($this->sorting === self::SORT_GROUPNAME) {
-			array_multisort($sortKeys, SORT_ASC, $entries);
-		}
-	}
-
-	/**
-	 * returns the available groups
-	 * @param string $search a search string
-	 * @return \OCP\IGroup[]
-	 */
-	protected function getGroups($search = '') {
-		if($this->isAdmin) {
-			return $this->groupManager->search($search);
-		} else {
-			$userObject = $this->userSession->getUser();
-			if($userObject !== null) {
-				$groups = $this->groupManager->getSubAdmin()->getSubAdminsGroups($userObject);
-			} else {
-				$groups = [];
-			}
-
-			return $groups;
-		}
-	}
+    const SORT_NONE = 0;
+    const SORT_USERCOUNT = 1; // May have performance issues on LDAP backends
+    const SORT_GROUPNAME = 2;
+
+    /** @var string */
+    protected $user;
+    /** @var bool */
+    protected $isAdmin;
+    /** @var array */
+    protected $metaData = array();
+    /** @var IGroupManager */
+    protected $groupManager;
+    /** @var IUserManager */
+    protected $userManager;
+    /** @var bool */
+    protected $sorting = false;
+    /** @var IUserSession */
+    protected $userSession;
+
+    /**
+     * @param string $user the uid of the current user
+     * @param bool $isAdmin whether the current users is an admin
+     * @param IGroupManager $groupManager
+     * @param IUserManager $userManager
+     * @param IUserSession $userSession
+     */
+    public function __construct(
+            $user,
+            $isAdmin,
+            IGroupManager $groupManager,
+            IUserManager $userManager,
+            IUserSession $userSession
+            ) {
+        $this->user = $user;
+        $this->isAdmin = (bool)$isAdmin;
+        $this->groupManager = $groupManager;
+        $this->userManager = $userManager;
+        $this->userSession = $userSession;
+    }
+
+    /**
+     * returns an array with meta data about all available groups
+     * the array is structured as follows:
+     * [0] array containing meta data about admin groups
+     * [1] array containing meta data about unprivileged groups
+     * @param string $groupSearch only effective when instance was created with
+     * isAdmin being true
+     * @param string $userSearch the pattern users are search for
+     * @return array
+     */
+    public function get($groupSearch = '', $userSearch = '') {
+        $key = $groupSearch . '::' . $userSearch;
+        if(isset($this->metaData[$key])) {
+            return $this->metaData[$key];
+        }
+
+        $adminGroups = array();
+        $groups = array();
+        $sortGroupsIndex = 0;
+        $sortGroupsKeys = array();
+        $sortAdminGroupsIndex = 0;
+        $sortAdminGroupsKeys = array();
+
+        foreach($this->getGroups($groupSearch) as $group) {
+            $groupMetaData = $this->generateGroupMetaData($group, $userSearch);
+            if (strtolower($group->getGID()) !== 'admin') {
+                $this->addEntry(
+                    $groups,
+                    $sortGroupsKeys,
+                    $sortGroupsIndex,
+                    $groupMetaData);
+            } else {
+                //admin group is hard coded to 'admin' for now. In future,
+                //backends may define admin groups too. Then the if statement
+                //has to be adjusted accordingly.
+                $this->addEntry(
+                    $adminGroups,
+                    $sortAdminGroupsKeys,
+                    $sortAdminGroupsIndex,
+                    $groupMetaData);
+            }
+        }
+
+        //whether sorting is necessary is will be checked in sort()
+        $this->sort($groups, $sortGroupsKeys);
+        $this->sort($adminGroups, $sortAdminGroupsKeys);
+
+        $this->metaData[$key] = array($adminGroups, $groups);
+        return $this->metaData[$key];
+    }
+
+    /**
+     * sets the sort mode, see SORT_* constants for supported modes
+     *
+     * @param int $sortMode
+     */
+    public function setSorting($sortMode) {
+        switch ($sortMode) {
+            case self::SORT_USERCOUNT:
+            case self::SORT_GROUPNAME:
+                $this->sorting = $sortMode;
+                break;
+
+            default:
+                $this->sorting = self::SORT_NONE;
+        }
+    }
+
+    /**
+     * adds an group entry to the resulting array
+     * @param array $entries the resulting array, by reference
+     * @param array $sortKeys the sort key array, by reference
+     * @param int $sortIndex the sort key index, by reference
+     * @param array $data the group's meta data as returned by generateGroupMetaData()
+     */
+    private function addEntry(&$entries, &$sortKeys, &$sortIndex, $data) {
+        $entries[] = $data;
+        if ($this->sorting === self::SORT_USERCOUNT) {
+            $sortKeys[$sortIndex] = $data['usercount'];
+            $sortIndex++;
+        } else if ($this->sorting === self::SORT_GROUPNAME) {
+            $sortKeys[$sortIndex] = $data['name'];
+            $sortIndex++;
+        }
+    }
+
+    /**
+     * creates an array containing the group meta data
+     * @param \OCP\IGroup $group
+     * @param string $userSearch
+     * @return array with the keys 'id', 'name', 'usercount' and 'disabled'
+     */
+    private function generateGroupMetaData(\OCP\IGroup $group, $userSearch) {
+        return array(
+                'id' => $group->getGID(),
+                'name' => $group->getDisplayName(),
+                'usercount' => $this->sorting === self::SORT_USERCOUNT ? $group->count($userSearch) : 0,
+                'disabled' => $group->countDisabled()
+            );
+    }
+
+    /**
+     * sorts the result array, if applicable
+     * @param array $entries the result array, by reference
+     * @param array $sortKeys the array containing the sort keys
+     * @param return null
+     */
+    private function sort(&$entries, $sortKeys) {
+        if ($this->sorting === self::SORT_USERCOUNT) {
+            array_multisort($sortKeys, SORT_DESC, $entries);
+        } else if ($this->sorting === self::SORT_GROUPNAME) {
+            array_multisort($sortKeys, SORT_ASC, $entries);
+        }
+    }
+
+    /**
+     * returns the available groups
+     * @param string $search a search string
+     * @return \OCP\IGroup[]
+     */
+    protected function getGroups($search = '') {
+        if($this->isAdmin) {
+            return $this->groupManager->search($search);
+        } else {
+            $userObject = $this->userSession->getUser();
+            if($userObject !== null) {
+                $groups = $this->groupManager->getSubAdmin()->getSubAdminsGroups($userObject);
+            } else {
+                $groups = [];
+            }
+
+            return $groups;
+        }
+    }
 }

settings/users.php

Indentation +42 added lines, -42 removed lines

@@ -48,18 +48,18 @@ 
 $config = \OC::$server->getConfig();
 
 if ($config->getSystemValue('sort_groups_by_name', false)) {
-	$sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
+    $sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
 } else {
-	$isLDAPUsed = false;
-	if ($appManager->isEnabledForUser('user_ldap')) {
-		$isLDAPUsed =
-			$groupManager->isBackendUsed('\OCA\User_LDAP\Group_LDAP')
-			|| $groupManager->isBackendUsed('\OCA\User_LDAP\Group_Proxy');
-		if ($isLDAPUsed) {
-			// LDAP user count can be slow, so we sort by group name here
-			$sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
-		}
-	}
+    $isLDAPUsed = false;
+    if ($appManager->isEnabledForUser('user_ldap')) {
+        $isLDAPUsed =
+            $groupManager->isBackendUsed('\OCA\User_LDAP\Group_LDAP')
+            || $groupManager->isBackendUsed('\OCA\User_LDAP\Group_Proxy');
+        if ($isLDAPUsed) {
+            // LDAP user count can be slow, so we sort by group name here
+            $sortGroupsBy = \OC\Group\MetaData::SORT_GROUPNAME;
+        }
+    }
 }
 
 $uid = \OC_User::getUser();
@@ -68,68 +68,68 @@ 
 $isDisabled = true;
 $user = $userManager->get($uid);
 if ($user) {
-	$isDisabled = !$user->isEnabled();
+    $isDisabled = !$user->isEnabled();
 }
 
 $groupsInfo = new \OC\Group\MetaData(
-	$uid,
-	$isAdmin,
-	$groupManager,
-	$userManager,
-	\OC::$server->getUserSession()
+    $uid,
+    $isAdmin,
+    $groupManager,
+    $userManager,
+    \OC::$server->getUserSession()
 );
 
 $groupsInfo->setSorting($sortGroupsBy);
 list($adminGroup, $groups) = $groupsInfo->get();
 
 $recoveryAdminEnabled = $appManager->isEnabledForUser('encryption') &&
-					    $config->getAppValue( 'encryption', 'recoveryAdminEnabled', '0');
+                        $config->getAppValue( 'encryption', 'recoveryAdminEnabled', '0');
 
 if ($isAdmin) {
-	$subAdmins = \OC::$server->getGroupManager()->getSubAdmin()->getAllSubAdmins();
-	// New class returns IUser[] so convert back
-	$result = [];
-	foreach ($subAdmins as $subAdmin) {
-		$result[] = [
-			'gid' => $subAdmin['group']->getGID(),
-			'uid' => $subAdmin['user']->getUID(),
-		];
-	}
-	$subAdmins = $result;
+    $subAdmins = \OC::$server->getGroupManager()->getSubAdmin()->getAllSubAdmins();
+    // New class returns IUser[] so convert back
+    $result = [];
+    foreach ($subAdmins as $subAdmin) {
+        $result[] = [
+            'gid' => $subAdmin['group']->getGID(),
+            'uid' => $subAdmin['user']->getUID(),
+        ];
+    }
+    $subAdmins = $result;
 } else {
-	/* Retrieve group IDs from $groups array, so we can pass that information into OC_Group::displayNamesInGroups() */
-	$gids = array();
-	foreach($groups as $group) {
-		if (isset($group['id'])) {
-			$gids[] = $group['id'];
-		}
-	}
-	$subAdmins = false;
+    /* Retrieve group IDs from $groups array, so we can pass that information into OC_Group::displayNamesInGroups() */
+    $gids = array();
+    foreach($groups as $group) {
+        if (isset($group['id'])) {
+            $gids[] = $group['id'];
+        }
+    }
+    $subAdmins = false;
 }
 
 // remove disabled from total count
 foreach($groups as $key => $group) {
-	$groups[$key]['usercount'] -= $group['disabled'];
+    $groups[$key]['usercount'] -= $group['disabled'];
 }
 
 $disabledUsers = $isLDAPUsed ? 0 : $isAdmin ? $userManager->countDisabledUsers() : $userManager->countDisabledUsersOfGroups();
 $disabledUsersGroup = [
-	'id' => '_disabledUsers',
-	'name' => '_disabledUsers',
-	'usercount' => $disabledUsers
+    'id' => '_disabledUsers',
+    'name' => '_disabledUsers',
+    'usercount' => $disabledUsers
 ];
 
 // load preset quotas
 $quotaPreset=$config->getAppValue('files', 'quota_preset', '1 GB, 5 GB, 10 GB');
 $quotaPreset=explode(',', $quotaPreset);
 foreach($quotaPreset as &$preset) {
-	$preset=trim($preset);
+    $preset=trim($preset);
 }
 $quotaPreset=array_diff($quotaPreset, array('default', 'none'));
 
 $defaultQuota=$config->getAppValue('files', 'default_quota', 'none');
 $defaultQuotaIsUserDefined=array_search($defaultQuota, $quotaPreset)===false
-	&& array_search($defaultQuota, array('none', 'default'))===false;
+    && array_search($defaultQuota, array('none', 'default'))===false;
 
 \OC::$server->getEventDispatcher()->dispatch('OC\Settings\Users::loadAdditionalScripts');
 

Spacing +12 added lines, -12 removed lines

@@ -83,7 +83,7 @@ 
 list($adminGroup, $groups) = $groupsInfo->get();
 
 $recoveryAdminEnabled = $appManager->isEnabledForUser('encryption') &&
-					    $config->getAppValue( 'encryption', 'recoveryAdminEnabled', '0');
+					    $config->getAppValue('encryption', 'recoveryAdminEnabled', '0');
 
 if ($isAdmin) {
 	$subAdmins = \OC::$server->getGroupManager()->getSubAdmin()->getAllSubAdmins();
@@ -99,7 +99,7 @@ 
 } else {
 	/* Retrieve group IDs from $groups array, so we can pass that information into OC_Group::displayNamesInGroups() */
 	$gids = array();
-	foreach($groups as $group) {
+	foreach ($groups as $group) {
 		if (isset($group['id'])) {
 			$gids[] = $group['id'];
 		}
@@ -108,7 +108,7 @@ 
 }
 
 // remove disabled from total count
-foreach($groups as $key => $group) {
+foreach ($groups as $key => $group) {
 	$groups[$key]['usercount'] -= $group['disabled'];
 }
 
@@ -120,16 +120,16 @@ 
 ];
 
 // load preset quotas
-$quotaPreset=$config->getAppValue('files', 'quota_preset', '1 GB, 5 GB, 10 GB');
-$quotaPreset=explode(',', $quotaPreset);
-foreach($quotaPreset as &$preset) {
-	$preset=trim($preset);
+$quotaPreset = $config->getAppValue('files', 'quota_preset', '1 GB, 5 GB, 10 GB');
+$quotaPreset = explode(',', $quotaPreset);
+foreach ($quotaPreset as &$preset) {
+	$preset = trim($preset);
 }
-$quotaPreset=array_diff($quotaPreset, array('default', 'none'));
+$quotaPreset = array_diff($quotaPreset, array('default', 'none'));
 
-$defaultQuota=$config->getAppValue('files', 'default_quota', 'none');
-$defaultQuotaIsUserDefined=array_search($defaultQuota, $quotaPreset)===false
-	&& array_search($defaultQuota, array('none', 'default'))===false;
+$defaultQuota = $config->getAppValue('files', 'default_quota', 'none');
+$defaultQuotaIsUserDefined = array_search($defaultQuota, $quotaPreset) === false
+	&& array_search($defaultQuota, array('none', 'default')) === false;
 
 \OC::$server->getEventDispatcher()->dispatch('OC\Settings\Users::loadAdditionalScripts');
 
@@ -138,7 +138,7 @@ 
 $tmpl->assign('sortGroups', $sortGroupsBy);
 $tmpl->assign('adminGroup', $adminGroup);
 $tmpl->assign('disabledUsersGroup', $disabledUsersGroup);
-$tmpl->assign('isAdmin', (int)$isAdmin);
+$tmpl->assign('isAdmin', (int) $isAdmin);
 $tmpl->assign('subadmins', $subAdmins);
 $tmpl->assign('numofgroups', count($groups) + count($adminGroup));
 $tmpl->assign('quota_preset', $quotaPreset);

settings/Controller/GroupsController.php

Indentation +113 added lines, -113 removed lines

@@ -39,125 +39,125 @@
  * @package OC\Settings\Controller
  */
 class GroupsController extends Controller {
-	/** @var IGroupManager */
-	private $groupManager;
-	/** @var IUserManager */
-	private $userManager;
-	/** @var IL10N */
-	private $l10n;
-	/** @var IUserSession */
-	private $userSession;
-	/** @var bool */
-	private $isAdmin;
+    /** @var IGroupManager */
+    private $groupManager;
+    /** @var IUserManager */
+    private $userManager;
+    /** @var IL10N */
+    private $l10n;
+    /** @var IUserSession */
+    private $userSession;
+    /** @var bool */
+    private $isAdmin;
 
-	/**
-	 * @param string $appName
-	 * @param IRequest $request
-	 * @param IGroupManager $groupManager
-	 * @param IUserSession $userSession
-	 * @param bool $isAdmin
-	 * @param IL10N $l10n
-	 */
-	public function __construct($appName,
-								IRequest $request,
-								IGroupManager $groupManager,
-								IUserManager $userManager,
-								IUserSession $userSession,
-								$isAdmin,
-								IL10N $l10n) {
-		parent::__construct($appName, $request);
-		$this->groupManager = $groupManager;
-		$this->userManager = $userManager;
-		$this->userSession = $userSession;
-		$this->isAdmin = $isAdmin;
-		$this->l10n = $l10n;
-	}
+    /**
+     * @param string $appName
+     * @param IRequest $request
+     * @param IGroupManager $groupManager
+     * @param IUserSession $userSession
+     * @param bool $isAdmin
+     * @param IL10N $l10n
+     */
+    public function __construct($appName,
+                                IRequest $request,
+                                IGroupManager $groupManager,
+                                IUserManager $userManager,
+                                IUserSession $userSession,
+                                $isAdmin,
+                                IL10N $l10n) {
+        parent::__construct($appName, $request);
+        $this->groupManager = $groupManager;
+        $this->userManager = $userManager;
+        $this->userSession = $userSession;
+        $this->isAdmin = $isAdmin;
+        $this->l10n = $l10n;
+    }
 
-	/**
-	 * @NoAdminRequired
-	 *
-	 * @param string $pattern
-	 * @param bool $filterGroups
-	 * @param int $sortGroups
-	 * @return DataResponse
-	 */
-	public function index($pattern = '', $filterGroups = false, $sortGroups = MetaData::SORT_USERCOUNT) {
-		$groupPattern = $filterGroups ? $pattern : '';
+    /**
+     * @NoAdminRequired
+     *
+     * @param string $pattern
+     * @param bool $filterGroups
+     * @param int $sortGroups
+     * @return DataResponse
+     */
+    public function index($pattern = '', $filterGroups = false, $sortGroups = MetaData::SORT_USERCOUNT) {
+        $groupPattern = $filterGroups ? $pattern : '';
 
-		$groupsInfo = new MetaData(
-			$this->userSession->getUser()->getUID(),
-			$this->isAdmin,
-			$this->groupManager,
-			$this->userManager,
-			$this->userSession
-		);
-		$groupsInfo->setSorting($sortGroups);
-		list($adminGroups, $groups) = $groupsInfo->get($groupPattern, $pattern);
+        $groupsInfo = new MetaData(
+            $this->userSession->getUser()->getUID(),
+            $this->isAdmin,
+            $this->groupManager,
+            $this->userManager,
+            $this->userSession
+        );
+        $groupsInfo->setSorting($sortGroups);
+        list($adminGroups, $groups) = $groupsInfo->get($groupPattern, $pattern);
 
-		return new DataResponse(
-			array(
-				'data' => array('adminGroups' => $adminGroups, 'groups' => $groups)
-			)
-		);
-	}
+        return new DataResponse(
+            array(
+                'data' => array('adminGroups' => $adminGroups, 'groups' => $groups)
+            )
+        );
+    }
 
-	/**
-	 * @PasswordConfirmationRequired
-	 * @param string $id
-	 * @return DataResponse
-	 */
-	public function create($id) {
-		if($this->groupManager->groupExists($id)) {
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Group already exists.')
-				),
-				Http::STATUS_CONFLICT
-			);
-		}
-		$group = $this->groupManager->createGroup($id);
-		if($group instanceof IGroup) {
-			return new DataResponse(['groupname' => $group->getDisplayName()], Http::STATUS_CREATED);
-		}
+    /**
+     * @PasswordConfirmationRequired
+     * @param string $id
+     * @return DataResponse
+     */
+    public function create($id) {
+        if($this->groupManager->groupExists($id)) {
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Group already exists.')
+                ),
+                Http::STATUS_CONFLICT
+            );
+        }
+        $group = $this->groupManager->createGroup($id);
+        if($group instanceof IGroup) {
+            return new DataResponse(['groupname' => $group->getDisplayName()], Http::STATUS_CREATED);
+        }
 
-		return new DataResponse(
-			array(
-				'status' => 'error',
-				'data' => array(
-					'message' => (string)$this->l10n->t('Unable to add group.')
-				)
-			),
-			Http::STATUS_FORBIDDEN
-		);
-	}
+        return new DataResponse(
+            array(
+                'status' => 'error',
+                'data' => array(
+                    'message' => (string)$this->l10n->t('Unable to add group.')
+                )
+            ),
+            Http::STATUS_FORBIDDEN
+        );
+    }
 
-	/**
-	 * @PasswordConfirmationRequired
-	 * @param string $id
-	 * @return DataResponse
-	 */
-	public function destroy($id) {
-		$group = $this->groupManager->get($id);
-		if ($group) {
-			if ($group->delete()) {
-				return new DataResponse(
-					array(
-						'status' => 'success',
-						'data' => ['groupname' => $group->getDisplayName()]
-					),
-					Http::STATUS_NO_CONTENT
-				);
-			}
-		}
-		return new DataResponse(
-			array(
-				'status' => 'error',
-				'data' => array(
-					'message' => (string)$this->l10n->t('Unable to delete group.')
-				),
-			),
-			Http::STATUS_FORBIDDEN
-		);
-	}
+    /**
+     * @PasswordConfirmationRequired
+     * @param string $id
+     * @return DataResponse
+     */
+    public function destroy($id) {
+        $group = $this->groupManager->get($id);
+        if ($group) {
+            if ($group->delete()) {
+                return new DataResponse(
+                    array(
+                        'status' => 'success',
+                        'data' => ['groupname' => $group->getDisplayName()]
+                    ),
+                    Http::STATUS_NO_CONTENT
+                );
+            }
+        }
+        return new DataResponse(
+            array(
+                'status' => 'error',
+                'data' => array(
+                    'message' => (string)$this->l10n->t('Unable to delete group.')
+                ),
+            ),
+            Http::STATUS_FORBIDDEN
+        );
+    }
 
 }

lib/private/Group/Database.php

Doc Comments -1 removed lines

@@ -362,7 +362,6 @@
 	/**
 	 * get the number of disabled users in a group
 	 *
-	 * @param string $search
 	 * @return int|bool
 	 */
 	public function countDisabledInGroup($gid) {

Indentation +337 added lines, -337 removed lines

@@ -47,343 +47,343 @@
  */
 class Database extends Backend {
 
-	/** @var string[] */
-	private $groupCache = [];
-
-	/** @var IDBConnection */
-	private $dbConn;
-
-	/**
-	 * \OC\Group\Database constructor.
-	 *
-	 * @param IDBConnection|null $dbConn
-	 */
-	public function __construct(IDBConnection $dbConn = null) {
-		$this->dbConn = $dbConn;
-	}
-
-	/**
-	 * FIXME: This function should not be required!
-	 */
-	private function fixDI() {
-		if ($this->dbConn === null) {
-			$this->dbConn = \OC::$server->getDatabaseConnection();
-		}
-	}
-
-	/**
-	 * Try to create a new group
-	 * @param string $gid The name of the group to create
-	 * @return bool
-	 *
-	 * Tries to create a new group. If the group name already exists, false will
-	 * be returned.
-	 */
-	public function createGroup( $gid ) {
-		$this->fixDI();
-
-		// Add group
-		$result = $this->dbConn->insertIfNotExist('*PREFIX*groups', [
-			'gid' => $gid,
-		]);
-
-		// Add to cache
-		$this->groupCache[$gid] = $gid;
-
-		return $result === 1;
-	}
-
-	/**
-	 * delete a group
-	 * @param string $gid gid of the group to delete
-	 * @return bool
-	 *
-	 * Deletes a group and removes it from the group_user-table
-	 */
-	public function deleteGroup( $gid ) {
-		$this->fixDI();
-
-		// Delete the group
-		$qb = $this->dbConn->getQueryBuilder();
-		$qb->delete('groups')
-			->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->execute();
-
-		// Delete the group-user relation
-		$qb = $this->dbConn->getQueryBuilder();
-		$qb->delete('group_user')
-			->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->execute();
-
-		// Delete the group-groupadmin relation
-		$qb = $this->dbConn->getQueryBuilder();
-		$qb->delete('group_admin')
-			->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->execute();
-
-		// Delete from cache
-		unset($this->groupCache[$gid]);
-
-		return true;
-	}
-
-	/**
-	 * is user in group?
-	 * @param string $uid uid of the user
-	 * @param string $gid gid of the group
-	 * @return bool
-	 *
-	 * Checks whether the user is member of a group or not.
-	 */
-	public function inGroup( $uid, $gid ) {
-		$this->fixDI();
-
-		// check
-		$qb = $this->dbConn->getQueryBuilder();
-		$cursor = $qb->select('uid')
-			->from('group_user')
-			->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->andWhere($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->execute();
-
-		$result = $cursor->fetch();
-		$cursor->closeCursor();
-
-		return $result ? true : false;
-	}
-
-	/**
-	 * Add a user to a group
-	 * @param string $uid Name of the user to add to group
-	 * @param string $gid Name of the group in which add the user
-	 * @return bool
-	 *
-	 * Adds a user to a group.
-	 */
-	public function addToGroup( $uid, $gid ) {
-		$this->fixDI();
-
-		// No duplicate entries!
-		if( !$this->inGroup( $uid, $gid )) {
-			$qb = $this->dbConn->getQueryBuilder();
-			$qb->insert('group_user')
-				->setValue('uid', $qb->createNamedParameter($uid))
-				->setValue('gid', $qb->createNamedParameter($gid))
-				->execute();
-			return true;
-		}else{
-			return false;
-		}
-	}
-
-	/**
-	 * Removes a user from a group
-	 * @param string $uid Name of the user to remove from group
-	 * @param string $gid Name of the group from which remove the user
-	 * @return bool
-	 *
-	 * removes the user from a group.
-	 */
-	public function removeFromGroup( $uid, $gid ) {
-		$this->fixDI();
-
-		$qb = $this->dbConn->getQueryBuilder();
-		$qb->delete('group_user')
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->andWhere($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->execute();
-
-		return true;
-	}
-
-	/**
-	 * Get all groups a user belongs to
-	 * @param string $uid Name of the user
-	 * @return array an array of group names
-	 *
-	 * This function fetches all groups a user belongs to. It does not check
-	 * if the user exists at all.
-	 */
-	public function getUserGroups( $uid ) {
-		//guests has empty or null $uid
-		if ($uid === null || $uid === '') {
-			return [];
-		}
-
-		$this->fixDI();
-
-		// No magic!
-		$qb = $this->dbConn->getQueryBuilder();
-		$cursor = $qb->select('gid')
-			->from('group_user')
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->execute();
-
-		$groups = [];
-		while( $row = $cursor->fetch()) {
-			$groups[] = $row['gid'];
-			$this->groupCache[$row['gid']] = $row['gid'];
-		}
-		$cursor->closeCursor();
-
-		return $groups;
-	}
-
-	/**
-	 * get a list of all groups
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return array an array of group names
-	 *
-	 * Returns a list with all groups
-	 */
-	public function getGroups($search = '', $limit = null, $offset = null) {
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-		$query->select('gid')
-			->from('groups')
-			->orderBy('gid', 'ASC');
-
-		if ($search !== '') {
-			$query->where($query->expr()->iLike('gid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
-			)));
-		}
-
-		$query->setMaxResults($limit)
-			->setFirstResult($offset);
-		$result = $query->execute();
-
-		$groups = [];
-		while ($row = $result->fetch()) {
-			$groups[] = $row['gid'];
-		}
-		$result->closeCursor();
-
-		return $groups;
-	}
-
-	/**
-	 * check if a group exists
-	 * @param string $gid
-	 * @return bool
-	 */
-	public function groupExists($gid) {
-		$this->fixDI();
-
-		// Check cache first
-		if (isset($this->groupCache[$gid])) {
-			return true;
-		}
-
-		$qb = $this->dbConn->getQueryBuilder();
-		$cursor = $qb->select('gid')
-			->from('groups')
-			->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
-			->execute();
-		$result = $cursor->fetch();
-		$cursor->closeCursor();
-
-		if ($result !== false) {
-			$this->groupCache[$gid] = $gid;
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * get a list of all users in a group
-	 * @param string $gid
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return array an array of user ids
-	 */
-	public function usersInGroup($gid, $search = '', $limit = null, $offset = null) {
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-		$query->select('uid')
-			->from('group_user')
-			->where($query->expr()->eq('gid', $query->createNamedParameter($gid)))
-			->orderBy('uid', 'ASC');
-
-		if ($search !== '') {
-			$query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
-			)));
-		}
-
-		$query->setMaxResults($limit)
-			->setFirstResult($offset);
-		$result = $query->execute();
-
-		$users = [];
-		while ($row = $result->fetch()) {
-			$users[] = $row['uid'];
-		}
-		$result->closeCursor();
-
-		return $users;
-	}
-
-	/**
-	 * get the number of all users matching the search string in a group
-	 * @param string $gid
-	 * @param string $search
-	 * @return int|false
-	 */
-	public function countUsersInGroup($gid, $search = '') {
-		$this->fixDI();
-
-		$query = $this->dbConn->getQueryBuilder();
-		$query->selectAlias($query->createFunction('COUNT(*)'), 'num_users')
-			->from('group_user')
-			->where($query->expr()->eq('gid', $query->createNamedParameter($gid)));
-
-		if ($search !== '') {
-			$query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
-			)));
-		}
-
-		$result = $query->execute();
-		$count = $result->fetchColumn();
-		$result->closeCursor();
-
-		if ($count !== false) {
-			$count = (int)$count;
-		}
-		return $count;
-	}
-
-	/**
-	 * get the number of disabled users in a group
-	 *
-	 * @param string $search
-	 * @return int|bool
-	 */
-	public function countDisabledInGroup($gid) {
-		$this->fixDI();
+    /** @var string[] */
+    private $groupCache = [];
+
+    /** @var IDBConnection */
+    private $dbConn;
+
+    /**
+     * \OC\Group\Database constructor.
+     *
+     * @param IDBConnection|null $dbConn
+     */
+    public function __construct(IDBConnection $dbConn = null) {
+        $this->dbConn = $dbConn;
+    }
+
+    /**
+     * FIXME: This function should not be required!
+     */
+    private function fixDI() {
+        if ($this->dbConn === null) {
+            $this->dbConn = \OC::$server->getDatabaseConnection();
+        }
+    }
+
+    /**
+     * Try to create a new group
+     * @param string $gid The name of the group to create
+     * @return bool
+     *
+     * Tries to create a new group. If the group name already exists, false will
+     * be returned.
+     */
+    public function createGroup( $gid ) {
+        $this->fixDI();
+
+        // Add group
+        $result = $this->dbConn->insertIfNotExist('*PREFIX*groups', [
+            'gid' => $gid,
+        ]);
+
+        // Add to cache
+        $this->groupCache[$gid] = $gid;
+
+        return $result === 1;
+    }
+
+    /**
+     * delete a group
+     * @param string $gid gid of the group to delete
+     * @return bool
+     *
+     * Deletes a group and removes it from the group_user-table
+     */
+    public function deleteGroup( $gid ) {
+        $this->fixDI();
+
+        // Delete the group
+        $qb = $this->dbConn->getQueryBuilder();
+        $qb->delete('groups')
+            ->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->execute();
+
+        // Delete the group-user relation
+        $qb = $this->dbConn->getQueryBuilder();
+        $qb->delete('group_user')
+            ->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->execute();
+
+        // Delete the group-groupadmin relation
+        $qb = $this->dbConn->getQueryBuilder();
+        $qb->delete('group_admin')
+            ->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->execute();
+
+        // Delete from cache
+        unset($this->groupCache[$gid]);
+
+        return true;
+    }
+
+    /**
+     * is user in group?
+     * @param string $uid uid of the user
+     * @param string $gid gid of the group
+     * @return bool
+     *
+     * Checks whether the user is member of a group or not.
+     */
+    public function inGroup( $uid, $gid ) {
+        $this->fixDI();
+
+        // check
+        $qb = $this->dbConn->getQueryBuilder();
+        $cursor = $qb->select('uid')
+            ->from('group_user')
+            ->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->andWhere($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->execute();
+
+        $result = $cursor->fetch();
+        $cursor->closeCursor();
+
+        return $result ? true : false;
+    }
+
+    /**
+     * Add a user to a group
+     * @param string $uid Name of the user to add to group
+     * @param string $gid Name of the group in which add the user
+     * @return bool
+     *
+     * Adds a user to a group.
+     */
+    public function addToGroup( $uid, $gid ) {
+        $this->fixDI();
+
+        // No duplicate entries!
+        if( !$this->inGroup( $uid, $gid )) {
+            $qb = $this->dbConn->getQueryBuilder();
+            $qb->insert('group_user')
+                ->setValue('uid', $qb->createNamedParameter($uid))
+                ->setValue('gid', $qb->createNamedParameter($gid))
+                ->execute();
+            return true;
+        }else{
+            return false;
+        }
+    }
+
+    /**
+     * Removes a user from a group
+     * @param string $uid Name of the user to remove from group
+     * @param string $gid Name of the group from which remove the user
+     * @return bool
+     *
+     * removes the user from a group.
+     */
+    public function removeFromGroup( $uid, $gid ) {
+        $this->fixDI();
+
+        $qb = $this->dbConn->getQueryBuilder();
+        $qb->delete('group_user')
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->andWhere($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->execute();
+
+        return true;
+    }
+
+    /**
+     * Get all groups a user belongs to
+     * @param string $uid Name of the user
+     * @return array an array of group names
+     *
+     * This function fetches all groups a user belongs to. It does not check
+     * if the user exists at all.
+     */
+    public function getUserGroups( $uid ) {
+        //guests has empty or null $uid
+        if ($uid === null || $uid === '') {
+            return [];
+        }
+
+        $this->fixDI();
+
+        // No magic!
+        $qb = $this->dbConn->getQueryBuilder();
+        $cursor = $qb->select('gid')
+            ->from('group_user')
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->execute();
+
+        $groups = [];
+        while( $row = $cursor->fetch()) {
+            $groups[] = $row['gid'];
+            $this->groupCache[$row['gid']] = $row['gid'];
+        }
+        $cursor->closeCursor();
+
+        return $groups;
+    }
+
+    /**
+     * get a list of all groups
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return array an array of group names
+     *
+     * Returns a list with all groups
+     */
+    public function getGroups($search = '', $limit = null, $offset = null) {
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+        $query->select('gid')
+            ->from('groups')
+            ->orderBy('gid', 'ASC');
+
+        if ($search !== '') {
+            $query->where($query->expr()->iLike('gid', $query->createNamedParameter(
+                '%' . $this->dbConn->escapeLikeParameter($search) . '%'
+            )));
+        }
+
+        $query->setMaxResults($limit)
+            ->setFirstResult($offset);
+        $result = $query->execute();
+
+        $groups = [];
+        while ($row = $result->fetch()) {
+            $groups[] = $row['gid'];
+        }
+        $result->closeCursor();
+
+        return $groups;
+    }
+
+    /**
+     * check if a group exists
+     * @param string $gid
+     * @return bool
+     */
+    public function groupExists($gid) {
+        $this->fixDI();
+
+        // Check cache first
+        if (isset($this->groupCache[$gid])) {
+            return true;
+        }
+
+        $qb = $this->dbConn->getQueryBuilder();
+        $cursor = $qb->select('gid')
+            ->from('groups')
+            ->where($qb->expr()->eq('gid', $qb->createNamedParameter($gid)))
+            ->execute();
+        $result = $cursor->fetch();
+        $cursor->closeCursor();
+
+        if ($result !== false) {
+            $this->groupCache[$gid] = $gid;
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * get a list of all users in a group
+     * @param string $gid
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return array an array of user ids
+     */
+    public function usersInGroup($gid, $search = '', $limit = null, $offset = null) {
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+        $query->select('uid')
+            ->from('group_user')
+            ->where($query->expr()->eq('gid', $query->createNamedParameter($gid)))
+            ->orderBy('uid', 'ASC');
+
+        if ($search !== '') {
+            $query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
+                '%' . $this->dbConn->escapeLikeParameter($search) . '%'
+            )));
+        }
+
+        $query->setMaxResults($limit)
+            ->setFirstResult($offset);
+        $result = $query->execute();
+
+        $users = [];
+        while ($row = $result->fetch()) {
+            $users[] = $row['uid'];
+        }
+        $result->closeCursor();
+
+        return $users;
+    }
+
+    /**
+     * get the number of all users matching the search string in a group
+     * @param string $gid
+     * @param string $search
+     * @return int|false
+     */
+    public function countUsersInGroup($gid, $search = '') {
+        $this->fixDI();
+
+        $query = $this->dbConn->getQueryBuilder();
+        $query->selectAlias($query->createFunction('COUNT(*)'), 'num_users')
+            ->from('group_user')
+            ->where($query->expr()->eq('gid', $query->createNamedParameter($gid)));
+
+        if ($search !== '') {
+            $query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
+                '%' . $this->dbConn->escapeLikeParameter($search) . '%'
+            )));
+        }
+
+        $result = $query->execute();
+        $count = $result->fetchColumn();
+        $result->closeCursor();
+
+        if ($count !== false) {
+            $count = (int)$count;
+        }
+        return $count;
+    }
+
+    /**
+     * get the number of disabled users in a group
+     *
+     * @param string $search
+     * @return int|bool
+     */
+    public function countDisabledInGroup($gid) {
+        $this->fixDI();
 		
-		$query = $this->dbConn->getQueryBuilder();
-		$query->select($queryBuilder->createFunction('COUNT(*)'))
-			->from('preferences')
-			->where($query->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
-			->andWhere($query->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
-			->andWhere($query->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR));
-
-		$result = $query->execute();
-		$result = (int)$result->fetchColumn();
-		$query->closeCursor();
-
-
-		if ($count !== false) {
-			$count = (int)$count;
-		}
-		return $count;
-	}
+        $query = $this->dbConn->getQueryBuilder();
+        $query->select($queryBuilder->createFunction('COUNT(*)'))
+            ->from('preferences')
+            ->where($query->expr()->eq('appid', $queryBuilder->createNamedParameter('core')))
+            ->andWhere($query->expr()->eq('configkey', $queryBuilder->createNamedParameter('enabled')))
+            ->andWhere($query->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR));
+
+        $result = $query->execute();
+        $result = (int)$result->fetchColumn();
+        $query->closeCursor();
+
+
+        if ($count !== false) {
+            $count = (int)$count;
+        }
+        return $count;
+    }
 
 }

Spacing +15 added lines, -15 removed lines

@@ -79,7 +79,7 @@ 
 	 * Tries to create a new group. If the group name already exists, false will
 	 * be returned.
 	 */
-	public function createGroup( $gid ) {
+	public function createGroup($gid) {
 		$this->fixDI();
 
 		// Add group
@@ -100,7 +100,7 @@ 
 	 *
 	 * Deletes a group and removes it from the group_user-table
 	 */
-	public function deleteGroup( $gid ) {
+	public function deleteGroup($gid) {
 		$this->fixDI();
 
 		// Delete the group
@@ -135,7 +135,7 @@ 
 	 *
 	 * Checks whether the user is member of a group or not.
 	 */
-	public function inGroup( $uid, $gid ) {
+	public function inGroup($uid, $gid) {
 		$this->fixDI();
 
 		// check
@@ -160,18 +160,18 @@ 
 	 *
 	 * Adds a user to a group.
 	 */
-	public function addToGroup( $uid, $gid ) {
+	public function addToGroup($uid, $gid) {
 		$this->fixDI();
 
 		// No duplicate entries!
-		if( !$this->inGroup( $uid, $gid )) {
+		if (!$this->inGroup($uid, $gid)) {
 			$qb = $this->dbConn->getQueryBuilder();
 			$qb->insert('group_user')
 				->setValue('uid', $qb->createNamedParameter($uid))
 				->setValue('gid', $qb->createNamedParameter($gid))
 				->execute();
 			return true;
-		}else{
+		} else {
 			return false;
 		}
 	}
@@ -184,7 +184,7 @@ 
 	 *
 	 * removes the user from a group.
 	 */
-	public function removeFromGroup( $uid, $gid ) {
+	public function removeFromGroup($uid, $gid) {
 		$this->fixDI();
 
 		$qb = $this->dbConn->getQueryBuilder();
@@ -204,7 +204,7 @@ 
 	 * This function fetches all groups a user belongs to. It does not check
 	 * if the user exists at all.
 	 */
-	public function getUserGroups( $uid ) {
+	public function getUserGroups($uid) {
 		//guests has empty or null $uid
 		if ($uid === null || $uid === '') {
 			return [];
@@ -220,7 +220,7 @@ 
 			->execute();
 
 		$groups = [];
-		while( $row = $cursor->fetch()) {
+		while ($row = $cursor->fetch()) {
 			$groups[] = $row['gid'];
 			$this->groupCache[$row['gid']] = $row['gid'];
 		}
@@ -248,7 +248,7 @@ 
 
 		if ($search !== '') {
 			$query->where($query->expr()->iLike('gid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
+				'%'.$this->dbConn->escapeLikeParameter($search).'%'
 			)));
 		}
 
@@ -312,7 +312,7 @@ 
 
 		if ($search !== '') {
 			$query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
+				'%'.$this->dbConn->escapeLikeParameter($search).'%'
 			)));
 		}
 
@@ -345,7 +345,7 @@ 
 
 		if ($search !== '') {
 			$query->andWhere($query->expr()->like('uid', $query->createNamedParameter(
-				'%' . $this->dbConn->escapeLikeParameter($search) . '%'
+				'%'.$this->dbConn->escapeLikeParameter($search).'%'
 			)));
 		}
 
@@ -354,7 +354,7 @@ 
 		$result->closeCursor();
 
 		if ($count !== false) {
-			$count = (int)$count;
+			$count = (int) $count;
 		}
 		return $count;
 	}
@@ -376,12 +376,12 @@ 
 			->andWhere($query->expr()->eq('configvalue', $queryBuilder->createNamedParameter('false'), IQueryBuilder::PARAM_STR));
 
 		$result = $query->execute();
-		$result = (int)$result->fetchColumn();
+		$result = (int) $result->fetchColumn();
 		$query->closeCursor();
 
 
 		if ($count !== false) {
-			$count = (int)$count;
+			$count = (int) $count;
 		}
 		return $count;
 	}

lib/private/Group/Backend.php

Indentation +94 added lines, -94 removed lines

@@ -28,108 +28,108 @@
  * Abstract base class for user management
  */
 abstract class Backend implements \OCP\GroupInterface {
-	/**
-	 * error code for functions not provided by the group backend
-	 */
-	const NOT_IMPLEMENTED = -501;
+    /**
+     * error code for functions not provided by the group backend
+     */
+    const NOT_IMPLEMENTED = -501;
 
-	protected $possibleActions = [
-		self::CREATE_GROUP => 'createGroup',
-		self::DELETE_GROUP => 'deleteGroup',
-		self::ADD_TO_GROUP => 'addToGroup',
-		self::REMOVE_FROM_GOUP => 'removeFromGroup',
-		self::COUNT_USERS => 'countUsersInGroup',
-		self::COUNT_DISABLED => 'countDisabledInGroup',
-		self::GROUP_DETAILS => 'getGroupDetails',
-		self::IS_ADMIN => 'isAdmin',
-	];
+    protected $possibleActions = [
+        self::CREATE_GROUP => 'createGroup',
+        self::DELETE_GROUP => 'deleteGroup',
+        self::ADD_TO_GROUP => 'addToGroup',
+        self::REMOVE_FROM_GOUP => 'removeFromGroup',
+        self::COUNT_USERS => 'countUsersInGroup',
+        self::COUNT_DISABLED => 'countDisabledInGroup',
+        self::GROUP_DETAILS => 'getGroupDetails',
+        self::IS_ADMIN => 'isAdmin',
+    ];
 
-	/**
-	* Get all supported actions
-	* @return int bitwise-or'ed actions
-	*
-	* Returns the supported actions as int to be
-	* compared with \OC\Group\Backend::CREATE_GROUP etc.
-	*/
-	public function getSupportedActions() {
-		$actions = 0;
-		foreach($this->possibleActions AS $action => $methodName) {
-			if(method_exists($this, $methodName)) {
-				$actions |= $action;
-			}
-		}
+    /**
+     * Get all supported actions
+     * @return int bitwise-or'ed actions
+     *
+     * Returns the supported actions as int to be
+     * compared with \OC\Group\Backend::CREATE_GROUP etc.
+     */
+    public function getSupportedActions() {
+        $actions = 0;
+        foreach($this->possibleActions AS $action => $methodName) {
+            if(method_exists($this, $methodName)) {
+                $actions |= $action;
+            }
+        }
 
-		return $actions;
-	}
+        return $actions;
+    }
 
-	/**
-	* Check if backend implements actions
-	* @param int $actions bitwise-or'ed actions
-	* @return bool
-	*
-	* Returns the supported actions as int to be
-	* compared with \OC\Group\Backend::CREATE_GROUP etc.
-	*/
-	public function implementsActions($actions) {
-		return (bool)($this->getSupportedActions() & $actions);
-	}
+    /**
+     * Check if backend implements actions
+     * @param int $actions bitwise-or'ed actions
+     * @return bool
+     *
+     * Returns the supported actions as int to be
+     * compared with \OC\Group\Backend::CREATE_GROUP etc.
+     */
+    public function implementsActions($actions) {
+        return (bool)($this->getSupportedActions() & $actions);
+    }
 
-	/**
-	 * is user in group?
-	 * @param string $uid uid of the user
-	 * @param string $gid gid of the group
-	 * @return bool
-	 *
-	 * Checks whether the user is member of a group or not.
-	 */
-	public function inGroup($uid, $gid) {
-		return in_array($gid, $this->getUserGroups($uid));
-	}
+    /**
+     * is user in group?
+     * @param string $uid uid of the user
+     * @param string $gid gid of the group
+     * @return bool
+     *
+     * Checks whether the user is member of a group or not.
+     */
+    public function inGroup($uid, $gid) {
+        return in_array($gid, $this->getUserGroups($uid));
+    }
 
-	/**
-	 * Get all groups a user belongs to
-	 * @param string $uid Name of the user
-	 * @return array an array of group names
-	 *
-	 * This function fetches all groups a user belongs to. It does not check
-	 * if the user exists at all.
-	 */
-	public function getUserGroups($uid) {
-		return array();
-	}
+    /**
+     * Get all groups a user belongs to
+     * @param string $uid Name of the user
+     * @return array an array of group names
+     *
+     * This function fetches all groups a user belongs to. It does not check
+     * if the user exists at all.
+     */
+    public function getUserGroups($uid) {
+        return array();
+    }
 
-	/**
-	 * get a list of all groups
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return array an array of group names
-	 *
-	 * Returns a list with all groups
-	 */
+    /**
+     * get a list of all groups
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return array an array of group names
+     *
+     * Returns a list with all groups
+     */
 
-	public function getGroups($search = '', $limit = -1, $offset = 0) {
-		return array();
-	}
+    public function getGroups($search = '', $limit = -1, $offset = 0) {
+        return array();
+    }
 
-	/**
-	 * check if a group exists
-	 * @param string $gid
-	 * @return bool
-	 */
-	public function groupExists($gid) {
-		return in_array($gid, $this->getGroups($gid, 1));
-	}
+    /**
+     * check if a group exists
+     * @param string $gid
+     * @return bool
+     */
+    public function groupExists($gid) {
+        return in_array($gid, $this->getGroups($gid, 1));
+    }
 
-	/**
-	 * get a list of all users in a group
-	 * @param string $gid
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return array an array of user ids
-	 */
-	public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
-		return array();
-	}
+    /**
+     * get a list of all users in a group
+     * @param string $gid
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return array an array of user ids
+     */
+    public function usersInGroup($gid, $search = '', $limit = -1, $offset = 0) {
+        return array();
+    }
 }

lib/private/Group/Group.php

Indentation +265 added lines, -265 removed lines

@@ -33,292 +33,292 @@
 use OCP\IUser;
 
 class Group implements IGroup {
-	/** @var null|string  */
-	protected $displayName;
+    /** @var null|string  */
+    protected $displayName;
 
-	/**
-	 * @var string $id
-	 */
-	private $gid;
+    /**
+     * @var string $id
+     */
+    private $gid;
 
-	/**
-	 * @var \OC\User\User[] $users
-	 */
-	private $users = array();
+    /**
+     * @var \OC\User\User[] $users
+     */
+    private $users = array();
 
-	/**
-	 * @var bool $usersLoaded
-	 */
-	private $usersLoaded;
+    /**
+     * @var bool $usersLoaded
+     */
+    private $usersLoaded;
 
-	/**
-	 * @var \OC\Group\Backend[]|\OC\Group\Database[] $backend
-	 */
-	private $backends;
+    /**
+     * @var \OC\Group\Backend[]|\OC\Group\Database[] $backend
+     */
+    private $backends;
 
-	/**
-	 * @var \OC\Hooks\PublicEmitter $emitter
-	 */
-	private $emitter;
+    /**
+     * @var \OC\Hooks\PublicEmitter $emitter
+     */
+    private $emitter;
 
-	/**
-	 * @var \OC\User\Manager $userManager
-	 */
-	private $userManager;
+    /**
+     * @var \OC\User\Manager $userManager
+     */
+    private $userManager;
 
-	/**
-	 * @param string $gid
-	 * @param \OC\Group\Backend[] $backends
-	 * @param \OC\User\Manager $userManager
-	 * @param \OC\Hooks\PublicEmitter $emitter
-	 * @param string $displayName
-	 */
-	public function __construct($gid, $backends, $userManager, $emitter = null, $displayName = null) {
-		$this->gid = $gid;
-		$this->backends = $backends;
-		$this->userManager = $userManager;
-		$this->emitter = $emitter;
-		$this->displayName = $displayName;
-	}
+    /**
+     * @param string $gid
+     * @param \OC\Group\Backend[] $backends
+     * @param \OC\User\Manager $userManager
+     * @param \OC\Hooks\PublicEmitter $emitter
+     * @param string $displayName
+     */
+    public function __construct($gid, $backends, $userManager, $emitter = null, $displayName = null) {
+        $this->gid = $gid;
+        $this->backends = $backends;
+        $this->userManager = $userManager;
+        $this->emitter = $emitter;
+        $this->displayName = $displayName;
+    }
 
-	public function getGID() {
-		return $this->gid;
-	}
+    public function getGID() {
+        return $this->gid;
+    }
 
-	public function getDisplayName() {
-		if (is_null($this->displayName)) {
-			return $this->gid;
-		}
-		return $this->displayName;
-	}
+    public function getDisplayName() {
+        if (is_null($this->displayName)) {
+            return $this->gid;
+        }
+        return $this->displayName;
+    }
 
-	/**
-	 * get all users in the group
-	 *
-	 * @return \OC\User\User[]
-	 */
-	public function getUsers() {
-		if ($this->usersLoaded) {
-			return $this->users;
-		}
+    /**
+     * get all users in the group
+     *
+     * @return \OC\User\User[]
+     */
+    public function getUsers() {
+        if ($this->usersLoaded) {
+            return $this->users;
+        }
 
-		$userIds = array();
-		foreach ($this->backends as $backend) {
-			$diff = array_diff(
-				$backend->usersInGroup($this->gid),
-				$userIds
-			);
-			if ($diff) {
-				$userIds = array_merge($userIds, $diff);
-			}
-		}
+        $userIds = array();
+        foreach ($this->backends as $backend) {
+            $diff = array_diff(
+                $backend->usersInGroup($this->gid),
+                $userIds
+            );
+            if ($diff) {
+                $userIds = array_merge($userIds, $diff);
+            }
+        }
 
-		$this->users = $this->getVerifiedUsers($userIds);
-		$this->usersLoaded = true;
-		return $this->users;
-	}
+        $this->users = $this->getVerifiedUsers($userIds);
+        $this->usersLoaded = true;
+        return $this->users;
+    }
 
-	/**
-	 * check if a user is in the group
-	 *
-	 * @param IUser $user
-	 * @return bool
-	 */
-	public function inGroup(IUser $user) {
-		if (isset($this->users[$user->getUID()])) {
-			return true;
-		}
-		foreach ($this->backends as $backend) {
-			if ($backend->inGroup($user->getUID(), $this->gid)) {
-				$this->users[$user->getUID()] = $user;
-				return true;
-			}
-		}
-		return false;
-	}
+    /**
+     * check if a user is in the group
+     *
+     * @param IUser $user
+     * @return bool
+     */
+    public function inGroup(IUser $user) {
+        if (isset($this->users[$user->getUID()])) {
+            return true;
+        }
+        foreach ($this->backends as $backend) {
+            if ($backend->inGroup($user->getUID(), $this->gid)) {
+                $this->users[$user->getUID()] = $user;
+                return true;
+            }
+        }
+        return false;
+    }
 
-	/**
-	 * add a user to the group
-	 *
-	 * @param IUser $user
-	 */
-	public function addUser(IUser $user) {
-		if ($this->inGroup($user)) {
-			return;
-		}
+    /**
+     * add a user to the group
+     *
+     * @param IUser $user
+     */
+    public function addUser(IUser $user) {
+        if ($this->inGroup($user)) {
+            return;
+        }
 
-		if ($this->emitter) {
-			$this->emitter->emit('\OC\Group', 'preAddUser', array($this, $user));
-		}
-		foreach ($this->backends as $backend) {
-			if ($backend->implementsActions(\OC\Group\Backend::ADD_TO_GROUP)) {
-				$backend->addToGroup($user->getUID(), $this->gid);
-				if ($this->users) {
-					$this->users[$user->getUID()] = $user;
-				}
-				if ($this->emitter) {
-					$this->emitter->emit('\OC\Group', 'postAddUser', array($this, $user));
-				}
-				return;
-			}
-		}
-	}
+        if ($this->emitter) {
+            $this->emitter->emit('\OC\Group', 'preAddUser', array($this, $user));
+        }
+        foreach ($this->backends as $backend) {
+            if ($backend->implementsActions(\OC\Group\Backend::ADD_TO_GROUP)) {
+                $backend->addToGroup($user->getUID(), $this->gid);
+                if ($this->users) {
+                    $this->users[$user->getUID()] = $user;
+                }
+                if ($this->emitter) {
+                    $this->emitter->emit('\OC\Group', 'postAddUser', array($this, $user));
+                }
+                return;
+            }
+        }
+    }
 
-	/**
-	 * remove a user from the group
-	 *
-	 * @param \OC\User\User $user
-	 */
-	public function removeUser($user) {
-		$result = false;
-		if ($this->emitter) {
-			$this->emitter->emit('\OC\Group', 'preRemoveUser', array($this, $user));
-		}
-		foreach ($this->backends as $backend) {
-			if ($backend->implementsActions(\OC\Group\Backend::REMOVE_FROM_GOUP) and $backend->inGroup($user->getUID(), $this->gid)) {
-				$backend->removeFromGroup($user->getUID(), $this->gid);
-				$result = true;
-			}
-		}
-		if ($result) {
-			if ($this->emitter) {
-				$this->emitter->emit('\OC\Group', 'postRemoveUser', array($this, $user));
-			}
-			if ($this->users) {
-				foreach ($this->users as $index => $groupUser) {
-					if ($groupUser->getUID() === $user->getUID()) {
-						unset($this->users[$index]);
-						return;
-					}
-				}
-			}
-		}
-	}
+    /**
+     * remove a user from the group
+     *
+     * @param \OC\User\User $user
+     */
+    public function removeUser($user) {
+        $result = false;
+        if ($this->emitter) {
+            $this->emitter->emit('\OC\Group', 'preRemoveUser', array($this, $user));
+        }
+        foreach ($this->backends as $backend) {
+            if ($backend->implementsActions(\OC\Group\Backend::REMOVE_FROM_GOUP) and $backend->inGroup($user->getUID(), $this->gid)) {
+                $backend->removeFromGroup($user->getUID(), $this->gid);
+                $result = true;
+            }
+        }
+        if ($result) {
+            if ($this->emitter) {
+                $this->emitter->emit('\OC\Group', 'postRemoveUser', array($this, $user));
+            }
+            if ($this->users) {
+                foreach ($this->users as $index => $groupUser) {
+                    if ($groupUser->getUID() === $user->getUID()) {
+                        unset($this->users[$index]);
+                        return;
+                    }
+                }
+            }
+        }
+    }
 
-	/**
-	 * search for users in the group by userid
-	 *
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OC\User\User[]
-	 */
-	public function searchUsers($search, $limit = null, $offset = null) {
-		$users = array();
-		foreach ($this->backends as $backend) {
-			$userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
-			$users += $this->getVerifiedUsers($userIds);
-			if (!is_null($limit) and $limit <= 0) {
-				return array_values($users);
-			}
-		}
-		return array_values($users);
-	}
+    /**
+     * search for users in the group by userid
+     *
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return \OC\User\User[]
+     */
+    public function searchUsers($search, $limit = null, $offset = null) {
+        $users = array();
+        foreach ($this->backends as $backend) {
+            $userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
+            $users += $this->getVerifiedUsers($userIds);
+            if (!is_null($limit) and $limit <= 0) {
+                return array_values($users);
+            }
+        }
+        return array_values($users);
+    }
 
-	/**
-	 * returns the number of users matching the search string
-	 *
-	 * @param string $search
-	 * @return int|bool
-	 */
-	public function count($search = '') {
-		$users = false;
-		foreach ($this->backends as $backend) {
-			if($backend->implementsActions(\OC\Group\Backend::COUNT_USERS)) {
-				if($users === false) {
-					//we could directly add to a bool variable, but this would
-					//be ugly
-					$users = 0;
-				}
-				$users += $backend->countUsersInGroup($this->gid, $search);
-			}
-		}
-		return $users;
-	}
+    /**
+     * returns the number of users matching the search string
+     *
+     * @param string $search
+     * @return int|bool
+     */
+    public function count($search = '') {
+        $users = false;
+        foreach ($this->backends as $backend) {
+            if($backend->implementsActions(\OC\Group\Backend::COUNT_USERS)) {
+                if($users === false) {
+                    //we could directly add to a bool variable, but this would
+                    //be ugly
+                    $users = 0;
+                }
+                $users += $backend->countUsersInGroup($this->gid, $search);
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * returns the number of disabled users
-	 *
-	 * @return int|bool
-	 */
-	public function countDisabled() {
-		$users = false;
-		foreach ($this->backends as $backend) {
-			if($backend->implementsActions(\OC\Group\Backend::COUNT_DISABLED)) {
-				if($users === false) {
-					//we could directly add to a bool variable, but this would
-					//be ugly
-					$users = 0;
-				}
-				$users += $backend->countUsersInGroup($this->gid);
-			}
-		}
-		return $users;
-	}
+    /**
+     * returns the number of disabled users
+     *
+     * @return int|bool
+     */
+    public function countDisabled() {
+        $users = false;
+        foreach ($this->backends as $backend) {
+            if($backend->implementsActions(\OC\Group\Backend::COUNT_DISABLED)) {
+                if($users === false) {
+                    //we could directly add to a bool variable, but this would
+                    //be ugly
+                    $users = 0;
+                }
+                $users += $backend->countUsersInGroup($this->gid);
+            }
+        }
+        return $users;
+    }
 
-	/**
-	 * search for users in the group by displayname
-	 *
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OC\User\User[]
-	 */
-	public function searchDisplayName($search, $limit = null, $offset = null) {
-		$users = array();
-		foreach ($this->backends as $backend) {
-			$userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
-			$users = $this->getVerifiedUsers($userIds);
-			if (!is_null($limit) and $limit <= 0) {
-				return array_values($users);
-			}
-		}
-		return array_values($users);
-	}
+    /**
+     * search for users in the group by displayname
+     *
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return \OC\User\User[]
+     */
+    public function searchDisplayName($search, $limit = null, $offset = null) {
+        $users = array();
+        foreach ($this->backends as $backend) {
+            $userIds = $backend->usersInGroup($this->gid, $search, $limit, $offset);
+            $users = $this->getVerifiedUsers($userIds);
+            if (!is_null($limit) and $limit <= 0) {
+                return array_values($users);
+            }
+        }
+        return array_values($users);
+    }
 
-	/**
-	 * delete the group
-	 *
-	 * @return bool
-	 */
-	public function delete() {
-		// Prevent users from deleting group admin
-		if ($this->getGID() === 'admin') {
-			return false;
-		}
+    /**
+     * delete the group
+     *
+     * @return bool
+     */
+    public function delete() {
+        // Prevent users from deleting group admin
+        if ($this->getGID() === 'admin') {
+            return false;
+        }
 
-		$result = false;
-		if ($this->emitter) {
-			$this->emitter->emit('\OC\Group', 'preDelete', array($this));
-		}
-		foreach ($this->backends as $backend) {
-			if ($backend->implementsActions(\OC\Group\Backend::DELETE_GROUP)) {
-				$result = true;
-				$backend->deleteGroup($this->gid);
-			}
-		}
-		if ($result and $this->emitter) {
-			$this->emitter->emit('\OC\Group', 'postDelete', array($this));
-		}
-		return $result;
-	}
+        $result = false;
+        if ($this->emitter) {
+            $this->emitter->emit('\OC\Group', 'preDelete', array($this));
+        }
+        foreach ($this->backends as $backend) {
+            if ($backend->implementsActions(\OC\Group\Backend::DELETE_GROUP)) {
+                $result = true;
+                $backend->deleteGroup($this->gid);
+            }
+        }
+        if ($result and $this->emitter) {
+            $this->emitter->emit('\OC\Group', 'postDelete', array($this));
+        }
+        return $result;
+    }
 
-	/**
-	 * returns all the Users from an array that really exists
-	 * @param string[] $userIds an array containing user IDs
-	 * @return \OC\User\User[] an Array with the userId as Key and \OC\User\User as value
-	 */
-	private function getVerifiedUsers($userIds) {
-		if (!is_array($userIds)) {
-			return array();
-		}
-		$users = array();
-		foreach ($userIds as $userId) {
-			$user = $this->userManager->get($userId);
-			if (!is_null($user)) {
-				$users[$userId] = $user;
-			}
-		}
-		return $users;
-	}
+    /**
+     * returns all the Users from an array that really exists
+     * @param string[] $userIds an array containing user IDs
+     * @return \OC\User\User[] an Array with the userId as Key and \OC\User\User as value
+     */
+    private function getVerifiedUsers($userIds) {
+        if (!is_array($userIds)) {
+            return array();
+        }
+        $users = array();
+        foreach ($userIds as $userId) {
+            $user = $this->userManager->get($userId);
+            if (!is_null($user)) {
+                $users[$userId] = $user;
+            }
+        }
+        return $users;
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -224,8 +224,8 @@ 
 	public function count($search = '') {
 		$users = false;
 		foreach ($this->backends as $backend) {
-			if($backend->implementsActions(\OC\Group\Backend::COUNT_USERS)) {
-				if($users === false) {
+			if ($backend->implementsActions(\OC\Group\Backend::COUNT_USERS)) {
+				if ($users === false) {
 					//we could directly add to a bool variable, but this would
 					//be ugly
 					$users = 0;
@@ -244,8 +244,8 @@ 
 	public function countDisabled() {
 		$users = false;
 		foreach ($this->backends as $backend) {
-			if($backend->implementsActions(\OC\Group\Backend::COUNT_DISABLED)) {
-				if($users === false) {
+			if ($backend->implementsActions(\OC\Group\Backend::COUNT_DISABLED)) {
+				if ($users === false) {
 					//we could directly add to a bool variable, but this would
 					//be ugly
 					$users = 0;

lib/private/User/Manager.php

Indentation +486 added lines, -486 removed lines

@@ -57,490 +57,490 @@
  * @package OC\User
  */
 class Manager extends PublicEmitter implements IUserManager {
-	/**
-	 * @var \OCP\UserInterface[] $backends
-	 */
-	private $backends = array();
-
-	/**
-	 * @var \OC\User\User[] $cachedUsers
-	 */
-	private $cachedUsers = array();
-
-	/**
-	 * @var \OCP\IConfig $config
-	 */
-	private $config;
-
-	/**
-	 * @param \OCP\IConfig $config
-	 */
-	public function __construct(IConfig $config) {
-		$this->config = $config;
-		$cachedUsers = &$this->cachedUsers;
-		$this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
-			/** @var \OC\User\User $user */
-			unset($cachedUsers[$user->getUID()]);
-		});
-	}
-
-	/**
-	 * 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 = array();
-		if (($i = array_search($backend, $this->backends)) !== false) {
-			unset($this->backends[$i]);
-		}
-	}
-
-	/**
-	 * remove all user backends
-	 */
-	public function clearBackends() {
-		$this->cachedUsers = array();
-		$this->backends = array();
-	}
-
-	/**
-	 * 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];
-		}
-		foreach ($this->backends as $backend) {
-			if ($backend->userExists($uid)) {
-				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 (isset($this->cachedUsers[$uid])) {
-			return $this->cachedUsers[$uid];
-		}
-
-		$user = new User($uid, $backend, $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 mixed 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);
-				}
-			}
-		}
-
-		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 = array();
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->getUsers($pattern, $limit, $offset);
-			if (is_array($backendUsers)) {
-				foreach ($backendUsers as $uid) {
-					$users[$uid] = $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		uasort($users, function ($a, $b) {
-			/**
-			 * @var \OC\User\User $a
-			 * @var \OC\User\User $b
-			 */
-			return strcmp($a->getUID(), $b->getUID());
-		});
-		return $users;
-	}
-
-	/**
-	 * search by displayName
-	 *
-	 * @param string $pattern
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OC\User\User[]
-	 */
-	public function searchDisplayName($pattern, $limit = null, $offset = null) {
-		$users = array();
-		foreach ($this->backends as $backend) {
-			$backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
-			if (is_array($backendUsers)) {
-				foreach ($backendUsers as $uid => $displayName) {
-					$users[] = $this->getUserObject($uid, $backend);
-				}
-			}
-		}
-
-		usort($users, function ($a, $b) {
-			/**
-			 * @var \OC\User\User $a
-			 * @var \OC\User\User $b
-			 */
-			return strcmp(strtolower($a->getDisplayName()), strtolower($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) {
-		$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'));
-		}
-		// 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'));
-		}
-
-		$this->emit('\OC\User', 'preCreateUser', [$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) {
-			$this->emit('\OC\User', 'postCreateUser', [$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;
-	}
-
-	/**
-	 * 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 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 uid)'))
-			->from('preferences', 'p')
-			->innerJoin('p', 'group_user', 'g', '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)));
-
-		$query = $queryBuilder->execute();
-
-		$result = (int)$query->fetchColumn();
-		$query->closeCursor();
-
-		return $result;
-	}
-
-	/**
-	 * 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->createFunction('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->fetchColumn();
-		$query->closeCursor();
-
-		return $result;
-	}
-
-	/**
-	 * @param \Closure $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->getUsersForUserValue('settings', 'email', $email);
-
-		return array_map(function($uid) {
-			return $this->get($uid);
-		}, $userIds);
-	}
+    /**
+     * @var \OCP\UserInterface[] $backends
+     */
+    private $backends = array();
+
+    /**
+     * @var \OC\User\User[] $cachedUsers
+     */
+    private $cachedUsers = array();
+
+    /**
+     * @var \OCP\IConfig $config
+     */
+    private $config;
+
+    /**
+     * @param \OCP\IConfig $config
+     */
+    public function __construct(IConfig $config) {
+        $this->config = $config;
+        $cachedUsers = &$this->cachedUsers;
+        $this->listen('\OC\User', 'postDelete', function ($user) use (&$cachedUsers) {
+            /** @var \OC\User\User $user */
+            unset($cachedUsers[$user->getUID()]);
+        });
+    }
+
+    /**
+     * 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 = array();
+        if (($i = array_search($backend, $this->backends)) !== false) {
+            unset($this->backends[$i]);
+        }
+    }
+
+    /**
+     * remove all user backends
+     */
+    public function clearBackends() {
+        $this->cachedUsers = array();
+        $this->backends = array();
+    }
+
+    /**
+     * 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];
+        }
+        foreach ($this->backends as $backend) {
+            if ($backend->userExists($uid)) {
+                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 (isset($this->cachedUsers[$uid])) {
+            return $this->cachedUsers[$uid];
+        }
+
+        $user = new User($uid, $backend, $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 mixed 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);
+                }
+            }
+        }
+
+        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 = array();
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->getUsers($pattern, $limit, $offset);
+            if (is_array($backendUsers)) {
+                foreach ($backendUsers as $uid) {
+                    $users[$uid] = $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        uasort($users, function ($a, $b) {
+            /**
+             * @var \OC\User\User $a
+             * @var \OC\User\User $b
+             */
+            return strcmp($a->getUID(), $b->getUID());
+        });
+        return $users;
+    }
+
+    /**
+     * search by displayName
+     *
+     * @param string $pattern
+     * @param int $limit
+     * @param int $offset
+     * @return \OC\User\User[]
+     */
+    public function searchDisplayName($pattern, $limit = null, $offset = null) {
+        $users = array();
+        foreach ($this->backends as $backend) {
+            $backendUsers = $backend->getDisplayNames($pattern, $limit, $offset);
+            if (is_array($backendUsers)) {
+                foreach ($backendUsers as $uid => $displayName) {
+                    $users[] = $this->getUserObject($uid, $backend);
+                }
+            }
+        }
+
+        usort($users, function ($a, $b) {
+            /**
+             * @var \OC\User\User $a
+             * @var \OC\User\User $b
+             */
+            return strcmp(strtolower($a->getDisplayName()), strtolower($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) {
+        $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'));
+        }
+        // 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'));
+        }
+
+        $this->emit('\OC\User', 'preCreateUser', [$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) {
+            $this->emit('\OC\User', 'postCreateUser', [$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;
+    }
+
+    /**
+     * 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 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 uid)'))
+            ->from('preferences', 'p')
+            ->innerJoin('p', 'group_user', 'g', '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)));
+
+        $query = $queryBuilder->execute();
+
+        $result = (int)$query->fetchColumn();
+        $query->closeCursor();
+
+        return $result;
+    }
+
+    /**
+     * 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->createFunction('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->fetchColumn();
+        $query->closeCursor();
+
+        return $result;
+    }
+
+    /**
+     * @param \Closure $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->getUsersForUserValue('settings', 'email', $email);
+
+        return array_map(function($uid) {
+            return $this->get($uid);
+        }, $userIds);
+    }
 }

lib/public/IGroup.php

Indentation +82 added lines, -82 removed lines

@@ -33,96 +33,96 @@
  * @since 8.0.0
  */
 interface IGroup {
-	/**
-	 * @return string
-	 * @since 8.0.0
-	 */
-	public function getGID();
+    /**
+     * @return string
+     * @since 8.0.0
+     */
+    public function getGID();
 
-	/**
-	 * Returns the group display name
-	 *
-	 * @return string
-	 * @since 12.0.0
-	 */
-	public function getDisplayName();
+    /**
+     * Returns the group display name
+     *
+     * @return string
+     * @since 12.0.0
+     */
+    public function getDisplayName();
 
-	/**
-	 * get all users in the group
-	 *
-	 * @return \OCP\IUser[]
-	 * @since 8.0.0
-	 */
-	public function getUsers();
+    /**
+     * get all users in the group
+     *
+     * @return \OCP\IUser[]
+     * @since 8.0.0
+     */
+    public function getUsers();
 
-	/**
-	 * check if a user is in the group
-	 *
-	 * @param \OCP\IUser $user
-	 * @return bool
-	 * @since 8.0.0
-	 */
-	public function inGroup(IUser $user);
+    /**
+     * check if a user is in the group
+     *
+     * @param \OCP\IUser $user
+     * @return bool
+     * @since 8.0.0
+     */
+    public function inGroup(IUser $user);
 
-	/**
-	 * add a user to the group
-	 *
-	 * @param \OCP\IUser $user
-	 * @since 8.0.0
-	 */
-	public function addUser(IUser $user);
+    /**
+     * add a user to the group
+     *
+     * @param \OCP\IUser $user
+     * @since 8.0.0
+     */
+    public function addUser(IUser $user);
 
-	/**
-	 * remove a user from the group
-	 *
-	 * @param \OCP\IUser $user
-	 * @since 8.0.0
-	 */
-	public function removeUser($user);
+    /**
+     * remove a user from the group
+     *
+     * @param \OCP\IUser $user
+     * @since 8.0.0
+     */
+    public function removeUser($user);
 
-	/**
-	 * search for users in the group by userid
-	 *
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\IUser[]
-	 * @since 8.0.0
-	 */
-	public function searchUsers($search, $limit = null, $offset = null);
+    /**
+     * search for users in the group by userid
+     *
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\IUser[]
+     * @since 8.0.0
+     */
+    public function searchUsers($search, $limit = null, $offset = null);
 
-	/**
-	 * returns the number of users matching the search string
-	 *
-	 * @param string $search
-	 * @return int|bool
-	 * @since 8.0.0
-	 */
-	public function count($search = '');
+    /**
+     * returns the number of users matching the search string
+     *
+     * @param string $search
+     * @return int|bool
+     * @since 8.0.0
+     */
+    public function count($search = '');
 
-	/**
-	 * returns the number of disabled users
-	 *
-	 * @since 14.0.0
-	 */
-	public function countDisabled();
+    /**
+     * returns the number of disabled users
+     *
+     * @since 14.0.0
+     */
+    public function countDisabled();
 
-	/**
-	 * search for users in the group by displayname
-	 *
-	 * @param string $search
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\IUser[]
-	 * @since 8.0.0
-	 */
-	public function searchDisplayName($search, $limit = null, $offset = null);
+    /**
+     * search for users in the group by displayname
+     *
+     * @param string $search
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\IUser[]
+     * @since 8.0.0
+     */
+    public function searchDisplayName($search, $limit = null, $offset = null);
 
-	/**
-	 * delete the group
-	 *
-	 * @return bool
-	 * @since 8.0.0
-	 */
-	public function delete();
+    /**
+     * delete the group
+     *
+     * @return bool
+     * @since 8.0.0
+     */
+    public function delete();
 }