nextcloud / server

apps/files_external/ajax/oauth1.php

Indentation +37 added lines, -37 removed lines

@@ -33,42 +33,42 @@
 
 // FIXME: currently hard-coded to Dropbox OAuth
 if (isset($_POST['app_key']) && isset($_POST['app_secret'])) {
-	$oauth = new Dropbox_OAuth_Curl((string)$_POST['app_key'], (string)$_POST['app_secret']);
-	if (isset($_POST['step'])) {
-		switch ($_POST['step']) {
-			case 1:
-				try {
-					if (isset($_POST['callback'])) {
-						$callback = (string)$_POST['callback'];
-					} else {
-						$callback = null;
-					}
-					$token = $oauth->getRequestToken();
-					OCP\JSON::success(array('data' => array('url' => $oauth->getAuthorizeUrl($callback),
-															'request_token' => $token['token'],
-															'request_token_secret' => $token['token_secret'])));
-				} catch (Exception $exception) {
-					OCP\JSON::error(array('data' => array('message' =>
-						$l->t('Fetching request tokens failed. Verify that your app key and secret are correct.'))
-						));
-				}
-				break;
-			case 2:
-				if (isset($_POST['request_token']) && isset($_POST['request_token_secret'])) {
-					try {
-						$oauth->setToken((string)$_POST['request_token'], (string)$_POST['request_token_secret']);
-						$token = $oauth->getAccessToken();
-						OCP\JSON::success(array('access_token' => $token['token'],
-												'access_token_secret' => $token['token_secret']));
-					} catch (Exception $exception) {
-						OCP\JSON::error(array('data' => array('message' =>
-							$l->t('Fetching access tokens failed. Verify that your app key and secret are correct.'))
-							));
-					}
-				}
-				break;
-		}
-	}
+    $oauth = new Dropbox_OAuth_Curl((string)$_POST['app_key'], (string)$_POST['app_secret']);
+    if (isset($_POST['step'])) {
+        switch ($_POST['step']) {
+            case 1:
+                try {
+                    if (isset($_POST['callback'])) {
+                        $callback = (string)$_POST['callback'];
+                    } else {
+                        $callback = null;
+                    }
+                    $token = $oauth->getRequestToken();
+                    OCP\JSON::success(array('data' => array('url' => $oauth->getAuthorizeUrl($callback),
+                                                            'request_token' => $token['token'],
+                                                            'request_token_secret' => $token['token_secret'])));
+                } catch (Exception $exception) {
+                    OCP\JSON::error(array('data' => array('message' =>
+                        $l->t('Fetching request tokens failed. Verify that your app key and secret are correct.'))
+                        ));
+                }
+                break;
+            case 2:
+                if (isset($_POST['request_token']) && isset($_POST['request_token_secret'])) {
+                    try {
+                        $oauth->setToken((string)$_POST['request_token'], (string)$_POST['request_token_secret']);
+                        $token = $oauth->getAccessToken();
+                        OCP\JSON::success(array('access_token' => $token['token'],
+                                                'access_token_secret' => $token['token_secret']));
+                    } catch (Exception $exception) {
+                        OCP\JSON::error(array('data' => array('message' =>
+                            $l->t('Fetching access tokens failed. Verify that your app key and secret are correct.'))
+                            ));
+                    }
+                }
+                break;
+        }
+    }
 } else {
-	OCP\JSON::error(array('data' => array('message' => $l->t('Please provide a valid app key and secret.'))));
+    OCP\JSON::error(array('data' => array('message' => $l->t('Please provide a valid app key and secret.'))));
 }

Spacing +4 added lines, -4 removed lines

@@ -24,7 +24,7 @@ 
  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  *
  */
-require_once __DIR__ . '/../3rdparty/Dropbox/autoload.php';
+require_once __DIR__.'/../3rdparty/Dropbox/autoload.php';
 
 OCP\JSON::checkAppEnabled('files_external');
 OCP\JSON::checkLoggedIn();
@@ -33,13 +33,13 @@ 
 
 // FIXME: currently hard-coded to Dropbox OAuth
 if (isset($_POST['app_key']) && isset($_POST['app_secret'])) {
-	$oauth = new Dropbox_OAuth_Curl((string)$_POST['app_key'], (string)$_POST['app_secret']);
+	$oauth = new Dropbox_OAuth_Curl((string) $_POST['app_key'], (string) $_POST['app_secret']);
 	if (isset($_POST['step'])) {
 		switch ($_POST['step']) {
 			case 1:
 				try {
 					if (isset($_POST['callback'])) {
-						$callback = (string)$_POST['callback'];
+						$callback = (string) $_POST['callback'];
 					} else {
 						$callback = null;
 					}
@@ -56,7 +56,7 @@ 
 			case 2:
 				if (isset($_POST['request_token']) && isset($_POST['request_token_secret'])) {
 					try {
-						$oauth->setToken((string)$_POST['request_token'], (string)$_POST['request_token_secret']);
+						$oauth->setToken((string) $_POST['request_token'], (string) $_POST['request_token_secret']);
 						$token = $oauth->getAccessToken();
 						OCP\JSON::success(array('access_token' => $token['token'],
 												'access_token_secret' => $token['token_secret']));

apps/files_external/ajax/oauth2.php

Indentation +34 added lines, -34 removed lines

@@ -28,7 +28,7 @@ 
  *
  */
 set_include_path(get_include_path().PATH_SEPARATOR.
-	\OC_App::getAppPath('files_external').'/3rdparty/google-api-php-client/src');
+    \OC_App::getAppPath('files_external').'/3rdparty/google-api-php-client/src');
 require_once 'Google/autoload.php';
 
 OCP\JSON::checkAppEnabled('files_external');
@@ -38,37 +38,37 @@ 
 
 // FIXME: currently hard-coded to Google Drive
 if (isset($_POST['client_id']) && isset($_POST['client_secret']) && isset($_POST['redirect'])) {
-	$client = new Google_Client();
-	$client->setClientId((string)$_POST['client_id']);
-	$client->setClientSecret((string)$_POST['client_secret']);
-	$client->setRedirectUri((string)$_POST['redirect']);
-	$client->setScopes(array('https://www.googleapis.com/auth/drive'));
-	$client->setApprovalPrompt('force');
-	$client->setAccessType('offline');
-	if (isset($_POST['step'])) {
-		$step = $_POST['step'];
-		if ($step == 1) {
-			try {
-				$authUrl = $client->createAuthUrl();
-				OCP\JSON::success(array('data' => array(
-					'url' => $authUrl
-				)));
-			} catch (Exception $exception) {
-				OCP\JSON::error(array('data' => array(
-					'message' => $l->t('Step 1 failed. Exception: %s', array($exception->getMessage()))
-				)));
-			}
-		} else if ($step == 2 && isset($_POST['code'])) {
-			try {
-				$token = $client->authenticate((string)$_POST['code']);
-				OCP\JSON::success(array('data' => array(
-					'token' => $token
-				)));
-			} catch (Exception $exception) {
-				OCP\JSON::error(array('data' => array(
-					'message' => $l->t('Step 2 failed. Exception: %s', array($exception->getMessage()))
-				)));
-			}
-		}
-	}
+    $client = new Google_Client();
+    $client->setClientId((string)$_POST['client_id']);
+    $client->setClientSecret((string)$_POST['client_secret']);
+    $client->setRedirectUri((string)$_POST['redirect']);
+    $client->setScopes(array('https://www.googleapis.com/auth/drive'));
+    $client->setApprovalPrompt('force');
+    $client->setAccessType('offline');
+    if (isset($_POST['step'])) {
+        $step = $_POST['step'];
+        if ($step == 1) {
+            try {
+                $authUrl = $client->createAuthUrl();
+                OCP\JSON::success(array('data' => array(
+                    'url' => $authUrl
+                )));
+            } catch (Exception $exception) {
+                OCP\JSON::error(array('data' => array(
+                    'message' => $l->t('Step 1 failed. Exception: %s', array($exception->getMessage()))
+                )));
+            }
+        } else if ($step == 2 && isset($_POST['code'])) {
+            try {
+                $token = $client->authenticate((string)$_POST['code']);
+                OCP\JSON::success(array('data' => array(
+                    'token' => $token
+                )));
+            } catch (Exception $exception) {
+                OCP\JSON::error(array('data' => array(
+                    'message' => $l->t('Step 2 failed. Exception: %s', array($exception->getMessage()))
+                )));
+            }
+        }
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -39,9 +39,9 @@ 
 // FIXME: currently hard-coded to Google Drive
 if (isset($_POST['client_id']) && isset($_POST['client_secret']) && isset($_POST['redirect'])) {
 	$client = new Google_Client();
-	$client->setClientId((string)$_POST['client_id']);
-	$client->setClientSecret((string)$_POST['client_secret']);
-	$client->setRedirectUri((string)$_POST['redirect']);
+	$client->setClientId((string) $_POST['client_id']);
+	$client->setClientSecret((string) $_POST['client_secret']);
+	$client->setRedirectUri((string) $_POST['redirect']);
 	$client->setScopes(array('https://www.googleapis.com/auth/drive'));
 	$client->setApprovalPrompt('force');
 	$client->setAccessType('offline');
@@ -60,7 +60,7 @@ 
 			}
 		} else if ($step == 2 && isset($_POST['code'])) {
 			try {
-				$token = $client->authenticate((string)$_POST['code']);
+				$token = $client->authenticate((string) $_POST['code']);
 				OCP\JSON::success(array('data' => array(
 					'token' => $token
 				)));

apps/files_external/ajax/applicable.php

Indentation +5 added lines, -5 removed lines

@@ -30,23 +30,23 @@
 $limit = null;
 $offset = null;
 if (isset($_GET['pattern'])) {
-	$pattern = (string)$_GET['pattern'];
+    $pattern = (string)$_GET['pattern'];
 }
 if (isset($_GET['limit'])) {
-	$limit = (int)$_GET['limit'];
+    $limit = (int)$_GET['limit'];
 }
 if (isset($_GET['offset'])) {
-	$offset = (int)$_GET['offset'];
+    $offset = (int)$_GET['offset'];
 }
 
 $groups = [];
 foreach (\OC::$server->getGroupManager()->search($pattern, $limit, $offset) as $group) {
-	$groups[$group->getGID()] = $group->getGID();
+    $groups[$group->getGID()] = $group->getGID();
 }
 
 $users = [];
 foreach (\OC::$server->getUserManager()->searchDisplayName($pattern, $limit, $offset) as $user) {
-	$users[$user->getUID()] = $user->getDisplayName();
+    $users[$user->getUID()] = $user->getDisplayName();
 }
 
 $results = array('groups' => $groups, 'users' => $users);

Spacing +3 added lines, -3 removed lines

@@ -30,13 +30,13 @@
 $limit = null;
 $offset = null;
 if (isset($_GET['pattern'])) {
-	$pattern = (string)$_GET['pattern'];
+	$pattern = (string) $_GET['pattern'];
 }
 if (isset($_GET['limit'])) {
-	$limit = (int)$_GET['limit'];
+	$limit = (int) $_GET['limit'];
 }
 if (isset($_GET['offset'])) {
-	$offset = (int)$_GET['offset'];
+	$offset = (int) $_GET['offset'];
 }
 
 $groups = [];

apps/files_external/lib/Service/ImportLegacyStoragesService.php

Indentation +18 added lines, -18 removed lines

@@ -24,25 +24,25 @@
 namespace OCA\Files_External\Service;
 
 class ImportLegacyStoragesService extends LegacyStoragesService {
-	private $data;
+    private $data;
 
-	/**
-	 * @param BackendService $backendService
-	 */
-	public function __construct(BackendService $backendService) {
-		$this->backendService = $backendService;
-	}
+    /**
+     * @param BackendService $backendService
+     */
+    public function __construct(BackendService $backendService) {
+        $this->backendService = $backendService;
+    }
 
-	public function setData($data) {
-		$this->data = $data;
-	}
+    public function setData($data) {
+        $this->data = $data;
+    }
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of mount configs
-	 */
-	protected function readLegacyConfig() {
-		return $this->data;
-	}
+    /**
+     * Read legacy config data
+     *
+     * @return array list of mount configs
+     */
+    protected function readLegacyConfig() {
+        return $this->data;
+    }
 }

apps/files_external/lib/Service/BackendService.php

Indentation +245 added lines, -245 removed lines

@@ -35,249 +35,249 @@
  */
 class BackendService {
 
-	/** Visibility constants for VisibilityTrait */
-	const VISIBILITY_NONE = 0;
-	const VISIBILITY_PERSONAL = 1;
-	const VISIBILITY_ADMIN = 2;
-	//const VISIBILITY_ALIENS = 4;
-
-	const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
-
-	/** Priority constants for PriorityTrait */
-	const PRIORITY_DEFAULT = 100;
-
-	/** @var IConfig */
-	protected $config;
-
-	/** @var bool */
-	private $userMountingAllowed = true;
-
-	/** @var string[] */
-	private $userMountingBackends = [];
-
-	/** @var Backend[] */
-	private $backends = [];
-
-	/** @var IBackendProvider[] */
-	private $backendProviders = [];
-
-	/** @var AuthMechanism[] */
-	private $authMechanisms = [];
-
-	/** @var IAuthMechanismProvider[] */
-	private $authMechanismProviders = [];
-
-	/**
-	 * @param IConfig $config
-	 */
-	public function __construct(
-		IConfig $config
-	) {
-		$this->config = $config;
-
-		// Load config values
-		if ($this->config->getAppValue('files_external', 'allow_user_mounting', 'yes') !== 'yes') {
-			$this->userMountingAllowed = false;
-		}
-		$this->userMountingBackends = explode(',',
-			$this->config->getAppValue('files_external', 'user_mounting_backends', '')
-		);
-
-		// if no backend is in the list an empty string is in the array and user mounting is disabled
-		if ($this->userMountingBackends === ['']) {
-			$this->userMountingAllowed = false;
-		}
-	}
-
-	/**
-	 * Register a backend provider
-	 *
-	 * @since 9.1.0
-	 * @param IBackendProvider $provider
-	 */
-	public function registerBackendProvider(IBackendProvider $provider) {
-		$this->backendProviders[] = $provider;
-	}
-
-	private function loadBackendProviders() {
-		foreach ($this->backendProviders as $provider) {
-			$this->registerBackends($provider->getBackends());
-		}
-		$this->backendProviders = [];
-	}
-
-	/**
-	 * Register an auth mechanism provider
-	 *
-	 * @since 9.1.0
-	 * @param IAuthMechanismProvider $provider
-	 */
-	public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
-		$this->authMechanismProviders[] = $provider;
-	}
-
-	private function loadAuthMechanismProviders() {
-		foreach ($this->authMechanismProviders as $provider) {
-			$this->registerAuthMechanisms($provider->getAuthMechanisms());
-		}
-		$this->authMechanismProviders = [];
-	}
-
-	/**
-	 * Register a backend
-	 *
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend $backend
-	 */
-	public function registerBackend(Backend $backend) {
-		if (!$this->isAllowedUserBackend($backend)) {
-			$backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($backend->getIdentifierAliases() as $alias) {
-			$this->backends[$alias] = $backend;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerBackendProvider()
-	 * @param Backend[] $backends
-	 */
-	public function registerBackends(array $backends) {
-		foreach ($backends as $backend) {
-			$this->registerBackend($backend);
-		}
-	}
-	/**
-	 * Register an authentication mechanism
-	 *
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism $authMech
-	 */
-	public function registerAuthMechanism(AuthMechanism $authMech) {
-		if (!$this->isAllowedAuthMechanism($authMech)) {
-			$authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
-		}
-		foreach ($authMech->getIdentifierAliases() as $alias) {
-			$this->authMechanisms[$alias] = $authMech;
-		}
-	}
-
-	/**
-	 * @deprecated 9.1.0 use registerAuthMechanismProvider()
-	 * @param AuthMechanism[] $mechanisms
-	 */
-	public function registerAuthMechanisms(array $mechanisms) {
-		foreach ($mechanisms as $mechanism) {
-			$this->registerAuthMechanism($mechanism);
-		}
-	}
-
-	/**
-	 * Get all backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getBackends() {
-		$this->loadBackendProviders();
-		// only return real identifiers, no aliases
-		$backends = [];
-		foreach ($this->backends as $backend) {
-			$backends[$backend->getIdentifier()] = $backend;
-		}
-		return $backends;
-	}
-
-	/**
-	 * Get all available backends
-	 *
-	 * @return Backend[]
-	 */
-	public function getAvailableBackends() {
-		return array_filter($this->getBackends(), function($backend) {
-			return !($backend->checkDependencies());
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return Backend|null
-	 */
-	public function getBackend($identifier) {
-		$this->loadBackendProviders();
-		if (isset($this->backends[$identifier])) {
-			return $this->backends[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * Get all authentication mechanisms
-	 *
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanisms() {
-		$this->loadAuthMechanismProviders();
-		// only return real identifiers, no aliases
-		$mechanisms = [];
-		foreach ($this->authMechanisms as $mechanism) {
-			$mechanisms[$mechanism->getIdentifier()] = $mechanism;
-		}
-		return $mechanisms;
-	}
-
-	/**
-	 * Get all authentication mechanisms for schemes
-	 *
-	 * @param string[] $schemes
-	 * @return AuthMechanism[]
-	 */
-	public function getAuthMechanismsByScheme(array $schemes) {
-		return array_filter($this->getAuthMechanisms(), function($authMech) use ($schemes) {
-			return in_array($authMech->getScheme(), $schemes, true);
-		});
-	}
-
-	/**
-	 * @param string $identifier
-	 * @return AuthMechanism|null
-	 */
-	public function getAuthMechanism($identifier) {
-		$this->loadAuthMechanismProviders();
-		if (isset($this->authMechanisms[$identifier])) {
-			return $this->authMechanisms[$identifier];
-		}
-		return null;
-	}
-
-	/**
-	 * @return bool
-	 */
-	public function isUserMountingAllowed() {
-		return $this->userMountingAllowed;
-	}
-
-	/**
-	 * Check a backend if a user is allowed to mount it
-	 *
-	 * @param Backend $backend
-	 * @return bool
-	 */
-	protected function isAllowedUserBackend(Backend $backend) {
-		if ($this->userMountingAllowed &&
-			array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
-		) {
-			return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Check an authentication mechanism if a user is allowed to use it
-	 *
-	 * @param AuthMechanism $authMechanism
-	 * @return bool
-	 */
-	protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
-		return true; // not implemented
-	}
+    /** Visibility constants for VisibilityTrait */
+    const VISIBILITY_NONE = 0;
+    const VISIBILITY_PERSONAL = 1;
+    const VISIBILITY_ADMIN = 2;
+    //const VISIBILITY_ALIENS = 4;
+
+    const VISIBILITY_DEFAULT = 3; // PERSONAL | ADMIN
+
+    /** Priority constants for PriorityTrait */
+    const PRIORITY_DEFAULT = 100;
+
+    /** @var IConfig */
+    protected $config;
+
+    /** @var bool */
+    private $userMountingAllowed = true;
+
+    /** @var string[] */
+    private $userMountingBackends = [];
+
+    /** @var Backend[] */
+    private $backends = [];
+
+    /** @var IBackendProvider[] */
+    private $backendProviders = [];
+
+    /** @var AuthMechanism[] */
+    private $authMechanisms = [];
+
+    /** @var IAuthMechanismProvider[] */
+    private $authMechanismProviders = [];
+
+    /**
+     * @param IConfig $config
+     */
+    public function __construct(
+        IConfig $config
+    ) {
+        $this->config = $config;
+
+        // Load config values
+        if ($this->config->getAppValue('files_external', 'allow_user_mounting', 'yes') !== 'yes') {
+            $this->userMountingAllowed = false;
+        }
+        $this->userMountingBackends = explode(',',
+            $this->config->getAppValue('files_external', 'user_mounting_backends', '')
+        );
+
+        // if no backend is in the list an empty string is in the array and user mounting is disabled
+        if ($this->userMountingBackends === ['']) {
+            $this->userMountingAllowed = false;
+        }
+    }
+
+    /**
+     * Register a backend provider
+     *
+     * @since 9.1.0
+     * @param IBackendProvider $provider
+     */
+    public function registerBackendProvider(IBackendProvider $provider) {
+        $this->backendProviders[] = $provider;
+    }
+
+    private function loadBackendProviders() {
+        foreach ($this->backendProviders as $provider) {
+            $this->registerBackends($provider->getBackends());
+        }
+        $this->backendProviders = [];
+    }
+
+    /**
+     * Register an auth mechanism provider
+     *
+     * @since 9.1.0
+     * @param IAuthMechanismProvider $provider
+     */
+    public function registerAuthMechanismProvider(IAuthMechanismProvider $provider) {
+        $this->authMechanismProviders[] = $provider;
+    }
+
+    private function loadAuthMechanismProviders() {
+        foreach ($this->authMechanismProviders as $provider) {
+            $this->registerAuthMechanisms($provider->getAuthMechanisms());
+        }
+        $this->authMechanismProviders = [];
+    }
+
+    /**
+     * Register a backend
+     *
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend $backend
+     */
+    public function registerBackend(Backend $backend) {
+        if (!$this->isAllowedUserBackend($backend)) {
+            $backend->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($backend->getIdentifierAliases() as $alias) {
+            $this->backends[$alias] = $backend;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerBackendProvider()
+     * @param Backend[] $backends
+     */
+    public function registerBackends(array $backends) {
+        foreach ($backends as $backend) {
+            $this->registerBackend($backend);
+        }
+    }
+    /**
+     * Register an authentication mechanism
+     *
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism $authMech
+     */
+    public function registerAuthMechanism(AuthMechanism $authMech) {
+        if (!$this->isAllowedAuthMechanism($authMech)) {
+            $authMech->removeVisibility(BackendService::VISIBILITY_PERSONAL);
+        }
+        foreach ($authMech->getIdentifierAliases() as $alias) {
+            $this->authMechanisms[$alias] = $authMech;
+        }
+    }
+
+    /**
+     * @deprecated 9.1.0 use registerAuthMechanismProvider()
+     * @param AuthMechanism[] $mechanisms
+     */
+    public function registerAuthMechanisms(array $mechanisms) {
+        foreach ($mechanisms as $mechanism) {
+            $this->registerAuthMechanism($mechanism);
+        }
+    }
+
+    /**
+     * Get all backends
+     *
+     * @return Backend[]
+     */
+    public function getBackends() {
+        $this->loadBackendProviders();
+        // only return real identifiers, no aliases
+        $backends = [];
+        foreach ($this->backends as $backend) {
+            $backends[$backend->getIdentifier()] = $backend;
+        }
+        return $backends;
+    }
+
+    /**
+     * Get all available backends
+     *
+     * @return Backend[]
+     */
+    public function getAvailableBackends() {
+        return array_filter($this->getBackends(), function($backend) {
+            return !($backend->checkDependencies());
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return Backend|null
+     */
+    public function getBackend($identifier) {
+        $this->loadBackendProviders();
+        if (isset($this->backends[$identifier])) {
+            return $this->backends[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * Get all authentication mechanisms
+     *
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanisms() {
+        $this->loadAuthMechanismProviders();
+        // only return real identifiers, no aliases
+        $mechanisms = [];
+        foreach ($this->authMechanisms as $mechanism) {
+            $mechanisms[$mechanism->getIdentifier()] = $mechanism;
+        }
+        return $mechanisms;
+    }
+
+    /**
+     * Get all authentication mechanisms for schemes
+     *
+     * @param string[] $schemes
+     * @return AuthMechanism[]
+     */
+    public function getAuthMechanismsByScheme(array $schemes) {
+        return array_filter($this->getAuthMechanisms(), function($authMech) use ($schemes) {
+            return in_array($authMech->getScheme(), $schemes, true);
+        });
+    }
+
+    /**
+     * @param string $identifier
+     * @return AuthMechanism|null
+     */
+    public function getAuthMechanism($identifier) {
+        $this->loadAuthMechanismProviders();
+        if (isset($this->authMechanisms[$identifier])) {
+            return $this->authMechanisms[$identifier];
+        }
+        return null;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isUserMountingAllowed() {
+        return $this->userMountingAllowed;
+    }
+
+    /**
+     * Check a backend if a user is allowed to mount it
+     *
+     * @param Backend $backend
+     * @return bool
+     */
+    protected function isAllowedUserBackend(Backend $backend) {
+        if ($this->userMountingAllowed &&
+            array_intersect($backend->getIdentifierAliases(), $this->userMountingBackends)
+        ) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check an authentication mechanism if a user is allowed to use it
+     *
+     * @param AuthMechanism $authMechanism
+     * @return bool
+     */
+    protected function isAllowedAuthMechanism(AuthMechanism $authMechanism) {
+        return true; // not implemented
+    }
 }

apps/files_external/lib/Service/GlobalStoragesService.php

Indentation +147 added lines, -147 removed lines

@@ -35,151 +35,151 @@
  * Service class to manage global external storages
  */
 class GlobalStoragesService extends StoragesService {
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	protected function triggerHooks(StorageConfig $storage, $signal) {
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		$applicableUsers = $storage->getApplicableUsers();
-		$applicableGroups = $storage->getApplicableGroups();
-		if (empty($applicableUsers) && empty($applicableGroups)) {
-			// raise for user "all"
-			$this->triggerApplicableHooks(
-				$signal,
-				$storage->getMountPoint(),
-				\OC_Mount_Config::MOUNT_TYPE_USER,
-				['all']
-			);
-			return;
-		}
-
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$applicableUsers
-		);
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_GROUP,
-			$applicableGroups
-		);
-	}
-
-	/**
-	 * Triggers signal_create_mount or signal_delete_mount to
-	 * accommodate for additions/deletions in applicableUsers
-	 * and applicableGroups fields.
-	 *
-	 * @param StorageConfig $oldStorage old storage config
-	 * @param StorageConfig $newStorage new storage config
-	 */
-	protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
-		// if mount point changed, it's like a deletion + creation
-		if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
-			$this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
-			$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-			return;
-		}
-
-		$userAdditions = array_diff($newStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
-		$userDeletions = array_diff($oldStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
-		$groupAdditions = array_diff($newStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
-		$groupDeletions = array_diff($oldStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
-
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		// if no applicable were set, raise a signal for "all"
-		$oldApplicableUsers = $oldStorage->getApplicableUsers();
-		$oldApplicableGroups = $oldStorage->getApplicableGroups();
-		if (empty($oldApplicableUsers) && empty($oldApplicableGroups)) {
-			$this->triggerApplicableHooks(
-				Filesystem::signal_delete_mount,
-				$oldStorage->getMountPoint(),
-				\OC_Mount_Config::MOUNT_TYPE_USER,
-				['all']
-			);
-		}
-
-		// trigger delete for removed users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$userDeletions
-		);
-
-		// trigger delete for removed groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_delete_mount,
-			$oldStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_GROUP,
-			$groupDeletions
-		);
-
-		// and now add the new users
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			$userAdditions
-		);
-
-		// and now add the new groups
-		$this->triggerApplicableHooks(
-			Filesystem::signal_create_mount,
-			$newStorage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_GROUP,
-			$groupAdditions
-		);
-
-		// FIXME: Use as expression in empty once PHP 5.4 support is dropped
-		// if no applicable, raise a signal for "all"
-		$newApplicableUsers = $newStorage->getApplicableUsers();
-		$newApplicableGroups = $newStorage->getApplicableGroups();
-		if (empty($newApplicableUsers) && empty($newApplicableGroups)) {
-			$this->triggerApplicableHooks(
-				Filesystem::signal_create_mount,
-				$newStorage->getMountPoint(),
-				\OC_Mount_Config::MOUNT_TYPE_USER,
-				['all']
-			);
-		}
-	}
-
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	public function getVisibilityType() {
-		return BackendService::VISIBILITY_ADMIN;
-	}
-
-	protected function isApplicable(StorageConfig $config) {
-		return true;
-	}
-
-	/**
-	 * Get all configured admin and personal mounts
-	 *
-	 * @return array map of storage id to storage config
-	 */
-	public function getStorageForAllUsers() {
-		$mounts = $this->dbConfig->getAllMounts();
-		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
-			return $config instanceof StorageConfig;
-		});
-
-		$keys = array_map(function (StorageConfig $config) {
-			return $config->getId();
-		}, $configs);
-
-		return array_combine($keys, $configs);
-	}
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    protected function triggerHooks(StorageConfig $storage, $signal) {
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        $applicableUsers = $storage->getApplicableUsers();
+        $applicableGroups = $storage->getApplicableGroups();
+        if (empty($applicableUsers) && empty($applicableGroups)) {
+            // raise for user "all"
+            $this->triggerApplicableHooks(
+                $signal,
+                $storage->getMountPoint(),
+                \OC_Mount_Config::MOUNT_TYPE_USER,
+                ['all']
+            );
+            return;
+        }
+
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $applicableUsers
+        );
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_GROUP,
+            $applicableGroups
+        );
+    }
+
+    /**
+     * Triggers signal_create_mount or signal_delete_mount to
+     * accommodate for additions/deletions in applicableUsers
+     * and applicableGroups fields.
+     *
+     * @param StorageConfig $oldStorage old storage config
+     * @param StorageConfig $newStorage new storage config
+     */
+    protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
+        // if mount point changed, it's like a deletion + creation
+        if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
+            $this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
+            $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+            return;
+        }
+
+        $userAdditions = array_diff($newStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
+        $userDeletions = array_diff($oldStorage->getApplicableUsers(), $newStorage->getApplicableUsers());
+        $groupAdditions = array_diff($newStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
+        $groupDeletions = array_diff($oldStorage->getApplicableGroups(), $newStorage->getApplicableGroups());
+
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        // if no applicable were set, raise a signal for "all"
+        $oldApplicableUsers = $oldStorage->getApplicableUsers();
+        $oldApplicableGroups = $oldStorage->getApplicableGroups();
+        if (empty($oldApplicableUsers) && empty($oldApplicableGroups)) {
+            $this->triggerApplicableHooks(
+                Filesystem::signal_delete_mount,
+                $oldStorage->getMountPoint(),
+                \OC_Mount_Config::MOUNT_TYPE_USER,
+                ['all']
+            );
+        }
+
+        // trigger delete for removed users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $userDeletions
+        );
+
+        // trigger delete for removed groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_delete_mount,
+            $oldStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_GROUP,
+            $groupDeletions
+        );
+
+        // and now add the new users
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            $userAdditions
+        );
+
+        // and now add the new groups
+        $this->triggerApplicableHooks(
+            Filesystem::signal_create_mount,
+            $newStorage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_GROUP,
+            $groupAdditions
+        );
+
+        // FIXME: Use as expression in empty once PHP 5.4 support is dropped
+        // if no applicable, raise a signal for "all"
+        $newApplicableUsers = $newStorage->getApplicableUsers();
+        $newApplicableGroups = $newStorage->getApplicableGroups();
+        if (empty($newApplicableUsers) && empty($newApplicableGroups)) {
+            $this->triggerApplicableHooks(
+                Filesystem::signal_create_mount,
+                $newStorage->getMountPoint(),
+                \OC_Mount_Config::MOUNT_TYPE_USER,
+                ['all']
+            );
+        }
+    }
+
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    public function getVisibilityType() {
+        return BackendService::VISIBILITY_ADMIN;
+    }
+
+    protected function isApplicable(StorageConfig $config) {
+        return true;
+    }
+
+    /**
+     * Get all configured admin and personal mounts
+     *
+     * @return array map of storage id to storage config
+     */
+    public function getStorageForAllUsers() {
+        $mounts = $this->dbConfig->getAllMounts();
+        $configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
+        $configs = array_filter($configs, function ($config) {
+            return $config instanceof StorageConfig;
+        });
+
+        $keys = array_map(function (StorageConfig $config) {
+            return $config->getId();
+        }, $configs);
+
+        return array_combine($keys, $configs);
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -172,11 +172,11 @@
 	public function getStorageForAllUsers() {
 		$mounts = $this->dbConfig->getAllMounts();
 		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
+		$configs = array_filter($configs, function($config) {
 			return $config instanceof StorageConfig;
 		});
 
-		$keys = array_map(function (StorageConfig $config) {
+		$keys = array_map(function(StorageConfig $config) {
 			return $config->getId();
 		}, $configs);
 

apps/files_external/lib/Service/UserLegacyStoragesService.php

Indentation +22 added lines, -22 removed lines

@@ -29,28 +29,28 @@
  * Read user defined mounts from the legacy mount.json
  */
 class UserLegacyStoragesService extends LegacyStoragesService {
-	/**
-	 * @var IUserSession
-	 */
-	private $userSession;
+    /**
+     * @var IUserSession
+     */
+    private $userSession;
 
-	/**
-	 * @param BackendService $backendService
-	 * @param IUserSession $userSession
-	 */
-	public function __construct(BackendService $backendService, IUserSession $userSession) {
-		$this->backendService = $backendService;
-		$this->userSession = $userSession;
-	}
+    /**
+     * @param BackendService $backendService
+     * @param IUserSession $userSession
+     */
+    public function __construct(BackendService $backendService, IUserSession $userSession) {
+        $this->backendService = $backendService;
+        $this->userSession = $userSession;
+    }
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of storage configs
-	 */
-	protected function readLegacyConfig() {
-		// read user config
-		$user = $this->userSession->getUser()->getUID();
-		return \OC_Mount_Config::readData($user);
-	}
+    /**
+     * Read legacy config data
+     *
+     * @return array list of storage configs
+     */
+    protected function readLegacyConfig() {
+        // read user config
+        $user = $this->userSession->getUser()->getUID();
+        return \OC_Mount_Config::readData($user);
+    }
 }

apps/files_external/lib/Service/DBConfigService.php

Spacing +13 added lines, -13 removed lines

@@ -178,7 +178,7 @@ 
 	 */
 	public function getAdminMountsForMultiple($type, array $values) {
 		$builder = $this->connection->getQueryBuilder();
-		$params = array_map(function ($value) use ($builder) {
+		$params = array_map(function($value) use ($builder) {
 			return $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR);
 		}, $values);
 
@@ -231,7 +231,7 @@ 
 				'type' => $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)
 			]);
 		$query->execute();
-		return (int)$this->connection->lastInsertId('*PREFIX*external_mounts');
+		return (int) $this->connection->lastInsertId('*PREFIX*external_mounts');
 	}
 
 	/**
@@ -367,7 +367,7 @@ 
 		}
 		$uniqueMounts = array_values($uniqueMounts);
 
-		$mountIds = array_map(function ($mount) {
+		$mountIds = array_map(function($mount) {
 			return $mount['mount_id'];
 		}, $uniqueMounts);
 		$mountIds = array_values(array_unique($mountIds));
@@ -376,9 +376,9 @@ 
 		$config = $this->getConfigForMounts($mountIds);
 		$options = $this->getOptionsForMounts($mountIds);
 
-		return array_map(function ($mount, $applicable, $config, $options) {
-			$mount['type'] = (int)$mount['type'];
-			$mount['priority'] = (int)$mount['priority'];
+		return array_map(function($mount, $applicable, $config, $options) {
+			$mount['type'] = (int) $mount['type'];
+			$mount['priority'] = (int) $mount['priority'];
 			$mount['applicable'] = $applicable;
 			$mount['config'] = $config;
 			$mount['options'] = $options;
@@ -400,7 +400,7 @@ 
 		}
 		$builder = $this->connection->getQueryBuilder();
 		$fields[] = 'mount_id';
-		$placeHolders = array_map(function ($id) use ($builder) {
+		$placeHolders = array_map(function($id) use ($builder) {
 			return $builder->createPositionalParameter($id, IQueryBuilder::PARAM_INT);
 		}, $mountIds);
 		$query = $builder->select($fields)
@@ -414,7 +414,7 @@ 
 		}
 		foreach ($rows as $row) {
 			if (isset($row['type'])) {
-				$row['type'] = (int)$row['type'];
+				$row['type'] = (int) $row['type'];
 			}
 			$result[$row['mount_id']][] = $row;
 		}
@@ -445,8 +445,8 @@ 
 	public function getOptionsForMounts($mountIds) {
 		$mountOptions = $this->selectForMounts('external_options', ['key', 'value'], $mountIds);
 		$optionsMap = array_map([$this, 'createKeyValueMap'], $mountOptions);
-		return array_map(function (array $options) {
-			return array_map(function ($option) {
+		return array_map(function(array $options) {
+			return array_map(function($option) {
 				return json_decode($option);
 			}, $options);
 		}, $optionsMap);
@@ -457,16 +457,16 @@ 
 	 * @return array ['key1' => $value1, ...]
 	 */
 	private function createKeyValueMap(array $keyValuePairs) {
-		$decryptedPairts = array_map(function ($pair) {
+		$decryptedPairts = array_map(function($pair) {
 			if ($pair['key'] === 'password') {
 				$pair['value'] = $this->decryptValue($pair['value']);
 			}
 			return $pair;
 		}, $keyValuePairs);
-		$keys = array_map(function ($pair) {
+		$keys = array_map(function($pair) {
 			return $pair['key'];
 		}, $decryptedPairts);
-		$values = array_map(function ($pair) {
+		$values = array_map(function($pair) {
 			return $pair['value'];
 		}, $decryptedPairts);
 

Indentation +429 added lines, -429 removed lines

@@ -32,433 +32,433 @@
  * Stores the mount config in the database
  */
 class DBConfigService {
-	const MOUNT_TYPE_ADMIN = 1;
-	const MOUNT_TYPE_PERSONAl = 2;
-
-	const APPLICABLE_TYPE_GLOBAL = 1;
-	const APPLICABLE_TYPE_GROUP = 2;
-	const APPLICABLE_TYPE_USER = 3;
-
-	/**
-	 * @var IDBConnection
-	 */
-	private $connection;
-
-	/**
-	 * @var ICrypto
-	 */
-	private $crypto;
-
-	/**
-	 * DBConfigService constructor.
-	 *
-	 * @param IDBConnection $connection
-	 * @param ICrypto $crypto
-	 */
-	public function __construct(IDBConnection $connection, ICrypto $crypto) {
-		$this->connection = $connection;
-		$this->crypto = $crypto;
-	}
-
-	/**
-	 * @param int $mountId
-	 * @return array
-	 */
-	public function getMountById($mountId) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
-			->from('external_mounts', 'm')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-		$mounts = $this->getMountsFromQuery($query);
-		if (count($mounts) > 0) {
-			return $mounts[0];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * Get all configured mounts
-	 *
-	 * @return array
-	 */
-	public function getAllMounts() {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
-			->from('external_mounts');
-		return $this->getMountsFromQuery($query);
-	}
-
-	/**
-	 * Get admin defined mounts
-	 *
-	 * @return array
-	 */
-	public function getAdminMounts() {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
-			->from('external_mounts')
-			->where($builder->expr()->eq('type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
-		return $this->getMountsFromQuery($query);
-	}
-
-	protected function getForQuery(IQueryBuilder $builder, $type, $value) {
-		$query = $builder->select(['m.mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'm.type'])
-			->from('external_mounts', 'm')
-			->innerJoin('m', 'external_applicable', 'a', $builder->expr()->eq('m.mount_id', 'a.mount_id'))
-			->where($builder->expr()->eq('a.type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)));
-
-		if (is_null($value)) {
-			$query = $query->andWhere($builder->expr()->isNull('a.value'));
-		} else {
-			$query = $query->andWhere($builder->expr()->eq('a.value', $builder->createNamedParameter($value)));
-		}
-
-		return $query;
-	}
-
-	/**
-	 * Get mounts by applicable
-	 *
-	 * @param int $type any of the self::APPLICABLE_TYPE_ constants
-	 * @param string|null $value user_id, group_id or null for global mounts
-	 * @return array
-	 */
-	public function getMountsFor($type, $value) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $this->getForQuery($builder, $type, $value);
-
-		return $this->getMountsFromQuery($query);
-	}
-
-	/**
-	 * Get admin defined mounts by applicable
-	 *
-	 * @param int $type any of the self::APPLICABLE_TYPE_ constants
-	 * @param string|null $value user_id, group_id or null for global mounts
-	 * @return array
-	 */
-	public function getAdminMountsFor($type, $value) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $this->getForQuery($builder, $type, $value);
-		$query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
-
-		return $this->getMountsFromQuery($query);
-	}
-
-	/**
-	 * Get admin defined mounts for multiple applicable
-	 *
-	 * @param int $type any of the self::APPLICABLE_TYPE_ constants
-	 * @param string[] $values user_ids or group_ids
-	 * @return array
-	 */
-	public function getAdminMountsForMultiple($type, array $values) {
-		$builder = $this->connection->getQueryBuilder();
-		$params = array_map(function ($value) use ($builder) {
-			return $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR);
-		}, $values);
-
-		$query = $builder->select(['m.mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'm.type'])
-			->from('external_mounts', 'm')
-			->innerJoin('m', 'external_applicable', 'a', $builder->expr()->eq('m.mount_id', 'a.mount_id'))
-			->where($builder->expr()->eq('a.type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)))
-			->andWhere($builder->expr()->in('a.value', $params));
-		$query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
-
-		return $this->getMountsFromQuery($query);
-	}
-
-	/**
-	 * Get user defined mounts by applicable
-	 *
-	 * @param int $type any of the self::APPLICABLE_TYPE_ constants
-	 * @param string|null $value user_id, group_id or null for global mounts
-	 * @return array
-	 */
-	public function getUserMountsFor($type, $value) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $this->getForQuery($builder, $type, $value);
-		$query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_PERSONAl, IQueryBuilder::PARAM_INT)));
-
-		return $this->getMountsFromQuery($query);
-	}
-
-	/**
-	 * Add a mount to the database
-	 *
-	 * @param string $mountPoint
-	 * @param string $storageBackend
-	 * @param string $authBackend
-	 * @param int $priority
-	 * @param int $type self::MOUNT_TYPE_ADMIN or self::MOUNT_TYPE_PERSONAL
-	 * @return int the id of the new mount
-	 */
-	public function addMount($mountPoint, $storageBackend, $authBackend, $priority, $type) {
-		if (!$priority) {
-			$priority = 100;
-		}
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->insert('external_mounts')
-			->values([
-				'mount_point' => $builder->createNamedParameter($mountPoint, IQueryBuilder::PARAM_STR),
-				'storage_backend' => $builder->createNamedParameter($storageBackend, IQueryBuilder::PARAM_STR),
-				'auth_backend' => $builder->createNamedParameter($authBackend, IQueryBuilder::PARAM_STR),
-				'priority' => $builder->createNamedParameter($priority, IQueryBuilder::PARAM_INT),
-				'type' => $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)
-			]);
-		$query->execute();
-		return (int)$this->connection->lastInsertId('*PREFIX*external_mounts');
-	}
-
-	/**
-	 * Remove a mount from the database
-	 *
-	 * @param int $mountId
-	 */
-	public function removeMount($mountId) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->delete('external_mounts')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-
-		$query = $builder->delete('external_applicable')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-
-		$query = $builder->delete('external_config')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-
-		$query = $builder->delete('external_options')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-		$query->execute();
-	}
-
-	/**
-	 * @param int $mountId
-	 * @param string $newMountPoint
-	 */
-	public function setMountPoint($mountId, $newMountPoint) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('external_mounts')
-			->set('mount_point', $builder->createNamedParameter($newMountPoint))
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-
-		$query->execute();
-	}
-
-	/**
-	 * @param int $mountId
-	 * @param string $newAuthBackend
-	 */
-	public function setAuthBackend($mountId, $newAuthBackend) {
-		$builder = $this->connection->getQueryBuilder();
-
-		$query = $builder->update('external_mounts')
-			->set('auth_backend', $builder->createNamedParameter($newAuthBackend))
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
-
-		$query->execute();
-	}
-
-	/**
-	 * @param int $mountId
-	 * @param string $key
-	 * @param string $value
-	 */
-	public function setConfig($mountId, $key, $value) {
-		if ($key === 'password') {
-			$value = $this->encryptValue($value);
-		}
-		$count = $this->connection->insertIfNotExist('*PREFIX*external_config', [
-			'mount_id' => $mountId,
-			'key' => $key,
-			'value' => $value
-		], ['mount_id', 'key']);
-		if ($count === 0) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->update('external_config')
-				->set('value', $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR))
-				->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
-				->andWhere($builder->expr()->eq('key', $builder->createNamedParameter($key, IQueryBuilder::PARAM_STR)));
-			$query->execute();
-		}
-	}
-
-	/**
-	 * @param int $mountId
-	 * @param string $key
-	 * @param string $value
-	 */
-	public function setOption($mountId, $key, $value) {
-
-		$count = $this->connection->insertIfNotExist('*PREFIX*external_options', [
-			'mount_id' => $mountId,
-			'key' => $key,
-			'value' => json_encode($value)
-		], ['mount_id', 'key']);
-		if ($count === 0) {
-			$builder = $this->connection->getQueryBuilder();
-			$query = $builder->update('external_options')
-				->set('value', $builder->createNamedParameter(json_encode($value), IQueryBuilder::PARAM_STR))
-				->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
-				->andWhere($builder->expr()->eq('key', $builder->createNamedParameter($key, IQueryBuilder::PARAM_STR)));
-			$query->execute();
-		}
-	}
-
-	public function addApplicable($mountId, $type, $value) {
-		$this->connection->insertIfNotExist('*PREFIX*external_applicable', [
-			'mount_id' => $mountId,
-			'type' => $type,
-			'value' => $value
-		], ['mount_id', 'type', 'value']);
-	}
-
-	public function removeApplicable($mountId, $type, $value) {
-		$builder = $this->connection->getQueryBuilder();
-		$query = $builder->delete('external_applicable')
-			->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
-			->andWhere($builder->expr()->eq('type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)));
-
-		if (is_null($value)) {
-			$query = $query->andWhere($builder->expr()->isNull('value'));
-		} else {
-			$query = $query->andWhere($builder->expr()->eq('value', $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR)));
-		}
-
-		$query->execute();
-	}
-
-	private function getMountsFromQuery(IQueryBuilder $query) {
-		$result = $query->execute();
-		$mounts = $result->fetchAll();
-		$uniqueMounts = [];
-		foreach ($mounts as $mount) {
-			$id = $mount['mount_id'];
-			if (!isset($uniqueMounts[$id])) {
-				$uniqueMounts[$id] = $mount;
-			}
-		}
-		$uniqueMounts = array_values($uniqueMounts);
-
-		$mountIds = array_map(function ($mount) {
-			return $mount['mount_id'];
-		}, $uniqueMounts);
-		$mountIds = array_values(array_unique($mountIds));
-
-		$applicable = $this->getApplicableForMounts($mountIds);
-		$config = $this->getConfigForMounts($mountIds);
-		$options = $this->getOptionsForMounts($mountIds);
-
-		return array_map(function ($mount, $applicable, $config, $options) {
-			$mount['type'] = (int)$mount['type'];
-			$mount['priority'] = (int)$mount['priority'];
-			$mount['applicable'] = $applicable;
-			$mount['config'] = $config;
-			$mount['options'] = $options;
-			return $mount;
-		}, $uniqueMounts, $applicable, $config, $options);
-	}
-
-	/**
-	 * Get mount options from a table grouped by mount id
-	 *
-	 * @param string $table
-	 * @param string[] $fields
-	 * @param int[] $mountIds
-	 * @return array [$mountId => [['field1' => $value1, ...], ...], ...]
-	 */
-	private function selectForMounts($table, array $fields, array $mountIds) {
-		if (count($mountIds) === 0) {
-			return [];
-		}
-		$builder = $this->connection->getQueryBuilder();
-		$fields[] = 'mount_id';
-		$placeHolders = array_map(function ($id) use ($builder) {
-			return $builder->createPositionalParameter($id, IQueryBuilder::PARAM_INT);
-		}, $mountIds);
-		$query = $builder->select($fields)
-			->from($table)
-			->where($builder->expr()->in('mount_id', $placeHolders));
-		$rows = $query->execute()->fetchAll();
-
-		$result = [];
-		foreach ($mountIds as $mountId) {
-			$result[$mountId] = [];
-		}
-		foreach ($rows as $row) {
-			if (isset($row['type'])) {
-				$row['type'] = (int)$row['type'];
-			}
-			$result[$row['mount_id']][] = $row;
-		}
-		return $result;
-	}
-
-	/**
-	 * @param int[] $mountIds
-	 * @return array [$id => [['type' => $type, 'value' => $value], ...], ...]
-	 */
-	public function getApplicableForMounts($mountIds) {
-		return $this->selectForMounts('external_applicable', ['type', 'value'], $mountIds);
-	}
-
-	/**
-	 * @param int[] $mountIds
-	 * @return array [$id => ['key1' => $value1, ...], ...]
-	 */
-	public function getConfigForMounts($mountIds) {
-		$mountConfigs = $this->selectForMounts('external_config', ['key', 'value'], $mountIds);
-		return array_map([$this, 'createKeyValueMap'], $mountConfigs);
-	}
-
-	/**
-	 * @param int[] $mountIds
-	 * @return array [$id => ['key1' => $value1, ...], ...]
-	 */
-	public function getOptionsForMounts($mountIds) {
-		$mountOptions = $this->selectForMounts('external_options', ['key', 'value'], $mountIds);
-		$optionsMap = array_map([$this, 'createKeyValueMap'], $mountOptions);
-		return array_map(function (array $options) {
-			return array_map(function ($option) {
-				return json_decode($option);
-			}, $options);
-		}, $optionsMap);
-	}
-
-	/**
-	 * @param array $keyValuePairs [['key'=>$key, 'value=>$value], ...]
-	 * @return array ['key1' => $value1, ...]
-	 */
-	private function createKeyValueMap(array $keyValuePairs) {
-		$decryptedPairts = array_map(function ($pair) {
-			if ($pair['key'] === 'password') {
-				$pair['value'] = $this->decryptValue($pair['value']);
-			}
-			return $pair;
-		}, $keyValuePairs);
-		$keys = array_map(function ($pair) {
-			return $pair['key'];
-		}, $decryptedPairts);
-		$values = array_map(function ($pair) {
-			return $pair['value'];
-		}, $decryptedPairts);
-
-		return array_combine($keys, $values);
-	}
-
-	private function encryptValue($value) {
-		return $this->crypto->encrypt($value);
-	}
-
-	private function decryptValue($value) {
-		try {
-			return $this->crypto->decrypt($value);
-		} catch (\Exception $e) {
-			return $value;
-		}
-	}
+    const MOUNT_TYPE_ADMIN = 1;
+    const MOUNT_TYPE_PERSONAl = 2;
+
+    const APPLICABLE_TYPE_GLOBAL = 1;
+    const APPLICABLE_TYPE_GROUP = 2;
+    const APPLICABLE_TYPE_USER = 3;
+
+    /**
+     * @var IDBConnection
+     */
+    private $connection;
+
+    /**
+     * @var ICrypto
+     */
+    private $crypto;
+
+    /**
+     * DBConfigService constructor.
+     *
+     * @param IDBConnection $connection
+     * @param ICrypto $crypto
+     */
+    public function __construct(IDBConnection $connection, ICrypto $crypto) {
+        $this->connection = $connection;
+        $this->crypto = $crypto;
+    }
+
+    /**
+     * @param int $mountId
+     * @return array
+     */
+    public function getMountById($mountId) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
+            ->from('external_mounts', 'm')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+        $mounts = $this->getMountsFromQuery($query);
+        if (count($mounts) > 0) {
+            return $mounts[0];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Get all configured mounts
+     *
+     * @return array
+     */
+    public function getAllMounts() {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
+            ->from('external_mounts');
+        return $this->getMountsFromQuery($query);
+    }
+
+    /**
+     * Get admin defined mounts
+     *
+     * @return array
+     */
+    public function getAdminMounts() {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->select(['mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'type'])
+            ->from('external_mounts')
+            ->where($builder->expr()->eq('type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
+        return $this->getMountsFromQuery($query);
+    }
+
+    protected function getForQuery(IQueryBuilder $builder, $type, $value) {
+        $query = $builder->select(['m.mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'm.type'])
+            ->from('external_mounts', 'm')
+            ->innerJoin('m', 'external_applicable', 'a', $builder->expr()->eq('m.mount_id', 'a.mount_id'))
+            ->where($builder->expr()->eq('a.type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)));
+
+        if (is_null($value)) {
+            $query = $query->andWhere($builder->expr()->isNull('a.value'));
+        } else {
+            $query = $query->andWhere($builder->expr()->eq('a.value', $builder->createNamedParameter($value)));
+        }
+
+        return $query;
+    }
+
+    /**
+     * Get mounts by applicable
+     *
+     * @param int $type any of the self::APPLICABLE_TYPE_ constants
+     * @param string|null $value user_id, group_id or null for global mounts
+     * @return array
+     */
+    public function getMountsFor($type, $value) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $this->getForQuery($builder, $type, $value);
+
+        return $this->getMountsFromQuery($query);
+    }
+
+    /**
+     * Get admin defined mounts by applicable
+     *
+     * @param int $type any of the self::APPLICABLE_TYPE_ constants
+     * @param string|null $value user_id, group_id or null for global mounts
+     * @return array
+     */
+    public function getAdminMountsFor($type, $value) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $this->getForQuery($builder, $type, $value);
+        $query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
+
+        return $this->getMountsFromQuery($query);
+    }
+
+    /**
+     * Get admin defined mounts for multiple applicable
+     *
+     * @param int $type any of the self::APPLICABLE_TYPE_ constants
+     * @param string[] $values user_ids or group_ids
+     * @return array
+     */
+    public function getAdminMountsForMultiple($type, array $values) {
+        $builder = $this->connection->getQueryBuilder();
+        $params = array_map(function ($value) use ($builder) {
+            return $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR);
+        }, $values);
+
+        $query = $builder->select(['m.mount_id', 'mount_point', 'storage_backend', 'auth_backend', 'priority', 'm.type'])
+            ->from('external_mounts', 'm')
+            ->innerJoin('m', 'external_applicable', 'a', $builder->expr()->eq('m.mount_id', 'a.mount_id'))
+            ->where($builder->expr()->eq('a.type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)))
+            ->andWhere($builder->expr()->in('a.value', $params));
+        $query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_ADMIN, IQueryBuilder::PARAM_INT)));
+
+        return $this->getMountsFromQuery($query);
+    }
+
+    /**
+     * Get user defined mounts by applicable
+     *
+     * @param int $type any of the self::APPLICABLE_TYPE_ constants
+     * @param string|null $value user_id, group_id or null for global mounts
+     * @return array
+     */
+    public function getUserMountsFor($type, $value) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $this->getForQuery($builder, $type, $value);
+        $query->andWhere($builder->expr()->eq('m.type', $builder->expr()->literal(self::MOUNT_TYPE_PERSONAl, IQueryBuilder::PARAM_INT)));
+
+        return $this->getMountsFromQuery($query);
+    }
+
+    /**
+     * Add a mount to the database
+     *
+     * @param string $mountPoint
+     * @param string $storageBackend
+     * @param string $authBackend
+     * @param int $priority
+     * @param int $type self::MOUNT_TYPE_ADMIN or self::MOUNT_TYPE_PERSONAL
+     * @return int the id of the new mount
+     */
+    public function addMount($mountPoint, $storageBackend, $authBackend, $priority, $type) {
+        if (!$priority) {
+            $priority = 100;
+        }
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->insert('external_mounts')
+            ->values([
+                'mount_point' => $builder->createNamedParameter($mountPoint, IQueryBuilder::PARAM_STR),
+                'storage_backend' => $builder->createNamedParameter($storageBackend, IQueryBuilder::PARAM_STR),
+                'auth_backend' => $builder->createNamedParameter($authBackend, IQueryBuilder::PARAM_STR),
+                'priority' => $builder->createNamedParameter($priority, IQueryBuilder::PARAM_INT),
+                'type' => $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)
+            ]);
+        $query->execute();
+        return (int)$this->connection->lastInsertId('*PREFIX*external_mounts');
+    }
+
+    /**
+     * Remove a mount from the database
+     *
+     * @param int $mountId
+     */
+    public function removeMount($mountId) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->delete('external_mounts')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+
+        $query = $builder->delete('external_applicable')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+
+        $query = $builder->delete('external_config')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+
+        $query = $builder->delete('external_options')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+        $query->execute();
+    }
+
+    /**
+     * @param int $mountId
+     * @param string $newMountPoint
+     */
+    public function setMountPoint($mountId, $newMountPoint) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('external_mounts')
+            ->set('mount_point', $builder->createNamedParameter($newMountPoint))
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+
+        $query->execute();
+    }
+
+    /**
+     * @param int $mountId
+     * @param string $newAuthBackend
+     */
+    public function setAuthBackend($mountId, $newAuthBackend) {
+        $builder = $this->connection->getQueryBuilder();
+
+        $query = $builder->update('external_mounts')
+            ->set('auth_backend', $builder->createNamedParameter($newAuthBackend))
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)));
+
+        $query->execute();
+    }
+
+    /**
+     * @param int $mountId
+     * @param string $key
+     * @param string $value
+     */
+    public function setConfig($mountId, $key, $value) {
+        if ($key === 'password') {
+            $value = $this->encryptValue($value);
+        }
+        $count = $this->connection->insertIfNotExist('*PREFIX*external_config', [
+            'mount_id' => $mountId,
+            'key' => $key,
+            'value' => $value
+        ], ['mount_id', 'key']);
+        if ($count === 0) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->update('external_config')
+                ->set('value', $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR))
+                ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
+                ->andWhere($builder->expr()->eq('key', $builder->createNamedParameter($key, IQueryBuilder::PARAM_STR)));
+            $query->execute();
+        }
+    }
+
+    /**
+     * @param int $mountId
+     * @param string $key
+     * @param string $value
+     */
+    public function setOption($mountId, $key, $value) {
+
+        $count = $this->connection->insertIfNotExist('*PREFIX*external_options', [
+            'mount_id' => $mountId,
+            'key' => $key,
+            'value' => json_encode($value)
+        ], ['mount_id', 'key']);
+        if ($count === 0) {
+            $builder = $this->connection->getQueryBuilder();
+            $query = $builder->update('external_options')
+                ->set('value', $builder->createNamedParameter(json_encode($value), IQueryBuilder::PARAM_STR))
+                ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
+                ->andWhere($builder->expr()->eq('key', $builder->createNamedParameter($key, IQueryBuilder::PARAM_STR)));
+            $query->execute();
+        }
+    }
+
+    public function addApplicable($mountId, $type, $value) {
+        $this->connection->insertIfNotExist('*PREFIX*external_applicable', [
+            'mount_id' => $mountId,
+            'type' => $type,
+            'value' => $value
+        ], ['mount_id', 'type', 'value']);
+    }
+
+    public function removeApplicable($mountId, $type, $value) {
+        $builder = $this->connection->getQueryBuilder();
+        $query = $builder->delete('external_applicable')
+            ->where($builder->expr()->eq('mount_id', $builder->createNamedParameter($mountId, IQueryBuilder::PARAM_INT)))
+            ->andWhere($builder->expr()->eq('type', $builder->createNamedParameter($type, IQueryBuilder::PARAM_INT)));
+
+        if (is_null($value)) {
+            $query = $query->andWhere($builder->expr()->isNull('value'));
+        } else {
+            $query = $query->andWhere($builder->expr()->eq('value', $builder->createNamedParameter($value, IQueryBuilder::PARAM_STR)));
+        }
+
+        $query->execute();
+    }
+
+    private function getMountsFromQuery(IQueryBuilder $query) {
+        $result = $query->execute();
+        $mounts = $result->fetchAll();
+        $uniqueMounts = [];
+        foreach ($mounts as $mount) {
+            $id = $mount['mount_id'];
+            if (!isset($uniqueMounts[$id])) {
+                $uniqueMounts[$id] = $mount;
+            }
+        }
+        $uniqueMounts = array_values($uniqueMounts);
+
+        $mountIds = array_map(function ($mount) {
+            return $mount['mount_id'];
+        }, $uniqueMounts);
+        $mountIds = array_values(array_unique($mountIds));
+
+        $applicable = $this->getApplicableForMounts($mountIds);
+        $config = $this->getConfigForMounts($mountIds);
+        $options = $this->getOptionsForMounts($mountIds);
+
+        return array_map(function ($mount, $applicable, $config, $options) {
+            $mount['type'] = (int)$mount['type'];
+            $mount['priority'] = (int)$mount['priority'];
+            $mount['applicable'] = $applicable;
+            $mount['config'] = $config;
+            $mount['options'] = $options;
+            return $mount;
+        }, $uniqueMounts, $applicable, $config, $options);
+    }
+
+    /**
+     * Get mount options from a table grouped by mount id
+     *
+     * @param string $table
+     * @param string[] $fields
+     * @param int[] $mountIds
+     * @return array [$mountId => [['field1' => $value1, ...], ...], ...]
+     */
+    private function selectForMounts($table, array $fields, array $mountIds) {
+        if (count($mountIds) === 0) {
+            return [];
+        }
+        $builder = $this->connection->getQueryBuilder();
+        $fields[] = 'mount_id';
+        $placeHolders = array_map(function ($id) use ($builder) {
+            return $builder->createPositionalParameter($id, IQueryBuilder::PARAM_INT);
+        }, $mountIds);
+        $query = $builder->select($fields)
+            ->from($table)
+            ->where($builder->expr()->in('mount_id', $placeHolders));
+        $rows = $query->execute()->fetchAll();
+
+        $result = [];
+        foreach ($mountIds as $mountId) {
+            $result[$mountId] = [];
+        }
+        foreach ($rows as $row) {
+            if (isset($row['type'])) {
+                $row['type'] = (int)$row['type'];
+            }
+            $result[$row['mount_id']][] = $row;
+        }
+        return $result;
+    }
+
+    /**
+     * @param int[] $mountIds
+     * @return array [$id => [['type' => $type, 'value' => $value], ...], ...]
+     */
+    public function getApplicableForMounts($mountIds) {
+        return $this->selectForMounts('external_applicable', ['type', 'value'], $mountIds);
+    }
+
+    /**
+     * @param int[] $mountIds
+     * @return array [$id => ['key1' => $value1, ...], ...]
+     */
+    public function getConfigForMounts($mountIds) {
+        $mountConfigs = $this->selectForMounts('external_config', ['key', 'value'], $mountIds);
+        return array_map([$this, 'createKeyValueMap'], $mountConfigs);
+    }
+
+    /**
+     * @param int[] $mountIds
+     * @return array [$id => ['key1' => $value1, ...], ...]
+     */
+    public function getOptionsForMounts($mountIds) {
+        $mountOptions = $this->selectForMounts('external_options', ['key', 'value'], $mountIds);
+        $optionsMap = array_map([$this, 'createKeyValueMap'], $mountOptions);
+        return array_map(function (array $options) {
+            return array_map(function ($option) {
+                return json_decode($option);
+            }, $options);
+        }, $optionsMap);
+    }
+
+    /**
+     * @param array $keyValuePairs [['key'=>$key, 'value=>$value], ...]
+     * @return array ['key1' => $value1, ...]
+     */
+    private function createKeyValueMap(array $keyValuePairs) {
+        $decryptedPairts = array_map(function ($pair) {
+            if ($pair['key'] === 'password') {
+                $pair['value'] = $this->decryptValue($pair['value']);
+            }
+            return $pair;
+        }, $keyValuePairs);
+        $keys = array_map(function ($pair) {
+            return $pair['key'];
+        }, $decryptedPairts);
+        $values = array_map(function ($pair) {
+            return $pair['value'];
+        }, $decryptedPairts);
+
+        return array_combine($keys, $values);
+    }
+
+    private function encryptValue($value) {
+        return $this->crypto->encrypt($value);
+    }
+
+    private function decryptValue($value) {
+        try {
+            return $this->crypto->decrypt($value);
+        } catch (\Exception $e) {
+            return $value;
+        }
+    }
 }

apps/files_external/lib/Service/LegacyStoragesService.php

Indentation +175 added lines, -175 removed lines

@@ -30,183 +30,183 @@
  * Read mount config from legacy mount.json
  */
 abstract class LegacyStoragesService {
-	/** @var BackendService */
-	protected $backendService;
+    /** @var BackendService */
+    protected $backendService;
 
-	/**
-	 * Read legacy config data
-	 *
-	 * @return array list of mount configs
-	 */
-	abstract protected function readLegacyConfig();
+    /**
+     * Read legacy config data
+     *
+     * @return array list of mount configs
+     */
+    abstract protected function readLegacyConfig();
 
-	/**
-	 * Copy legacy storage options into the given storage config object.
-	 *
-	 * @param StorageConfig $storageConfig storage config to populate
-	 * @param string $mountType mount type
-	 * @param string $applicable applicable user or group
-	 * @param array $storageOptions legacy storage options
-	 *
-	 * @return StorageConfig populated storage config
-	 */
-	protected function populateStorageConfigWithLegacyOptions(
-		&$storageConfig,
-		$mountType,
-		$applicable,
-		$storageOptions
-	) {
-		$backend = $this->backendService->getBackend($storageOptions['backend']);
-		if (!$backend) {
-			throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
-		}
-		$storageConfig->setBackend($backend);
-		if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
-			$authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
-		} else {
-			$authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
-			$storageOptions['authMechanism'] = 'null'; // to make error handling easier
-		}
-		if (!$authMechanism) {
-			throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
-		}
-		$storageConfig->setAuthMechanism($authMechanism);
-		$storageConfig->setBackendOptions($storageOptions['options']);
-		if (isset($storageOptions['mountOptions'])) {
-			$storageConfig->setMountOptions($storageOptions['mountOptions']);
-		}
-		if (!isset($storageOptions['priority'])) {
-			$storageOptions['priority'] = $backend->getPriority();
-		}
-		$storageConfig->setPriority($storageOptions['priority']);
-		if ($mountType === \OC_Mount_Config::MOUNT_TYPE_USER) {
-			$applicableUsers = $storageConfig->getApplicableUsers();
-			if ($applicable !== 'all') {
-				$applicableUsers[] = $applicable;
-				$storageConfig->setApplicableUsers($applicableUsers);
-			}
-		} else if ($mountType === \OC_Mount_Config::MOUNT_TYPE_GROUP) {
-			$applicableGroups = $storageConfig->getApplicableGroups();
-			$applicableGroups[] = $applicable;
-			$storageConfig->setApplicableGroups($applicableGroups);
-		}
-		return $storageConfig;
-	}
+    /**
+     * Copy legacy storage options into the given storage config object.
+     *
+     * @param StorageConfig $storageConfig storage config to populate
+     * @param string $mountType mount type
+     * @param string $applicable applicable user or group
+     * @param array $storageOptions legacy storage options
+     *
+     * @return StorageConfig populated storage config
+     */
+    protected function populateStorageConfigWithLegacyOptions(
+        &$storageConfig,
+        $mountType,
+        $applicable,
+        $storageOptions
+    ) {
+        $backend = $this->backendService->getBackend($storageOptions['backend']);
+        if (!$backend) {
+            throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
+        }
+        $storageConfig->setBackend($backend);
+        if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
+            $authMechanism = $this->backendService->getAuthMechanism($storageOptions['authMechanism']);
+        } else {
+            $authMechanism = $backend->getLegacyAuthMechanism($storageOptions);
+            $storageOptions['authMechanism'] = 'null'; // to make error handling easier
+        }
+        if (!$authMechanism) {
+            throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
+        }
+        $storageConfig->setAuthMechanism($authMechanism);
+        $storageConfig->setBackendOptions($storageOptions['options']);
+        if (isset($storageOptions['mountOptions'])) {
+            $storageConfig->setMountOptions($storageOptions['mountOptions']);
+        }
+        if (!isset($storageOptions['priority'])) {
+            $storageOptions['priority'] = $backend->getPriority();
+        }
+        $storageConfig->setPriority($storageOptions['priority']);
+        if ($mountType === \OC_Mount_Config::MOUNT_TYPE_USER) {
+            $applicableUsers = $storageConfig->getApplicableUsers();
+            if ($applicable !== 'all') {
+                $applicableUsers[] = $applicable;
+                $storageConfig->setApplicableUsers($applicableUsers);
+            }
+        } else if ($mountType === \OC_Mount_Config::MOUNT_TYPE_GROUP) {
+            $applicableGroups = $storageConfig->getApplicableGroups();
+            $applicableGroups[] = $applicable;
+            $storageConfig->setApplicableGroups($applicableGroups);
+        }
+        return $storageConfig;
+    }
 
-	/**
-	 * Read the external storages config
-	 *
-	 * @return StorageConfig[] map of storage id to storage config
-	 */
-	public function getAllStorages() {
-		$mountPoints = $this->readLegacyConfig();
-		/**
-		 * Here is the how the horribly messy mount point array looks like
-		 * from the mount.json file:
-		 *
-		 * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
-		 *
-		 * - $mountType is either "user" or "group"
-		 * - $applicable is the name of a user or group (or the current user for personal mounts)
-		 * - $mountPath is the mount point path (where the storage must be mounted)
-		 * - $storageOptions is a map of storage options:
-		 *     - "priority": storage priority
-		 *     - "backend": backend identifier
-		 *     - "class": LEGACY backend class name
-		 *     - "options": backend-specific options
-		 *     - "authMechanism": authentication mechanism identifier
-		 *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
-		 */
-		// group by storage id
-		/** @var StorageConfig[] $storages */
-		$storages = [];
-		// for storages without id (legacy), group by config hash for
-		// later processing
-		$storagesWithConfigHash = [];
-		foreach ($mountPoints as $mountType => $applicables) {
-			foreach ($applicables as $applicable => $mountPaths) {
-				foreach ($mountPaths as $rootMountPath => $storageOptions) {
-					$currentStorage = null;
-					/**
-					 * Flag whether the config that was read already has an id.
-					 * If not, it will use a config hash instead and generate
-					 * a proper id later
-					 *
-					 * @var boolean
-					 */
-					$hasId = false;
-					// the root mount point is in the format "/$user/files/the/mount/point"
-					// we remove the "/$user/files" prefix
-					$parts = explode('/', ltrim($rootMountPath, '/'), 3);
-					if (count($parts) < 3) {
-						// something went wrong, skip
-						\OCP\Util::writeLog(
-							'files_external',
-							'Could not parse mount point "' . $rootMountPath . '"',
-							\OCP\Util::ERROR
-						);
-						continue;
-					}
-					$relativeMountPath = rtrim($parts[2], '/');
-					// note: we cannot do this after the loop because the decrypted config
-					// options might be needed for the config hash
-					$storageOptions['options'] = \OC_Mount_Config::decryptPasswords($storageOptions['options']);
-					if (!isset($storageOptions['backend'])) {
-						$storageOptions['backend'] = $storageOptions['class']; // legacy compat
-					}
-					if (!isset($storageOptions['authMechanism'])) {
-						$storageOptions['authMechanism'] = null; // ensure config hash works
-					}
-					if (isset($storageOptions['id'])) {
-						$configId = (int)$storageOptions['id'];
-						if (isset($storages[$configId])) {
-							$currentStorage = $storages[$configId];
-						}
-						$hasId = true;
-					} else {
-						// missing id in legacy config, need to generate
-						// but at this point we don't know the max-id, so use
-						// first group it by config hash
-						$storageOptions['mountpoint'] = $rootMountPath;
-						$configId = \OC_Mount_Config::makeConfigHash($storageOptions);
-						if (isset($storagesWithConfigHash[$configId])) {
-							$currentStorage = $storagesWithConfigHash[$configId];
-						}
-					}
-					if (is_null($currentStorage)) {
-						// create new
-						$currentStorage = new StorageConfig($configId);
-						$currentStorage->setMountPoint($relativeMountPath);
-					}
-					try {
-						$this->populateStorageConfigWithLegacyOptions(
-							$currentStorage,
-							$mountType,
-							$applicable,
-							$storageOptions
-						);
-						if ($hasId) {
-							$storages[$configId] = $currentStorage;
-						} else {
-							$storagesWithConfigHash[$configId] = $currentStorage;
-						}
-					} catch (\UnexpectedValueException $e) {
-						// don't die if a storage backend doesn't exist
-						\OCP\Util::writeLog(
-							'files_external',
-							'Could not load storage: "' . $e->getMessage() . '"',
-							\OCP\Util::ERROR
-						);
-					}
-				}
-			}
-		}
+    /**
+     * Read the external storages config
+     *
+     * @return StorageConfig[] map of storage id to storage config
+     */
+    public function getAllStorages() {
+        $mountPoints = $this->readLegacyConfig();
+        /**
+         * Here is the how the horribly messy mount point array looks like
+         * from the mount.json file:
+         *
+         * $storageOptions = $mountPoints[$mountType][$applicable][$mountPath]
+         *
+         * - $mountType is either "user" or "group"
+         * - $applicable is the name of a user or group (or the current user for personal mounts)
+         * - $mountPath is the mount point path (where the storage must be mounted)
+         * - $storageOptions is a map of storage options:
+         *     - "priority": storage priority
+         *     - "backend": backend identifier
+         *     - "class": LEGACY backend class name
+         *     - "options": backend-specific options
+         *     - "authMechanism": authentication mechanism identifier
+         *     - "mountOptions": mount-specific options (ex: disable previews, scanner, etc)
+         */
+        // group by storage id
+        /** @var StorageConfig[] $storages */
+        $storages = [];
+        // for storages without id (legacy), group by config hash for
+        // later processing
+        $storagesWithConfigHash = [];
+        foreach ($mountPoints as $mountType => $applicables) {
+            foreach ($applicables as $applicable => $mountPaths) {
+                foreach ($mountPaths as $rootMountPath => $storageOptions) {
+                    $currentStorage = null;
+                    /**
+                     * Flag whether the config that was read already has an id.
+                     * If not, it will use a config hash instead and generate
+                     * a proper id later
+                     *
+                     * @var boolean
+                     */
+                    $hasId = false;
+                    // the root mount point is in the format "/$user/files/the/mount/point"
+                    // we remove the "/$user/files" prefix
+                    $parts = explode('/', ltrim($rootMountPath, '/'), 3);
+                    if (count($parts) < 3) {
+                        // something went wrong, skip
+                        \OCP\Util::writeLog(
+                            'files_external',
+                            'Could not parse mount point "' . $rootMountPath . '"',
+                            \OCP\Util::ERROR
+                        );
+                        continue;
+                    }
+                    $relativeMountPath = rtrim($parts[2], '/');
+                    // note: we cannot do this after the loop because the decrypted config
+                    // options might be needed for the config hash
+                    $storageOptions['options'] = \OC_Mount_Config::decryptPasswords($storageOptions['options']);
+                    if (!isset($storageOptions['backend'])) {
+                        $storageOptions['backend'] = $storageOptions['class']; // legacy compat
+                    }
+                    if (!isset($storageOptions['authMechanism'])) {
+                        $storageOptions['authMechanism'] = null; // ensure config hash works
+                    }
+                    if (isset($storageOptions['id'])) {
+                        $configId = (int)$storageOptions['id'];
+                        if (isset($storages[$configId])) {
+                            $currentStorage = $storages[$configId];
+                        }
+                        $hasId = true;
+                    } else {
+                        // missing id in legacy config, need to generate
+                        // but at this point we don't know the max-id, so use
+                        // first group it by config hash
+                        $storageOptions['mountpoint'] = $rootMountPath;
+                        $configId = \OC_Mount_Config::makeConfigHash($storageOptions);
+                        if (isset($storagesWithConfigHash[$configId])) {
+                            $currentStorage = $storagesWithConfigHash[$configId];
+                        }
+                    }
+                    if (is_null($currentStorage)) {
+                        // create new
+                        $currentStorage = new StorageConfig($configId);
+                        $currentStorage->setMountPoint($relativeMountPath);
+                    }
+                    try {
+                        $this->populateStorageConfigWithLegacyOptions(
+                            $currentStorage,
+                            $mountType,
+                            $applicable,
+                            $storageOptions
+                        );
+                        if ($hasId) {
+                            $storages[$configId] = $currentStorage;
+                        } else {
+                            $storagesWithConfigHash[$configId] = $currentStorage;
+                        }
+                    } catch (\UnexpectedValueException $e) {
+                        // don't die if a storage backend doesn't exist
+                        \OCP\Util::writeLog(
+                            'files_external',
+                            'Could not load storage: "' . $e->getMessage() . '"',
+                            \OCP\Util::ERROR
+                        );
+                    }
+                }
+            }
+        }
 
-		// convert parameter values
-		foreach ($storages as $storage) {
-			$storage->getBackend()->validateStorageDefinition($storage);
-			$storage->getAuthMechanism()->validateStorageDefinition($storage);
-		}
-		return $storages;
-	}
+        // convert parameter values
+        foreach ($storages as $storage) {
+            $storage->getBackend()->validateStorageDefinition($storage);
+            $storage->getAuthMechanism()->validateStorageDefinition($storage);
+        }
+        return $storages;
+    }
 }

Spacing +5 added lines, -5 removed lines

@@ -58,7 +58,7 @@ 
 	) {
 		$backend = $this->backendService->getBackend($storageOptions['backend']);
 		if (!$backend) {
-			throw new \UnexpectedValueException('Invalid backend ' . $storageOptions['backend']);
+			throw new \UnexpectedValueException('Invalid backend '.$storageOptions['backend']);
 		}
 		$storageConfig->setBackend($backend);
 		if (isset($storageOptions['authMechanism']) && $storageOptions['authMechanism'] !== 'builtin::builtin') {
@@ -68,7 +68,7 @@ 
 			$storageOptions['authMechanism'] = 'null'; // to make error handling easier
 		}
 		if (!$authMechanism) {
-			throw new \UnexpectedValueException('Invalid authentication mechanism ' . $storageOptions['authMechanism']);
+			throw new \UnexpectedValueException('Invalid authentication mechanism '.$storageOptions['authMechanism']);
 		}
 		$storageConfig->setAuthMechanism($authMechanism);
 		$storageConfig->setBackendOptions($storageOptions['options']);
@@ -142,7 +142,7 @@ 
 						// something went wrong, skip
 						\OCP\Util::writeLog(
 							'files_external',
-							'Could not parse mount point "' . $rootMountPath . '"',
+							'Could not parse mount point "'.$rootMountPath.'"',
 							\OCP\Util::ERROR
 						);
 						continue;
@@ -158,7 +158,7 @@ 
 						$storageOptions['authMechanism'] = null; // ensure config hash works
 					}
 					if (isset($storageOptions['id'])) {
-						$configId = (int)$storageOptions['id'];
+						$configId = (int) $storageOptions['id'];
 						if (isset($storages[$configId])) {
 							$currentStorage = $storages[$configId];
 						}
@@ -194,7 +194,7 @@ 
 						// don't die if a storage backend doesn't exist
 						\OCP\Util::writeLog(
 							'files_external',
-							'Could not load storage: "' . $e->getMessage() . '"',
+							'Could not load storage: "'.$e->getMessage().'"',
 							\OCP\Util::ERROR
 						);
 					}