nextcloud / server

apps/comments/lib/Notification/Listener.php

Spacing +1 added lines, -1 removed lines

@@ -90,7 +90,7 @@
 		$notification
 			->setApp('comments')
 			->setObject('comment', $comment->getId())
-			->setSubject('mention', [ $comment->getObjectType(), $comment->getObjectId() ])
+			->setSubject('mention', [$comment->getObjectType(), $comment->getObjectId()])
 			->setDateTime($comment->getCreationDateTime());
 
 		return $notification;

Indentation +72 added lines, -72 removed lines

@@ -30,85 +30,85 @@
 
 class Listener {
 
-	protected IManager $notificationManager;
-	protected IUserManager $userManager;
+    protected IManager $notificationManager;
+    protected IUserManager $userManager;
 
-	/**
-	 * Listener constructor.
-	 */
-	public function __construct(
-		IManager $notificationManager,
-		IUserManager $userManager
-	) {
-		$this->notificationManager = $notificationManager;
-		$this->userManager = $userManager;
-	}
+    /**
+     * Listener constructor.
+     */
+    public function __construct(
+        IManager $notificationManager,
+        IUserManager $userManager
+    ) {
+        $this->notificationManager = $notificationManager;
+        $this->userManager = $userManager;
+    }
 
-	/**
-	 * @param CommentsEvent $event
-	 */
-	public function evaluate(CommentsEvent $event) {
-		$comment = $event->getComment();
+    /**
+     * @param CommentsEvent $event
+     */
+    public function evaluate(CommentsEvent $event) {
+        $comment = $event->getComment();
 
-		$mentions = $this->extractMentions($comment->getMentions());
-		if (empty($mentions)) {
-			// no one to notify
-			return;
-		}
+        $mentions = $this->extractMentions($comment->getMentions());
+        if (empty($mentions)) {
+            // no one to notify
+            return;
+        }
 
-		$notification = $this->instantiateNotification($comment);
+        $notification = $this->instantiateNotification($comment);
 
-		foreach ($mentions as $uid) {
-			if (($comment->getActorType() === 'users' && $uid === $comment->getActorId())
-				|| !$this->userManager->userExists($uid)
-			) {
-				// do not notify unknown users or yourself
-				continue;
-			}
+        foreach ($mentions as $uid) {
+            if (($comment->getActorType() === 'users' && $uid === $comment->getActorId())
+                || !$this->userManager->userExists($uid)
+            ) {
+                // do not notify unknown users or yourself
+                continue;
+            }
 
-			$notification->setUser($uid);
-			if ($event->getEvent() === CommentsEvent::EVENT_DELETE
-				|| $event->getEvent() === CommentsEvent::EVENT_PRE_UPDATE) {
-				$this->notificationManager->markProcessed($notification);
-			} else {
-				$this->notificationManager->notify($notification);
-			}
-		}
-	}
+            $notification->setUser($uid);
+            if ($event->getEvent() === CommentsEvent::EVENT_DELETE
+                || $event->getEvent() === CommentsEvent::EVENT_PRE_UPDATE) {
+                $this->notificationManager->markProcessed($notification);
+            } else {
+                $this->notificationManager->notify($notification);
+            }
+        }
+    }
 
-	/**
-	 * creates a notification instance and fills it with comment data
-	 *
-	 * @param IComment $comment
-	 * @return \OCP\Notification\INotification
-	 */
-	public function instantiateNotification(IComment $comment) {
-		$notification = $this->notificationManager->createNotification();
-		$notification
-			->setApp('comments')
-			->setObject('comment', $comment->getId())
-			->setSubject('mention', [ $comment->getObjectType(), $comment->getObjectId() ])
-			->setDateTime($comment->getCreationDateTime());
+    /**
+     * creates a notification instance and fills it with comment data
+     *
+     * @param IComment $comment
+     * @return \OCP\Notification\INotification
+     */
+    public function instantiateNotification(IComment $comment) {
+        $notification = $this->notificationManager->createNotification();
+        $notification
+            ->setApp('comments')
+            ->setObject('comment', $comment->getId())
+            ->setSubject('mention', [ $comment->getObjectType(), $comment->getObjectId() ])
+            ->setDateTime($comment->getCreationDateTime());
 
-		return $notification;
-	}
+        return $notification;
+    }
 
-	/**
-	 * flattens the mention array returned from comments to a list of user ids.
-	 *
-	 * @param array $mentions
-	 * @return string[] containing the mentions, e.g. ['alice', 'bob']
-	 */
-	public function extractMentions(array $mentions) {
-		if (empty($mentions)) {
-			return [];
-		}
-		$uids = [];
-		foreach ($mentions as $mention) {
-			if ($mention['type'] === 'user') {
-				$uids[] = $mention['id'];
-			}
-		}
-		return $uids;
-	}
+    /**
+     * flattens the mention array returned from comments to a list of user ids.
+     *
+     * @param array $mentions
+     * @return string[] containing the mentions, e.g. ['alice', 'bob']
+     */
+    public function extractMentions(array $mentions) {
+        if (empty($mentions)) {
+            return [];
+        }
+        $uids = [];
+        foreach ($mentions as $mention) {
+            if ($mention['type'] === 'user') {
+                $uids[] = $mention['id'];
+            }
+        }
+        return $uids;
+    }
 }

apps/comments/lib/EventHandler.php

Indentation +45 added lines, -45 removed lines

@@ -36,56 +36,56 @@
  * @package OCA\Comments
  */
 class EventHandler implements ICommentsEventHandler {
-	/** @var ActivityListener */
-	private $activityListener;
+    /** @var ActivityListener */
+    private $activityListener;
 
-	/** @var NotificationListener */
-	private $notificationListener;
+    /** @var NotificationListener */
+    private $notificationListener;
 
-	public function __construct(ActivityListener $activityListener, NotificationListener $notificationListener) {
-		$this->activityListener = $activityListener;
-		$this->notificationListener = $notificationListener;
-	}
+    public function __construct(ActivityListener $activityListener, NotificationListener $notificationListener) {
+        $this->activityListener = $activityListener;
+        $this->notificationListener = $notificationListener;
+    }
 
-	/**
-	 * @param CommentsEvent $event
-	 */
-	public function handle(CommentsEvent $event) {
-		if ($event->getComment()->getObjectType() !== 'files') {
-			// this is a 'files'-specific Handler
-			return;
-		}
+    /**
+     * @param CommentsEvent $event
+     */
+    public function handle(CommentsEvent $event) {
+        if ($event->getComment()->getObjectType() !== 'files') {
+            // this is a 'files'-specific Handler
+            return;
+        }
 
-		$eventType = $event->getEvent();
-		if ($eventType === CommentsEvent::EVENT_ADD
-		) {
-			$this->notificationHandler($event);
-			$this->activityHandler($event);
-			return;
-		}
+        $eventType = $event->getEvent();
+        if ($eventType === CommentsEvent::EVENT_ADD
+        ) {
+            $this->notificationHandler($event);
+            $this->activityHandler($event);
+            return;
+        }
 
-		$applicableEvents = [
-			CommentsEvent::EVENT_PRE_UPDATE,
-			CommentsEvent::EVENT_UPDATE,
-			CommentsEvent::EVENT_DELETE,
-		];
-		if (in_array($eventType, $applicableEvents)) {
-			$this->notificationHandler($event);
-			return;
-		}
-	}
+        $applicableEvents = [
+            CommentsEvent::EVENT_PRE_UPDATE,
+            CommentsEvent::EVENT_UPDATE,
+            CommentsEvent::EVENT_DELETE,
+        ];
+        if (in_array($eventType, $applicableEvents)) {
+            $this->notificationHandler($event);
+            return;
+        }
+    }
 
-	/**
-	 * @param CommentsEvent $event
-	 */
-	private function activityHandler(CommentsEvent $event) {
-		$this->activityListener->commentEvent($event);
-	}
+    /**
+     * @param CommentsEvent $event
+     */
+    private function activityHandler(CommentsEvent $event) {
+        $this->activityListener->commentEvent($event);
+    }
 
-	/**
-	 * @param CommentsEvent $event
-	 */
-	private function notificationHandler(CommentsEvent $event) {
-		$this->notificationListener->evaluate($event);
-	}
+    /**
+     * @param CommentsEvent $event
+     */
+    private function notificationHandler(CommentsEvent $event) {
+        $this->notificationListener->evaluate($event);
+    }
 }

apps/user_ldap/lib/User_Proxy.php

Spacing +2 added lines, -2 removed lines

@@ -197,7 +197,7 @@ 
 	 * @return string|false
 	 */
 	public function loginName2UserName($loginName) {
-		$id = 'LOGINNAME,' . $loginName;
+		$id = 'LOGINNAME,'.$loginName;
 		return $this->handleRequest($id, 'loginName2UserName', [$loginName]);
 	}
 	
@@ -208,7 +208,7 @@ 
 	 * @return string|false with the username
 	 */
 	public function dn2UserName($dn) {
-		$id = 'DN,' . $dn;
+		$id = 'DN,'.$dn;
 		return $this->handleRequest($id, 'dn2UserName', [$dn]);
 	}
 

Indentation +395 added lines, -395 removed lines

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

apps/user_ldap/lib/BackendUtility.php

Indentation +8 added lines, -8 removed lines

@@ -26,13 +26,13 @@
 namespace OCA\User_LDAP;
 
 abstract class BackendUtility {
-	protected $access;
+    protected $access;
 
-	/**
-	 * constructor, make sure the subclasses call this one!
-	 * @param Access $access an instance of Access for LDAP interaction
-	 */
-	public function __construct(Access $access) {
-		$this->access = $access;
-	}
+    /**
+     * constructor, make sure the subclasses call this one!
+     * @param Access $access an instance of Access for LDAP interaction
+     */
+    public function __construct(Access $access) {
+        $this->access = $access;
+    }
 }

apps/user_ldap/ajax/getNewServerConfigPrefix.php

Indentation +5 added lines, -5 removed lines

@@ -38,12 +38,12 @@
 
 $newConfig = new \OCA\User_LDAP\Configuration($nk, false);
 if (isset($_POST['copyConfig'])) {
-	$originalConfig = new \OCA\User_LDAP\Configuration($_POST['copyConfig']);
-	$newConfig->setConfiguration($originalConfig->getConfiguration());
+    $originalConfig = new \OCA\User_LDAP\Configuration($_POST['copyConfig']);
+    $newConfig->setConfiguration($originalConfig->getConfiguration());
 } else {
-	$configuration = new \OCA\User_LDAP\Configuration($nk, false);
-	$newConfig->setConfiguration($configuration->getDefaults());
-	$resultData['defaults'] = $configuration->getDefaults();
+    $configuration = new \OCA\User_LDAP\Configuration($nk, false);
+    $newConfig->setConfiguration($configuration->getDefaults());
+    $resultData['defaults'] = $configuration->getDefaults();
 }
 $newConfig->saveConfiguration();
 

Spacing +1 added lines, -1 removed lines

@@ -33,7 +33,7 @@
 $serverConnections = $helper->getServerConfigurationPrefixes();
 sort($serverConnections);
 $lk = array_pop($serverConnections);
-$ln = (int)str_replace('s', '', $lk);
+$ln = (int) str_replace('s', '', $lk);
 $nk = 's'.str_pad($ln + 1, 2, '0', STR_PAD_LEFT);
 
 $resultData = ['configPrefix' => $nk];

apps/encryption/lib/Util.php

Spacing +2 added lines, -2 removed lines

@@ -167,7 +167,7 @@ 
 	 * @return bool
 	 */
 	public function userHasFiles($uid) {
-		return $this->files->file_exists($uid . '/files');
+		return $this->files->file_exists($uid.'/files');
 	}
 
 	/**
@@ -183,7 +183,7 @@ 
 		if (count($parts) > 1) {
 			$owner = $parts[1];
 			if ($this->userManager->userExists($owner) === false) {
-				throw new \BadMethodCallException('Unknown user: ' .
+				throw new \BadMethodCallException('Unknown user: '.
 				'method expects path to a user folder relative to the data folder');
 			}
 		}

Indentation +147 added lines, -147 removed lines

@@ -36,164 +36,164 @@
 use OCP\PreConditionNotMetException;
 
 class Util {
-	/**
-	 * @var View
-	 */
-	private $files;
-	/**
-	 * @var Crypt
-	 */
-	private $crypt;
-	/**
-	 * @var ILogger
-	 */
-	private $logger;
-	/**
-	 * @var bool|IUser
-	 */
-	private $user;
-	/**
-	 * @var IConfig
-	 */
-	private $config;
-	/**
-	 * @var IUserManager
-	 */
-	private $userManager;
+    /**
+     * @var View
+     */
+    private $files;
+    /**
+     * @var Crypt
+     */
+    private $crypt;
+    /**
+     * @var ILogger
+     */
+    private $logger;
+    /**
+     * @var bool|IUser
+     */
+    private $user;
+    /**
+     * @var IConfig
+     */
+    private $config;
+    /**
+     * @var IUserManager
+     */
+    private $userManager;
 
-	/**
-	 * Util constructor.
-	 *
-	 * @param View $files
-	 * @param Crypt $crypt
-	 * @param ILogger $logger
-	 * @param IUserSession $userSession
-	 * @param IConfig $config
-	 * @param IUserManager $userManager
-	 */
-	public function __construct(View $files,
-								Crypt $crypt,
-								ILogger $logger,
-								IUserSession $userSession,
-								IConfig $config,
-								IUserManager $userManager
-	) {
-		$this->files = $files;
-		$this->crypt = $crypt;
-		$this->logger = $logger;
-		$this->user = $userSession && $userSession->isLoggedIn() ? $userSession->getUser() : false;
-		$this->config = $config;
-		$this->userManager = $userManager;
-	}
+    /**
+     * Util constructor.
+     *
+     * @param View $files
+     * @param Crypt $crypt
+     * @param ILogger $logger
+     * @param IUserSession $userSession
+     * @param IConfig $config
+     * @param IUserManager $userManager
+     */
+    public function __construct(View $files,
+                                Crypt $crypt,
+                                ILogger $logger,
+                                IUserSession $userSession,
+                                IConfig $config,
+                                IUserManager $userManager
+    ) {
+        $this->files = $files;
+        $this->crypt = $crypt;
+        $this->logger = $logger;
+        $this->user = $userSession && $userSession->isLoggedIn() ? $userSession->getUser() : false;
+        $this->config = $config;
+        $this->userManager = $userManager;
+    }
 
-	/**
-	 * check if recovery key is enabled for user
-	 *
-	 * @param string $uid
-	 * @return bool
-	 */
-	public function isRecoveryEnabledForUser($uid) {
-		$recoveryMode = $this->config->getUserValue($uid,
-			'encryption',
-			'recoveryEnabled',
-			'0');
+    /**
+     * check if recovery key is enabled for user
+     *
+     * @param string $uid
+     * @return bool
+     */
+    public function isRecoveryEnabledForUser($uid) {
+        $recoveryMode = $this->config->getUserValue($uid,
+            'encryption',
+            'recoveryEnabled',
+            '0');
 
-		return ($recoveryMode === '1');
-	}
+        return ($recoveryMode === '1');
+    }
 
-	/**
-	 * check if the home storage should be encrypted
-	 *
-	 * @return bool
-	 */
-	public function shouldEncryptHomeStorage() {
-		$encryptHomeStorage = $this->config->getAppValue(
-			'encryption',
-			'encryptHomeStorage',
-			'1'
-		);
+    /**
+     * check if the home storage should be encrypted
+     *
+     * @return bool
+     */
+    public function shouldEncryptHomeStorage() {
+        $encryptHomeStorage = $this->config->getAppValue(
+            'encryption',
+            'encryptHomeStorage',
+            '1'
+        );
 
-		return ($encryptHomeStorage === '1');
-	}
+        return ($encryptHomeStorage === '1');
+    }
 
-	/**
-	 * set the home storage encryption on/off
-	 *
-	 * @param bool $encryptHomeStorage
-	 */
-	public function setEncryptHomeStorage($encryptHomeStorage) {
-		$value = $encryptHomeStorage ? '1' : '0';
-		$this->config->setAppValue(
-			'encryption',
-			'encryptHomeStorage',
-			$value
-		);
-	}
+    /**
+     * set the home storage encryption on/off
+     *
+     * @param bool $encryptHomeStorage
+     */
+    public function setEncryptHomeStorage($encryptHomeStorage) {
+        $value = $encryptHomeStorage ? '1' : '0';
+        $this->config->setAppValue(
+            'encryption',
+            'encryptHomeStorage',
+            $value
+        );
+    }
 
-	/**
-	 * check if master key is enabled
-	 *
-	 * @return bool
-	 */
-	public function isMasterKeyEnabled() {
-		$userMasterKey = $this->config->getAppValue('encryption', 'useMasterKey', '1');
-		return ($userMasterKey === '1');
-	}
+    /**
+     * check if master key is enabled
+     *
+     * @return bool
+     */
+    public function isMasterKeyEnabled() {
+        $userMasterKey = $this->config->getAppValue('encryption', 'useMasterKey', '1');
+        return ($userMasterKey === '1');
+    }
 
-	/**
-	 * @param $enabled
-	 * @return bool
-	 */
-	public function setRecoveryForUser($enabled) {
-		$value = $enabled ? '1' : '0';
+    /**
+     * @param $enabled
+     * @return bool
+     */
+    public function setRecoveryForUser($enabled) {
+        $value = $enabled ? '1' : '0';
 
-		try {
-			$this->config->setUserValue($this->user->getUID(),
-				'encryption',
-				'recoveryEnabled',
-				$value);
-			return true;
-		} catch (PreConditionNotMetException $e) {
-			return false;
-		}
-	}
+        try {
+            $this->config->setUserValue($this->user->getUID(),
+                'encryption',
+                'recoveryEnabled',
+                $value);
+            return true;
+        } catch (PreConditionNotMetException $e) {
+            return false;
+        }
+    }
 
-	/**
-	 * @param string $uid
-	 * @return bool
-	 */
-	public function userHasFiles($uid) {
-		return $this->files->file_exists($uid . '/files');
-	}
+    /**
+     * @param string $uid
+     * @return bool
+     */
+    public function userHasFiles($uid) {
+        return $this->files->file_exists($uid . '/files');
+    }
 
-	/**
-	 * get owner from give path, path relative to data/ expected
-	 *
-	 * @param string $path relative to data/
-	 * @return string
-	 * @throws \BadMethodCallException
-	 */
-	public function getOwner($path) {
-		$owner = '';
-		$parts = explode('/', $path, 3);
-		if (count($parts) > 1) {
-			$owner = $parts[1];
-			if ($this->userManager->userExists($owner) === false) {
-				throw new \BadMethodCallException('Unknown user: ' .
-				'method expects path to a user folder relative to the data folder');
-			}
-		}
+    /**
+     * get owner from give path, path relative to data/ expected
+     *
+     * @param string $path relative to data/
+     * @return string
+     * @throws \BadMethodCallException
+     */
+    public function getOwner($path) {
+        $owner = '';
+        $parts = explode('/', $path, 3);
+        if (count($parts) > 1) {
+            $owner = $parts[1];
+            if ($this->userManager->userExists($owner) === false) {
+                throw new \BadMethodCallException('Unknown user: ' .
+                'method expects path to a user folder relative to the data folder');
+            }
+        }
 
-		return $owner;
-	}
+        return $owner;
+    }
 
-	/**
-	 * get storage of path
-	 *
-	 * @param string $path
-	 * @return \OC\Files\Storage\Storage|null
-	 */
-	public function getStorage($path) {
-		return $this->files->getMount($path)->getStorage();
-	}
+    /**
+     * get storage of path
+     *
+     * @param string $path
+     * @return \OC\Files\Storage\Storage|null
+     */
+    public function getStorage($path) {
+        return $this->files->getMount($path)->getStorage();
+    }
 }

apps/encryption/lib/Crypto/DecryptAll.php

Indentation +122 added lines, -122 removed lines

@@ -34,126 +34,126 @@
 
 class DecryptAll {
 
-	/** @var Util  */
-	protected $util;
-
-	/** @var QuestionHelper  */
-	protected $questionHelper;
-
-	/** @var  Crypt */
-	protected $crypt;
-
-	/** @var  KeyManager */
-	protected $keyManager;
-
-	/** @var Session  */
-	protected $session;
-
-	/**
-	 * @param Util $util
-	 * @param KeyManager $keyManager
-	 * @param Crypt $crypt
-	 * @param Session $session
-	 * @param QuestionHelper $questionHelper
-	 */
-	public function __construct(
-		Util $util,
-		KeyManager $keyManager,
-		Crypt $crypt,
-		Session $session,
-		QuestionHelper $questionHelper
-	) {
-		$this->util = $util;
-		$this->keyManager = $keyManager;
-		$this->crypt = $crypt;
-		$this->session = $session;
-		$this->questionHelper = $questionHelper;
-	}
-
-	/**
-	 * prepare encryption module to decrypt all files
-	 *
-	 * @param InputInterface $input
-	 * @param OutputInterface $output
-	 * @param $user
-	 * @return bool
-	 */
-	public function prepare(InputInterface $input, OutputInterface $output, $user) {
-		$question = new Question('Please enter the recovery key password: ');
-
-		if ($this->util->isMasterKeyEnabled()) {
-			$output->writeln('Use master key to decrypt all files');
-			$user = $this->keyManager->getMasterKeyId();
-			$password = $this->keyManager->getMasterKeyPassword();
-		} else {
-			$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
-			if (!empty($user)) {
-				$output->writeln('You can only decrypt the users files if you know');
-				$output->writeln('the users password or if he activated the recovery key.');
-				$output->writeln('');
-				$questionUseLoginPassword = new ConfirmationQuestion(
-					'Do you want to use the users login password to decrypt all files? (y/n) ',
-					false
-				);
-				$useLoginPassword = $this->questionHelper->ask($input, $output, $questionUseLoginPassword);
-				if ($useLoginPassword) {
-					$question = new Question('Please enter the user\'s login password: ');
-				} elseif ($this->util->isRecoveryEnabledForUser($user) === false) {
-					$output->writeln('No recovery key available for user ' . $user);
-					return false;
-				} else {
-					$user = $recoveryKeyId;
-				}
-			} else {
-				$output->writeln('You can only decrypt the files of all users if the');
-				$output->writeln('recovery key is enabled by the admin and activated by the users.');
-				$output->writeln('');
-				$user = $recoveryKeyId;
-			}
-
-			$question->setHidden(true);
-			$question->setHiddenFallback(false);
-			$password = $this->questionHelper->ask($input, $output, $question);
-		}
-
-		$privateKey = $this->getPrivateKey($user, $password);
-		if ($privateKey !== false) {
-			$this->updateSession($user, $privateKey);
-			return true;
-		} else {
-			$output->writeln('Could not decrypt private key, maybe you entered the wrong password?');
-		}
-
-
-		return false;
-	}
-
-	/**
-	 * get the private key which will be used to decrypt all files
-	 *
-	 * @param string $user
-	 * @param string $password
-	 * @return bool|string
-	 * @throws \OCA\Encryption\Exceptions\PrivateKeyMissingException
-	 */
-	protected function getPrivateKey($user, $password) {
-		$recoveryKeyId = $this->keyManager->getRecoveryKeyId();
-		$masterKeyId = $this->keyManager->getMasterKeyId();
-		if ($user === $recoveryKeyId) {
-			$recoveryKey = $this->keyManager->getSystemPrivateKey($recoveryKeyId);
-			$privateKey = $this->crypt->decryptPrivateKey($recoveryKey, $password);
-		} elseif ($user === $masterKeyId) {
-			$masterKey = $this->keyManager->getSystemPrivateKey($masterKeyId);
-			$privateKey = $this->crypt->decryptPrivateKey($masterKey, $password, $masterKeyId);
-		} else {
-			$userKey = $this->keyManager->getPrivateKey($user);
-			$privateKey = $this->crypt->decryptPrivateKey($userKey, $password, $user);
-		}
-
-		return $privateKey;
-	}
-
-	protected function updateSession($user, $privateKey) {
-		$this->session->prepareDecryptAll($user, $privateKey);
-	}
+    /** @var Util  */
+    protected $util;
+
+    /** @var QuestionHelper  */
+    protected $questionHelper;
+
+    /** @var  Crypt */
+    protected $crypt;
+
+    /** @var  KeyManager */
+    protected $keyManager;
+
+    /** @var Session  */
+    protected $session;
+
+    /**
+     * @param Util $util
+     * @param KeyManager $keyManager
+     * @param Crypt $crypt
+     * @param Session $session
+     * @param QuestionHelper $questionHelper
+     */
+    public function __construct(
+        Util $util,
+        KeyManager $keyManager,
+        Crypt $crypt,
+        Session $session,
+        QuestionHelper $questionHelper
+    ) {
+        $this->util = $util;
+        $this->keyManager = $keyManager;
+        $this->crypt = $crypt;
+        $this->session = $session;
+        $this->questionHelper = $questionHelper;
+    }
+
+    /**
+     * prepare encryption module to decrypt all files
+     *
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     * @param $user
+     * @return bool
+     */
+    public function prepare(InputInterface $input, OutputInterface $output, $user) {
+        $question = new Question('Please enter the recovery key password: ');
+
+        if ($this->util->isMasterKeyEnabled()) {
+            $output->writeln('Use master key to decrypt all files');
+            $user = $this->keyManager->getMasterKeyId();
+            $password = $this->keyManager->getMasterKeyPassword();
+        } else {
+            $recoveryKeyId = $this->keyManager->getRecoveryKeyId();
+            if (!empty($user)) {
+                $output->writeln('You can only decrypt the users files if you know');
+                $output->writeln('the users password or if he activated the recovery key.');
+                $output->writeln('');
+                $questionUseLoginPassword = new ConfirmationQuestion(
+                    'Do you want to use the users login password to decrypt all files? (y/n) ',
+                    false
+                );
+                $useLoginPassword = $this->questionHelper->ask($input, $output, $questionUseLoginPassword);
+                if ($useLoginPassword) {
+                    $question = new Question('Please enter the user\'s login password: ');
+                } elseif ($this->util->isRecoveryEnabledForUser($user) === false) {
+                    $output->writeln('No recovery key available for user ' . $user);
+                    return false;
+                } else {
+                    $user = $recoveryKeyId;
+                }
+            } else {
+                $output->writeln('You can only decrypt the files of all users if the');
+                $output->writeln('recovery key is enabled by the admin and activated by the users.');
+                $output->writeln('');
+                $user = $recoveryKeyId;
+            }
+
+            $question->setHidden(true);
+            $question->setHiddenFallback(false);
+            $password = $this->questionHelper->ask($input, $output, $question);
+        }
+
+        $privateKey = $this->getPrivateKey($user, $password);
+        if ($privateKey !== false) {
+            $this->updateSession($user, $privateKey);
+            return true;
+        } else {
+            $output->writeln('Could not decrypt private key, maybe you entered the wrong password?');
+        }
+
+
+        return false;
+    }
+
+    /**
+     * get the private key which will be used to decrypt all files
+     *
+     * @param string $user
+     * @param string $password
+     * @return bool|string
+     * @throws \OCA\Encryption\Exceptions\PrivateKeyMissingException
+     */
+    protected function getPrivateKey($user, $password) {
+        $recoveryKeyId = $this->keyManager->getRecoveryKeyId();
+        $masterKeyId = $this->keyManager->getMasterKeyId();
+        if ($user === $recoveryKeyId) {
+            $recoveryKey = $this->keyManager->getSystemPrivateKey($recoveryKeyId);
+            $privateKey = $this->crypt->decryptPrivateKey($recoveryKey, $password);
+        } elseif ($user === $masterKeyId) {
+            $masterKey = $this->keyManager->getSystemPrivateKey($masterKeyId);
+            $privateKey = $this->crypt->decryptPrivateKey($masterKey, $password, $masterKeyId);
+        } else {
+            $userKey = $this->keyManager->getPrivateKey($user);
+            $privateKey = $this->crypt->decryptPrivateKey($userKey, $password, $user);
+        }
+
+        return $privateKey;
+    }
+
+    protected function updateSession($user, $privateKey) {
+        $this->session->prepareDecryptAll($user, $privateKey);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -99,7 +99,7 @@
 				if ($useLoginPassword) {
 					$question = new Question('Please enter the user\'s login password: ');
 				} elseif ($this->util->isRecoveryEnabledForUser($user) === false) {
-					$output->writeln('No recovery key available for user ' . $user);
+					$output->writeln('No recovery key available for user '.$user);
 					return false;
 				} else {
 					$user = $recoveryKeyId;

apps/encryption/lib/Exceptions/PrivateKeyMissingException.php

Indentation +9 added lines, -9 removed lines

@@ -28,13 +28,13 @@
 
 class PrivateKeyMissingException extends GenericEncryptionException {
 
-	/**
-	 * @param string $userId
-	 */
-	public function __construct($userId) {
-		if (empty($userId)) {
-			$userId = "<no-user-id-given>";
-		}
-		parent::__construct("Private Key missing for user: $userId");
-	}
+    /**
+     * @param string $userId
+     */
+    public function __construct($userId) {
+        if (empty($userId)) {
+            $userId = "<no-user-id-given>";
+        }
+        parent::__construct("Private Key missing for user: $userId");
+    }
 }

apps/encryption/lib/Exceptions/PublicKeyMissingException.php

Indentation +9 added lines, -9 removed lines

@@ -25,13 +25,13 @@
 
 class PublicKeyMissingException extends GenericEncryptionException {
 
-	/**
-	 * @param string $userId
-	 */
-	public function __construct($userId) {
-		if (empty($userId)) {
-			$userId = "<no-user-id-given>";
-		}
-		parent::__construct("Public Key missing for user: $userId");
-	}
+    /**
+     * @param string $userId
+     */
+    public function __construct($userId) {
+        if (empty($userId)) {
+            $userId = "<no-user-id-given>";
+        }
+        parent::__construct("Public Key missing for user: $userId");
+    }
 }