nextcloud / server

apps/files_external/lib/Controller/GlobalStoragesController.php

Indentation +145 added lines, -145 removed lines

@@ -39,151 +39,151 @@
  * Global storages controller
  */
 class GlobalStoragesController extends StoragesController {
-	/**
-	 * Creates a new global storages controller.
-	 *
-	 * @param string $AppName application name
-	 * @param IRequest $request request object
-	 * @param IL10N $l10n l10n service
-	 * @param GlobalStoragesService $globalStoragesService storage service
-	 * @param ILogger $logger
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		GlobalStoragesService $globalStoragesService,
-		ILogger $logger
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$globalStoragesService,
-			$logger
-		);
-	}
-
-	/**
-	 * Create an external storage entry.
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backend backend identifier
-	 * @param string $authMechanism authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array $mountOptions mount-specific options
-	 * @param array $applicableUsers users for which to mount the storage
-	 * @param array $applicableGroups groups for which to mount the storage
-	 * @param int $priority priority
-	 *
-	 * @return DataResponse
-	 */
-	public function create(
-		$mountPoint,
-		$backend,
-		$authMechanism,
-		$backendOptions,
-		$mountOptions,
-		$applicableUsers,
-		$applicableGroups,
-		$priority
-	) {
-		$newStorage = $this->createStorage(
-			$mountPoint,
-			$backend,
-			$authMechanism,
-			$backendOptions,
-			$mountOptions,
-			$applicableUsers,
-			$applicableGroups,
-			$priority
-		);
-		if ($newStorage instanceof DataResponse) {
-			return $newStorage;
-		}
-
-		$response = $this->validate($newStorage);
-		if (!empty($response)) {
-			return $response;
-		}
-
-		$newStorage = $this->service->addStorage($newStorage);
-
-		$this->updateStorageStatus($newStorage);
-
-		return new DataResponse(
-			$newStorage,
-			Http::STATUS_CREATED
-		);
-	}
-
-	/**
-	 * Update an external storage entry.
-	 *
-	 * @param int $id storage id
-	 * @param string $mountPoint storage mount point
-	 * @param string $backend backend identifier
-	 * @param string $authMechanism authentication mechansim identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array $mountOptions mount-specific options
-	 * @param array $applicableUsers users for which to mount the storage
-	 * @param array $applicableGroups groups for which to mount the storage
-	 * @param int $priority priority
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 *
-	 * @return DataResponse
-	 */
-	public function update(
-		$id,
-		$mountPoint,
-		$backend,
-		$authMechanism,
-		$backendOptions,
-		$mountOptions,
-		$applicableUsers,
-		$applicableGroups,
-		$priority,
-		$testOnly = true
-	) {
-		$storage = $this->createStorage(
-			$mountPoint,
-			$backend,
-			$authMechanism,
-			$backendOptions,
-			$mountOptions,
-			$applicableUsers,
-			$applicableGroups,
-			$priority
-		);
-		if ($storage instanceof DataResponse) {
-			return $storage;
-		}
-		$storage->setId($id);
-
-		$response = $this->validate($storage);
-		if (!empty($response)) {
-			return $response;
-		}
-
-		try {
-			$storage = $this->service->updateStorage($storage);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage, $testOnly);
-
-		return new DataResponse(
-			$storage,
-			Http::STATUS_OK
-		);
-
-	}
+    /**
+     * Creates a new global storages controller.
+     *
+     * @param string $AppName application name
+     * @param IRequest $request request object
+     * @param IL10N $l10n l10n service
+     * @param GlobalStoragesService $globalStoragesService storage service
+     * @param ILogger $logger
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        GlobalStoragesService $globalStoragesService,
+        ILogger $logger
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $globalStoragesService,
+            $logger
+        );
+    }
+
+    /**
+     * Create an external storage entry.
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backend backend identifier
+     * @param string $authMechanism authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array $mountOptions mount-specific options
+     * @param array $applicableUsers users for which to mount the storage
+     * @param array $applicableGroups groups for which to mount the storage
+     * @param int $priority priority
+     *
+     * @return DataResponse
+     */
+    public function create(
+        $mountPoint,
+        $backend,
+        $authMechanism,
+        $backendOptions,
+        $mountOptions,
+        $applicableUsers,
+        $applicableGroups,
+        $priority
+    ) {
+        $newStorage = $this->createStorage(
+            $mountPoint,
+            $backend,
+            $authMechanism,
+            $backendOptions,
+            $mountOptions,
+            $applicableUsers,
+            $applicableGroups,
+            $priority
+        );
+        if ($newStorage instanceof DataResponse) {
+            return $newStorage;
+        }
+
+        $response = $this->validate($newStorage);
+        if (!empty($response)) {
+            return $response;
+        }
+
+        $newStorage = $this->service->addStorage($newStorage);
+
+        $this->updateStorageStatus($newStorage);
+
+        return new DataResponse(
+            $newStorage,
+            Http::STATUS_CREATED
+        );
+    }
+
+    /**
+     * Update an external storage entry.
+     *
+     * @param int $id storage id
+     * @param string $mountPoint storage mount point
+     * @param string $backend backend identifier
+     * @param string $authMechanism authentication mechansim identifier
+     * @param array $backendOptions backend-specific options
+     * @param array $mountOptions mount-specific options
+     * @param array $applicableUsers users for which to mount the storage
+     * @param array $applicableGroups groups for which to mount the storage
+     * @param int $priority priority
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     *
+     * @return DataResponse
+     */
+    public function update(
+        $id,
+        $mountPoint,
+        $backend,
+        $authMechanism,
+        $backendOptions,
+        $mountOptions,
+        $applicableUsers,
+        $applicableGroups,
+        $priority,
+        $testOnly = true
+    ) {
+        $storage = $this->createStorage(
+            $mountPoint,
+            $backend,
+            $authMechanism,
+            $backendOptions,
+            $mountOptions,
+            $applicableUsers,
+            $applicableGroups,
+            $priority
+        );
+        if ($storage instanceof DataResponse) {
+            return $storage;
+        }
+        $storage->setId($id);
+
+        $response = $this->validate($storage);
+        if (!empty($response)) {
+            return $response;
+        }
+
+        try {
+            $storage = $this->service->updateStorage($storage);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage, $testOnly);
+
+        return new DataResponse(
+            $storage,
+            Http::STATUS_OK
+        );
+
+    }
 
 
 }

apps/files_external/lib/Controller/UserGlobalStoragesController.php

Indentation +160 added lines, -160 removed lines

@@ -43,165 +43,165 @@
  * User global storages controller
  */
 class UserGlobalStoragesController extends StoragesController {
-	/**
-	 * @var IUserSession
-	 */
-	private $userSession;
-
-	/**
-	 * Creates a new user global storages controller.
-	 *
-	 * @param string $AppName application name
-	 * @param IRequest $request request object
-	 * @param IL10N $l10n l10n service
-	 * @param UserGlobalStoragesService $userGlobalStoragesService storage service
-	 * @param IUserSession $userSession
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		IUserSession $userSession,
-		ILogger $logger
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$userGlobalStoragesService,
-			$logger
-		);
-		$this->userSession = $userSession;
-	}
-
-	/**
-	 * Get all storage entries
-	 *
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function index() {
-		$storages = $this->service->getUniqueStorages();
-
-		// remove configuration data, this must be kept private
-		foreach ($storages as $storage) {
-			$this->sanitizeStorage($storage);
-		}
-
-		return new DataResponse(
-			$storages,
-			Http::STATUS_OK
-		);
-	}
-
-	protected function manipulateStorageConfig(StorageConfig $storage) {
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		$authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		$backend->manipulateStorageConfig($storage, $this->userSession->getUser());
-	}
-
-	/**
-	 * Get an external storage entry.
-	 *
-	 * @param int $id storage id
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function show($id, $testOnly = true) {
-		try {
-			$storage = $this->service->getStorage($id);
-
-			$this->updateStorageStatus($storage, $testOnly);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->sanitizeStorage($storage);
-
-		return new DataResponse(
-			$storage,
-			Http::STATUS_OK
-		);
-	}
-
-	/**
-	 * Update an external storage entry.
-	 * Only allows setting user provided backend fields
-	 *
-	 * @param int $id storage id
-	 * @param array $backendOptions backend-specific options
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 *
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function update(
-		$id,
-		$backendOptions,
-		$testOnly = true
-	) {
-		try {
-			$storage = $this->service->getStorage($id);
-			$authMechanism = $storage->getAuthMechanism();
-			if ($authMechanism instanceof IUserProvided) {
-				$authMechanism->saveBackendOptions($this->userSession->getUser(), $id, $backendOptions);
-				$authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
-			} else {
-				return new DataResponse(
-					[
-						'message' => (string)$this->l10n->t('Storage with id "%i" is not user editable', array($id))
-					],
-					Http::STATUS_FORBIDDEN
-				);
-			}
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage, $testOnly);
-		$this->sanitizeStorage($storage);
-
-		return new DataResponse(
-			$storage,
-			Http::STATUS_OK
-		);
-
-	}
-
-	/**
-	 * Remove sensitive data from a StorageConfig before returning it to the user
-	 *
-	 * @param StorageConfig $storage
-	 */
-	protected function sanitizeStorage(StorageConfig $storage) {
-		$storage->setBackendOptions([]);
-		$storage->setMountOptions([]);
-
-		if ($storage->getAuthMechanism() instanceof IUserProvided) {
-			try {
-				$storage->getAuthMechanism()->manipulateStorageConfig($storage, $this->userSession->getUser());
-			} catch (InsufficientDataForMeaningfulAnswerException $e) {
-				// not configured yet
-			}
-		}
-	}
+    /**
+     * @var IUserSession
+     */
+    private $userSession;
+
+    /**
+     * Creates a new user global storages controller.
+     *
+     * @param string $AppName application name
+     * @param IRequest $request request object
+     * @param IL10N $l10n l10n service
+     * @param UserGlobalStoragesService $userGlobalStoragesService storage service
+     * @param IUserSession $userSession
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        IUserSession $userSession,
+        ILogger $logger
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $userGlobalStoragesService,
+            $logger
+        );
+        $this->userSession = $userSession;
+    }
+
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function index() {
+        $storages = $this->service->getUniqueStorages();
+
+        // remove configuration data, this must be kept private
+        foreach ($storages as $storage) {
+            $this->sanitizeStorage($storage);
+        }
+
+        return new DataResponse(
+            $storages,
+            Http::STATUS_OK
+        );
+    }
+
+    protected function manipulateStorageConfig(StorageConfig $storage) {
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        $authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        $backend->manipulateStorageConfig($storage, $this->userSession->getUser());
+    }
+
+    /**
+     * Get an external storage entry.
+     *
+     * @param int $id storage id
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function show($id, $testOnly = true) {
+        try {
+            $storage = $this->service->getStorage($id);
+
+            $this->updateStorageStatus($storage, $testOnly);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->sanitizeStorage($storage);
+
+        return new DataResponse(
+            $storage,
+            Http::STATUS_OK
+        );
+    }
+
+    /**
+     * Update an external storage entry.
+     * Only allows setting user provided backend fields
+     *
+     * @param int $id storage id
+     * @param array $backendOptions backend-specific options
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     *
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function update(
+        $id,
+        $backendOptions,
+        $testOnly = true
+    ) {
+        try {
+            $storage = $this->service->getStorage($id);
+            $authMechanism = $storage->getAuthMechanism();
+            if ($authMechanism instanceof IUserProvided) {
+                $authMechanism->saveBackendOptions($this->userSession->getUser(), $id, $backendOptions);
+                $authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
+            } else {
+                return new DataResponse(
+                    [
+                        'message' => (string)$this->l10n->t('Storage with id "%i" is not user editable', array($id))
+                    ],
+                    Http::STATUS_FORBIDDEN
+                );
+            }
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with id "%i" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage, $testOnly);
+        $this->sanitizeStorage($storage);
+
+        return new DataResponse(
+            $storage,
+            Http::STATUS_OK
+        );
+
+    }
+
+    /**
+     * Remove sensitive data from a StorageConfig before returning it to the user
+     *
+     * @param StorageConfig $storage
+     */
+    protected function sanitizeStorage(StorageConfig $storage) {
+        $storage->setBackendOptions([]);
+        $storage->setMountOptions([]);
+
+        if ($storage->getAuthMechanism() instanceof IUserProvided) {
+            try {
+                $storage->getAuthMechanism()->manipulateStorageConfig($storage, $this->userSession->getUser());
+            } catch (InsufficientDataForMeaningfulAnswerException $e) {
+                // not configured yet
+            }
+        }
+    }
 
 }

apps/files_external/lib/AppInfo/Application.php

Indentation +102 added lines, -102 removed lines

@@ -41,107 +41,107 @@
  */
 class Application extends App implements IBackendProvider, IAuthMechanismProvider {
 
-	public function __construct(array $urlParams = array()) {
-		parent::__construct('files_external', $urlParams);
-
-		$container = $this->getContainer();
-
-		$container->registerService('OCP\Files\Config\IUserMountCache', function (IAppContainer $c) {
-			return $c->getServer()->query('UserMountCache');
-		});
-
-		$backendService = $container->query('OCA\\Files_External\\Service\\BackendService');
-		$backendService->registerBackendProvider($this);
-		$backendService->registerAuthMechanismProvider($this);
-
-		// force-load auth mechanisms since some will register hooks
-		// TODO: obsolete these and use the TokenProvider to get the user's password from the session
-		$this->getAuthMechanisms();
-
-		// app developers: do NOT depend on this! it will disappear with oC 9.0!
-		\OC::$server->getEventDispatcher()->dispatch(
-			'OCA\\Files_External::loadAdditionalBackends'
-		);
-	}
-
-	/**
-	 * Register settings templates
-	 */
-	public function registerSettings() {
-		$container = $this->getContainer();
-		$userSession = $container->getServer()->getUserSession();
-		if (!$userSession->isLoggedIn()) {
-			return;
-		}
-		$backendService = $container->query('OCA\\Files_External\\Service\\BackendService');
-
-		/** @var \OCA\Files_External\Service\UserGlobalStoragesService $userGlobalStoragesService */
-		$userGlobalStoragesService = $container->query('OCA\Files_External\Service\UserGlobalStoragesService');
-		if (count($userGlobalStoragesService->getStorages()) > 0 || $backendService->isUserMountingAllowed()) {
-			\OCP\App::registerPersonal('files_external', 'personal');
-		}
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getBackends() {
-		$container = $this->getContainer();
-
-		$backends = [
-			$container->query('OCA\Files_External\Lib\Backend\Local'),
-			$container->query('OCA\Files_External\Lib\Backend\FTP'),
-			$container->query('OCA\Files_External\Lib\Backend\DAV'),
-			$container->query('OCA\Files_External\Lib\Backend\OwnCloud'),
-			$container->query('OCA\Files_External\Lib\Backend\SFTP'),
-			$container->query('OCA\Files_External\Lib\Backend\AmazonS3'),
-			$container->query('OCA\Files_External\Lib\Backend\Dropbox'),
-			$container->query('OCA\Files_External\Lib\Backend\Google'),
-			$container->query('OCA\Files_External\Lib\Backend\Swift'),
-			$container->query('OCA\Files_External\Lib\Backend\SFTP_Key'),
-			$container->query('OCA\Files_External\Lib\Backend\SMB'),
-			$container->query('OCA\Files_External\Lib\Backend\SMB_OC'),
-		];
-
-		return $backends;
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getAuthMechanisms() {
-		$container = $this->getContainer();
-
-		return [
-			// AuthMechanism::SCHEME_NULL mechanism
-			$container->query('OCA\Files_External\Lib\Auth\NullMechanism'),
-
-			// AuthMechanism::SCHEME_BUILTIN mechanism
-			$container->query('OCA\Files_External\Lib\Auth\Builtin'),
-
-			// AuthMechanism::SCHEME_PASSWORD mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\Password\Password'),
-			$container->query('OCA\Files_External\Lib\Auth\Password\SessionCredentials'),
-			$container->query('OCA\Files_External\Lib\Auth\Password\LoginCredentials'),
-			$container->query('OCA\Files_External\Lib\Auth\Password\UserProvided'),
-			$container->query('OCA\Files_External\Lib\Auth\Password\GlobalAuth'),
-
-			// AuthMechanism::SCHEME_OAUTH1 mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\OAuth1\OAuth1'),
-
-			// AuthMechanism::SCHEME_OAUTH2 mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\OAuth2\OAuth2'),
-
-			// AuthMechanism::SCHEME_PUBLICKEY mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\PublicKey\RSA'),
-
-			// AuthMechanism::SCHEME_OPENSTACK mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\OpenStack\OpenStack'),
-			$container->query('OCA\Files_External\Lib\Auth\OpenStack\Rackspace'),
-
-			// Specialized mechanisms
-			$container->query('OCA\Files_External\Lib\Auth\AmazonS3\AccessKey'),
-		];
-	}
+    public function __construct(array $urlParams = array()) {
+        parent::__construct('files_external', $urlParams);
+
+        $container = $this->getContainer();
+
+        $container->registerService('OCP\Files\Config\IUserMountCache', function (IAppContainer $c) {
+            return $c->getServer()->query('UserMountCache');
+        });
+
+        $backendService = $container->query('OCA\\Files_External\\Service\\BackendService');
+        $backendService->registerBackendProvider($this);
+        $backendService->registerAuthMechanismProvider($this);
+
+        // force-load auth mechanisms since some will register hooks
+        // TODO: obsolete these and use the TokenProvider to get the user's password from the session
+        $this->getAuthMechanisms();
+
+        // app developers: do NOT depend on this! it will disappear with oC 9.0!
+        \OC::$server->getEventDispatcher()->dispatch(
+            'OCA\\Files_External::loadAdditionalBackends'
+        );
+    }
+
+    /**
+     * Register settings templates
+     */
+    public function registerSettings() {
+        $container = $this->getContainer();
+        $userSession = $container->getServer()->getUserSession();
+        if (!$userSession->isLoggedIn()) {
+            return;
+        }
+        $backendService = $container->query('OCA\\Files_External\\Service\\BackendService');
+
+        /** @var \OCA\Files_External\Service\UserGlobalStoragesService $userGlobalStoragesService */
+        $userGlobalStoragesService = $container->query('OCA\Files_External\Service\UserGlobalStoragesService');
+        if (count($userGlobalStoragesService->getStorages()) > 0 || $backendService->isUserMountingAllowed()) {
+            \OCP\App::registerPersonal('files_external', 'personal');
+        }
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getBackends() {
+        $container = $this->getContainer();
+
+        $backends = [
+            $container->query('OCA\Files_External\Lib\Backend\Local'),
+            $container->query('OCA\Files_External\Lib\Backend\FTP'),
+            $container->query('OCA\Files_External\Lib\Backend\DAV'),
+            $container->query('OCA\Files_External\Lib\Backend\OwnCloud'),
+            $container->query('OCA\Files_External\Lib\Backend\SFTP'),
+            $container->query('OCA\Files_External\Lib\Backend\AmazonS3'),
+            $container->query('OCA\Files_External\Lib\Backend\Dropbox'),
+            $container->query('OCA\Files_External\Lib\Backend\Google'),
+            $container->query('OCA\Files_External\Lib\Backend\Swift'),
+            $container->query('OCA\Files_External\Lib\Backend\SFTP_Key'),
+            $container->query('OCA\Files_External\Lib\Backend\SMB'),
+            $container->query('OCA\Files_External\Lib\Backend\SMB_OC'),
+        ];
+
+        return $backends;
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getAuthMechanisms() {
+        $container = $this->getContainer();
+
+        return [
+            // AuthMechanism::SCHEME_NULL mechanism
+            $container->query('OCA\Files_External\Lib\Auth\NullMechanism'),
+
+            // AuthMechanism::SCHEME_BUILTIN mechanism
+            $container->query('OCA\Files_External\Lib\Auth\Builtin'),
+
+            // AuthMechanism::SCHEME_PASSWORD mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\Password\Password'),
+            $container->query('OCA\Files_External\Lib\Auth\Password\SessionCredentials'),
+            $container->query('OCA\Files_External\Lib\Auth\Password\LoginCredentials'),
+            $container->query('OCA\Files_External\Lib\Auth\Password\UserProvided'),
+            $container->query('OCA\Files_External\Lib\Auth\Password\GlobalAuth'),
+
+            // AuthMechanism::SCHEME_OAUTH1 mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\OAuth1\OAuth1'),
+
+            // AuthMechanism::SCHEME_OAUTH2 mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\OAuth2\OAuth2'),
+
+            // AuthMechanism::SCHEME_PUBLICKEY mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\PublicKey\RSA'),
+
+            // AuthMechanism::SCHEME_OPENSTACK mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\OpenStack\OpenStack'),
+            $container->query('OCA\Files_External\Lib\Auth\OpenStack\Rackspace'),
+
+            // Specialized mechanisms
+            $container->query('OCA\Files_External\Lib\Auth\AmazonS3\AccessKey'),
+        ];
+    }
 
 }

apps/files_external/lib/Config/ConfigAdapter.php

Indentation +139 added lines, -139 removed lines

@@ -45,143 +45,143 @@
  */
 class ConfigAdapter implements IMountProvider {
 
-	/** @var UserStoragesService */
-	private $userStoragesService;
-
-	/** @var UserGlobalStoragesService */
-	private $userGlobalStoragesService;
-	/** @var StorageMigrator  */
-	private $migrator;
-
-	/**
-	 * @param UserStoragesService $userStoragesService
-	 * @param UserGlobalStoragesService $userGlobalStoragesService
-	 * @param StorageMigrator $migrator
-	 */
-	public function __construct(
-		UserStoragesService $userStoragesService,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		StorageMigrator $migrator
-	) {
-		$this->userStoragesService = $userStoragesService;
-		$this->userGlobalStoragesService = $userGlobalStoragesService;
-		$this->migrator = $migrator;
-	}
-
-	/**
-	 * Process storage ready for mounting
-	 *
-	 * @param StorageConfig $storage
-	 * @param IUser $user
-	 */
-	private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
-		foreach ($storage->getBackendOptions() as $option => $value) {
-			$storage->setBackendOption($option, \OC_Mount_Config::setUserVars(
-				$user->getUID(), $value
-			));
-		}
-
-		$objectStore = $storage->getBackendOption('objectstore');
-		if ($objectStore) {
-			$objectClass = $objectStore['class'];
-			if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
-				throw new \InvalidArgumentException('Invalid object store');
-			}
-			$storage->setBackendOption('objectstore', new $objectClass($objectStore));
-		}
-
-		$storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
-		$storage->getBackend()->manipulateStorageConfig($storage, $user);
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return Storage
-	 */
-	private function constructStorage(StorageConfig $storageConfig) {
-		$class = $storageConfig->getBackend()->getStorageClass();
-		$storage = new $class($storageConfig->getBackendOptions());
-
-		// auth mechanism should fire first
-		$storage = $storageConfig->getBackend()->wrapStorage($storage);
-		$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-		return $storage;
-	}
-
-	/**
-	 * Get all mountpoints applicable for the user
-	 *
-	 * @param \OCP\IUser $user
-	 * @param \OCP\Files\Storage\IStorageFactory $loader
-	 * @return \OCP\Files\Mount\IMountPoint[]
-	 */
-	public function getMountsForUser(IUser $user, IStorageFactory $loader) {
-		$this->migrator->migrateUser($user);
-
-		$this->userStoragesService->setUser($user);
-		$this->userGlobalStoragesService->setUser($user);
-
-		$storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
-
-		$storages = array_map(function(StorageConfig $storageConfig) use ($user) {
-			try {
-				$this->prepareStorageConfig($storageConfig, $user);
-				return $this->constructStorage($storageConfig);
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				return new FailedStorage(['exception' => $e]);
-			}
-		}, $storageConfigs);
-
-
-		\OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function(Storage\IStorage $storage) {
-			return $storage->getId();
-		}, $storages));
-
-		$availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
-			try {
-				$availability = $storage->getAvailability();
-				if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
-					$storage = new FailedStorage([
-						'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
-					]);
-				}
-			} catch (\Exception $e) {
-				// propagate exception into filesystem
-				$storage = new FailedStorage(['exception' => $e]);
-			}
-			return $storage;
-		}, $storages, $storageConfigs);
-
-		$mounts = array_map(function(StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
-			if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
-				return new PersonalMount(
-					$this->userStoragesService,
-					$storageConfig->getId(),
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions()
-				);
-			} else {
-				return new MountPoint(
-					$storage,
-					'/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
-					null,
-					$loader,
-					$storageConfig->getMountOptions(),
-					$storageConfig->getId()
-				);
-			}
-		}, $storageConfigs, $availableStorages);
-
-		$this->userStoragesService->resetUser();
-		$this->userGlobalStoragesService->resetUser();
-
-		return $mounts;
-	}
+    /** @var UserStoragesService */
+    private $userStoragesService;
+
+    /** @var UserGlobalStoragesService */
+    private $userGlobalStoragesService;
+    /** @var StorageMigrator  */
+    private $migrator;
+
+    /**
+     * @param UserStoragesService $userStoragesService
+     * @param UserGlobalStoragesService $userGlobalStoragesService
+     * @param StorageMigrator $migrator
+     */
+    public function __construct(
+        UserStoragesService $userStoragesService,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        StorageMigrator $migrator
+    ) {
+        $this->userStoragesService = $userStoragesService;
+        $this->userGlobalStoragesService = $userGlobalStoragesService;
+        $this->migrator = $migrator;
+    }
+
+    /**
+     * Process storage ready for mounting
+     *
+     * @param StorageConfig $storage
+     * @param IUser $user
+     */
+    private function prepareStorageConfig(StorageConfig &$storage, IUser $user) {
+        foreach ($storage->getBackendOptions() as $option => $value) {
+            $storage->setBackendOption($option, \OC_Mount_Config::setUserVars(
+                $user->getUID(), $value
+            ));
+        }
+
+        $objectStore = $storage->getBackendOption('objectstore');
+        if ($objectStore) {
+            $objectClass = $objectStore['class'];
+            if (!is_subclass_of($objectClass, '\OCP\Files\ObjectStore\IObjectStore')) {
+                throw new \InvalidArgumentException('Invalid object store');
+            }
+            $storage->setBackendOption('objectstore', new $objectClass($objectStore));
+        }
+
+        $storage->getAuthMechanism()->manipulateStorageConfig($storage, $user);
+        $storage->getBackend()->manipulateStorageConfig($storage, $user);
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return Storage
+     */
+    private function constructStorage(StorageConfig $storageConfig) {
+        $class = $storageConfig->getBackend()->getStorageClass();
+        $storage = new $class($storageConfig->getBackendOptions());
+
+        // auth mechanism should fire first
+        $storage = $storageConfig->getBackend()->wrapStorage($storage);
+        $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+        return $storage;
+    }
+
+    /**
+     * Get all mountpoints applicable for the user
+     *
+     * @param \OCP\IUser $user
+     * @param \OCP\Files\Storage\IStorageFactory $loader
+     * @return \OCP\Files\Mount\IMountPoint[]
+     */
+    public function getMountsForUser(IUser $user, IStorageFactory $loader) {
+        $this->migrator->migrateUser($user);
+
+        $this->userStoragesService->setUser($user);
+        $this->userGlobalStoragesService->setUser($user);
+
+        $storageConfigs = $this->userGlobalStoragesService->getAllStoragesForUser();
+
+        $storages = array_map(function(StorageConfig $storageConfig) use ($user) {
+            try {
+                $this->prepareStorageConfig($storageConfig, $user);
+                return $this->constructStorage($storageConfig);
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                return new FailedStorage(['exception' => $e]);
+            }
+        }, $storageConfigs);
+
+
+        \OC\Files\Cache\Storage::getGlobalCache()->loadForStorageIds(array_map(function(Storage\IStorage $storage) {
+            return $storage->getId();
+        }, $storages));
+
+        $availableStorages = array_map(function (Storage\IStorage $storage, StorageConfig $storageConfig) {
+            try {
+                $availability = $storage->getAvailability();
+                if (!$availability['available'] && !Availability::shouldRecheck($availability)) {
+                    $storage = new FailedStorage([
+                        'exception' => new StorageNotAvailableException('Storage with mount id ' . $storageConfig->getId() . ' is not available')
+                    ]);
+                }
+            } catch (\Exception $e) {
+                // propagate exception into filesystem
+                $storage = new FailedStorage(['exception' => $e]);
+            }
+            return $storage;
+        }, $storages, $storageConfigs);
+
+        $mounts = array_map(function(StorageConfig $storageConfig, Storage\IStorage $storage) use ($user, $loader) {
+            if ($storageConfig->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
+                return new PersonalMount(
+                    $this->userStoragesService,
+                    $storageConfig->getId(),
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions()
+                );
+            } else {
+                return new MountPoint(
+                    $storage,
+                    '/' . $user->getUID() . '/files' . $storageConfig->getMountPoint(),
+                    null,
+                    $loader,
+                    $storageConfig->getMountOptions(),
+                    $storageConfig->getId()
+                );
+            }
+        }, $storageConfigs, $availableStorages);
+
+        $this->userStoragesService->resetUser();
+        $this->userGlobalStoragesService->resetUser();
+
+        return $mounts;
+    }
 }

apps/files_external/lib/config.php

Indentation +367 added lines, -367 removed lines

@@ -45,371 +45,371 @@
  * Class to configure mount.json globally and for users
  */
 class OC_Mount_Config {
-	// TODO: make this class non-static and give it a proper namespace
-
-	const MOUNT_TYPE_GLOBAL = 'global';
-	const MOUNT_TYPE_GROUP = 'group';
-	const MOUNT_TYPE_USER = 'user';
-	const MOUNT_TYPE_PERSONAL = 'personal';
-
-	// whether to skip backend test (for unit tests, as this static class is not mockable)
-	public static $skipTest = false;
-
-	/** @var Application */
-	public static $app;
-
-	/**
-	 * @param string $class
-	 * @param array $definition
-	 * @return bool
-	 * @deprecated 8.2.0 use \OCA\Files_External\Service\BackendService::registerBackend()
-	 */
-	public static function registerBackend($class, $definition) {
-		$backendService = self::$app->getContainer()->query('OCA\Files_External\Service\BackendService');
-		$auth = self::$app->getContainer()->query('OCA\Files_External\Lib\Auth\Builtin');
-
-		$backendService->registerBackend(new LegacyBackend($class, $definition, $auth));
-
-		return true;
-	}
-
-	/**
-	 * Returns the mount points for the given user.
-	 * The mount point is relative to the data directory.
-	 *
-	 * @param string $uid user
-	 * @return array of mount point string as key, mountpoint config as value
-	 *
-	 * @deprecated 8.2.0 use UserGlobalStoragesService::getStorages() and UserStoragesService::getStorages()
-	 */
-	public static function getAbsoluteMountPoints($uid) {
-		$mountPoints = array();
-
-		$userGlobalStoragesService = self::$app->getContainer()->query('OCA\Files_External\Service\UserGlobalStoragesService');
-		$userStoragesService = self::$app->getContainer()->query('OCA\Files_External\Service\UserStoragesService');
-		$user = self::$app->getContainer()->query('OCP\IUserManager')->get($uid);
-
-		$userGlobalStoragesService->setUser($user);
-		$userStoragesService->setUser($user);
-
-		foreach ($userGlobalStoragesService->getStorages() as $storage) {
-			/** @var \OCA\Files_External\Lib\StorageConfig $storage */
-			$mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
-			$mountEntry = self::prepareMountPointEntry($storage, false);
-			foreach ($mountEntry['options'] as &$option) {
-				$option = self::setUserVars($uid, $option);
-			}
-			$mountPoints[$mountPoint] = $mountEntry;
-		}
-
-		foreach ($userStoragesService->getStorages() as $storage) {
-			$mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
-			$mountEntry = self::prepareMountPointEntry($storage, true);
-			foreach ($mountEntry['options'] as &$option) {
-				$option = self::setUserVars($uid, $option);
-			}
-			$mountPoints[$mountPoint] = $mountEntry;
-		}
-
-		$userGlobalStoragesService->resetUser();
-		$userStoragesService->resetUser();
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Get the system mount points
-	 *
-	 * @return array
-	 *
-	 * @deprecated 8.2.0 use GlobalStoragesService::getStorages()
-	 */
-	public static function getSystemMountPoints() {
-		$mountPoints = [];
-		$service = self::$app->getContainer()->query('OCA\Files_External\Service\GlobalStoragesService');
-
-		foreach ($service->getStorages() as $storage) {
-			$mountPoints[] = self::prepareMountPointEntry($storage, false);
-		}
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Get the personal mount points of the current user
-	 *
-	 * @return array
-	 *
-	 * @deprecated 8.2.0 use UserStoragesService::getStorages()
-	 */
-	public static function getPersonalMountPoints() {
-		$mountPoints = [];
-		$service = self::$app->getContainer()->query('OCA\Files_External\Service\UserStoragesService');
-
-		foreach ($service->getStorages() as $storage) {
-			$mountPoints[] = self::prepareMountPointEntry($storage, true);
-		}
-
-		return $mountPoints;
-	}
-
-	/**
-	 * Convert a StorageConfig to the legacy mountPoints array format
-	 * There's a lot of extra information in here, to satisfy all of the legacy functions
-	 *
-	 * @param StorageConfig $storage
-	 * @param bool $isPersonal
-	 * @return array
-	 */
-	private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) {
-		$mountEntry = [];
-
-		$mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash
-		$mountEntry['class'] = $storage->getBackend()->getIdentifier();
-		$mountEntry['backend'] = $storage->getBackend()->getText();
-		$mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier();
-		$mountEntry['personal'] = $isPersonal;
-		$mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions());
-		$mountEntry['mountOptions'] = $storage->getMountOptions();
-		$mountEntry['priority'] = $storage->getPriority();
-		$mountEntry['applicable'] = [
-			'groups' => $storage->getApplicableGroups(),
-			'users' => $storage->getApplicableUsers(),
-		];
-		// if mountpoint is applicable to all users the old API expects ['all']
-		if (empty($mountEntry['applicable']['groups']) && empty($mountEntry['applicable']['users'])) {
-			$mountEntry['applicable']['users'] = ['all'];
-		}
-
-		$mountEntry['id'] = $storage->getId();
-
-		return $mountEntry;
-	}
-
-	/**
-	 * fill in the correct values for $user
-	 *
-	 * @param string $user user value
-	 * @param string|array $input
-	 * @return string
-	 */
-	public static function setUserVars($user, $input) {
-		if (is_array($input)) {
-			foreach ($input as &$value) {
-				if (is_string($value)) {
-					$value = str_replace('$user', $user, $value);
-				}
-			}
-		} else {
-			if (is_string($input)) {
-				$input = str_replace('$user', $user, $input);
-			}
-		}
-		return $input;
-	}
-
-	/**
-	 * Test connecting using the given backend configuration
-	 *
-	 * @param string $class backend class name
-	 * @param array $options backend configuration options
-	 * @param boolean $isPersonal
-	 * @return int see self::STATUS_*
-	 * @throws Exception
-	 */
-	public static function getBackendStatus($class, $options, $isPersonal, $testOnly = true) {
-		if (self::$skipTest) {
-			return StorageNotAvailableException::STATUS_SUCCESS;
-		}
-		foreach ($options as &$option) {
-			$option = self::setUserVars(OCP\User::getUser(), $option);
-		}
-		if (class_exists($class)) {
-			try {
-				/** @var \OC\Files\Storage\Common $storage */
-				$storage = new $class($options);
-
-				try {
-					$result = $storage->test($isPersonal, $testOnly);
-					$storage->setAvailability($result);
-					if ($result) {
-						return StorageNotAvailableException::STATUS_SUCCESS;
-					}
-				} catch (\Exception $e) {
-					$storage->setAvailability(false);
-					throw $e;
-				}
-			} catch (Exception $exception) {
-				\OCP\Util::logException('files_external', $exception);
-				throw $exception;
-			}
-		}
-		return StorageNotAvailableException::STATUS_ERROR;
-	}
-
-	/**
-	 * Read the mount points in the config file into an array
-	 *
-	 * @param string|null $user If not null, personal for $user, otherwise system
-	 * @return array
-	 */
-	public static function readData($user = null) {
-		if (isset($user)) {
-			$jsonFile = \OC::$server->getUserManager()->get($user)->getHome() . '/mount.json';
-		} else {
-			$config = \OC::$server->getConfig();
-			$datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
-			$jsonFile = $config->getSystemValue('mount_file', $datadir . '/mount.json');
-		}
-		if (is_file($jsonFile)) {
-			$mountPoints = json_decode(file_get_contents($jsonFile), true);
-			if (is_array($mountPoints)) {
-				return $mountPoints;
-			}
-		}
-		return array();
-	}
-
-	/**
-	 * Get backend dependency message
-	 * TODO: move into AppFramework along with templates
-	 *
-	 * @param Backend[] $backends
-	 * @return string
-	 */
-	public static function dependencyMessage($backends) {
-		$l = \OC::$server->getL10N('files_external');
-		$message = '';
-		$dependencyGroups = [];
-
-		foreach ($backends as $backend) {
-			foreach ($backend->checkDependencies() as $dependency) {
-				if ($message = $dependency->getMessage()) {
-					$message .= '<p>' . $message . '</p>';
-				} else {
-					$dependencyGroups[$dependency->getDependency()][] = $backend;
-				}
-			}
-		}
-
-		foreach ($dependencyGroups as $module => $dependants) {
-			$backends = implode(', ', array_map(function($backend) {
-				return '"' . $backend->getText() . '"';
-			}, $dependants));
-			$message .= '<p>' . OC_Mount_Config::getSingleDependencyMessage($l, $module, $backends) . '</p>';
-		}
-
-		return $message;
-	}
-
-	/**
-	 * Returns a dependency missing message
-	 *
-	 * @param \OCP\IL10N $l
-	 * @param string $module
-	 * @param string $backend
-	 * @return string
-	 */
-	private static function getSingleDependencyMessage(\OCP\IL10N $l, $module, $backend) {
-		switch (strtolower($module)) {
-			case 'curl':
-				return (string)$l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', $backend);
-			case 'ftp':
-				return (string)$l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', $backend);
-			default:
-				return (string)$l->t('"%s" is not installed. Mounting of %s is not possible. Please ask your system administrator to install it.', array($module, $backend));
-		}
-	}
-
-	/**
-	 * Encrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function encryptPasswords($options) {
-		if (isset($options['password'])) {
-			$options['password_encrypted'] = self::encryptPassword($options['password']);
-			// do not unset the password, we want to keep the keys order
-			// on load... because that's how the UI currently works
-			$options['password'] = '';
-		}
-		return $options;
-	}
-
-	/**
-	 * Decrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function decryptPasswords($options) {
-		// note: legacy options might still have the unencrypted password in the "password" field
-		if (isset($options['password_encrypted'])) {
-			$options['password'] = self::decryptPassword($options['password_encrypted']);
-			unset($options['password_encrypted']);
-		}
-		return $options;
-	}
-
-	/**
-	 * Encrypt a single password
-	 *
-	 * @param string $password plain text password
-	 * @return string encrypted password
-	 */
-	private static function encryptPassword($password) {
-		$cipher = self::getCipher();
-		$iv = \OCP\Util::generateRandomBytes(16);
-		$cipher->setIV($iv);
-		return base64_encode($iv . $cipher->encrypt($password));
-	}
-
-	/**
-	 * Decrypts a single password
-	 *
-	 * @param string $encryptedPassword encrypted password
-	 * @return string plain text password
-	 */
-	private static function decryptPassword($encryptedPassword) {
-		$cipher = self::getCipher();
-		$binaryPassword = base64_decode($encryptedPassword);
-		$iv = substr($binaryPassword, 0, 16);
-		$cipher->setIV($iv);
-		$binaryPassword = substr($binaryPassword, 16);
-		return $cipher->decrypt($binaryPassword);
-	}
-
-	/**
-	 * Returns the encryption cipher
-	 *
-	 * @return AES
-	 */
-	private static function getCipher() {
-		$cipher = new AES(AES::MODE_CBC);
-		$cipher->setKey(\OC::$server->getConfig()->getSystemValue('passwordsalt', null));
-		return $cipher;
-	}
-
-	/**
-	 * Computes a hash based on the given configuration.
-	 * This is mostly used to find out whether configurations
-	 * are the same.
-	 *
-	 * @param array $config
-	 * @return string
-	 */
-	public static function makeConfigHash($config) {
-		$data = json_encode(
-			array(
-				'c' => $config['backend'],
-				'a' => $config['authMechanism'],
-				'm' => $config['mountpoint'],
-				'o' => $config['options'],
-				'p' => isset($config['priority']) ? $config['priority'] : -1,
-				'mo' => isset($config['mountOptions']) ? $config['mountOptions'] : [],
-			)
-		);
-		return hash('md5', $data);
-	}
+    // TODO: make this class non-static and give it a proper namespace
+
+    const MOUNT_TYPE_GLOBAL = 'global';
+    const MOUNT_TYPE_GROUP = 'group';
+    const MOUNT_TYPE_USER = 'user';
+    const MOUNT_TYPE_PERSONAL = 'personal';
+
+    // whether to skip backend test (for unit tests, as this static class is not mockable)
+    public static $skipTest = false;
+
+    /** @var Application */
+    public static $app;
+
+    /**
+     * @param string $class
+     * @param array $definition
+     * @return bool
+     * @deprecated 8.2.0 use \OCA\Files_External\Service\BackendService::registerBackend()
+     */
+    public static function registerBackend($class, $definition) {
+        $backendService = self::$app->getContainer()->query('OCA\Files_External\Service\BackendService');
+        $auth = self::$app->getContainer()->query('OCA\Files_External\Lib\Auth\Builtin');
+
+        $backendService->registerBackend(new LegacyBackend($class, $definition, $auth));
+
+        return true;
+    }
+
+    /**
+     * Returns the mount points for the given user.
+     * The mount point is relative to the data directory.
+     *
+     * @param string $uid user
+     * @return array of mount point string as key, mountpoint config as value
+     *
+     * @deprecated 8.2.0 use UserGlobalStoragesService::getStorages() and UserStoragesService::getStorages()
+     */
+    public static function getAbsoluteMountPoints($uid) {
+        $mountPoints = array();
+
+        $userGlobalStoragesService = self::$app->getContainer()->query('OCA\Files_External\Service\UserGlobalStoragesService');
+        $userStoragesService = self::$app->getContainer()->query('OCA\Files_External\Service\UserStoragesService');
+        $user = self::$app->getContainer()->query('OCP\IUserManager')->get($uid);
+
+        $userGlobalStoragesService->setUser($user);
+        $userStoragesService->setUser($user);
+
+        foreach ($userGlobalStoragesService->getStorages() as $storage) {
+            /** @var \OCA\Files_External\Lib\StorageConfig $storage */
+            $mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
+            $mountEntry = self::prepareMountPointEntry($storage, false);
+            foreach ($mountEntry['options'] as &$option) {
+                $option = self::setUserVars($uid, $option);
+            }
+            $mountPoints[$mountPoint] = $mountEntry;
+        }
+
+        foreach ($userStoragesService->getStorages() as $storage) {
+            $mountPoint = '/'.$uid.'/files'.$storage->getMountPoint();
+            $mountEntry = self::prepareMountPointEntry($storage, true);
+            foreach ($mountEntry['options'] as &$option) {
+                $option = self::setUserVars($uid, $option);
+            }
+            $mountPoints[$mountPoint] = $mountEntry;
+        }
+
+        $userGlobalStoragesService->resetUser();
+        $userStoragesService->resetUser();
+
+        return $mountPoints;
+    }
+
+    /**
+     * Get the system mount points
+     *
+     * @return array
+     *
+     * @deprecated 8.2.0 use GlobalStoragesService::getStorages()
+     */
+    public static function getSystemMountPoints() {
+        $mountPoints = [];
+        $service = self::$app->getContainer()->query('OCA\Files_External\Service\GlobalStoragesService');
+
+        foreach ($service->getStorages() as $storage) {
+            $mountPoints[] = self::prepareMountPointEntry($storage, false);
+        }
+
+        return $mountPoints;
+    }
+
+    /**
+     * Get the personal mount points of the current user
+     *
+     * @return array
+     *
+     * @deprecated 8.2.0 use UserStoragesService::getStorages()
+     */
+    public static function getPersonalMountPoints() {
+        $mountPoints = [];
+        $service = self::$app->getContainer()->query('OCA\Files_External\Service\UserStoragesService');
+
+        foreach ($service->getStorages() as $storage) {
+            $mountPoints[] = self::prepareMountPointEntry($storage, true);
+        }
+
+        return $mountPoints;
+    }
+
+    /**
+     * Convert a StorageConfig to the legacy mountPoints array format
+     * There's a lot of extra information in here, to satisfy all of the legacy functions
+     *
+     * @param StorageConfig $storage
+     * @param bool $isPersonal
+     * @return array
+     */
+    private static function prepareMountPointEntry(StorageConfig $storage, $isPersonal) {
+        $mountEntry = [];
+
+        $mountEntry['mountpoint'] = substr($storage->getMountPoint(), 1); // remove leading slash
+        $mountEntry['class'] = $storage->getBackend()->getIdentifier();
+        $mountEntry['backend'] = $storage->getBackend()->getText();
+        $mountEntry['authMechanism'] = $storage->getAuthMechanism()->getIdentifier();
+        $mountEntry['personal'] = $isPersonal;
+        $mountEntry['options'] = self::decryptPasswords($storage->getBackendOptions());
+        $mountEntry['mountOptions'] = $storage->getMountOptions();
+        $mountEntry['priority'] = $storage->getPriority();
+        $mountEntry['applicable'] = [
+            'groups' => $storage->getApplicableGroups(),
+            'users' => $storage->getApplicableUsers(),
+        ];
+        // if mountpoint is applicable to all users the old API expects ['all']
+        if (empty($mountEntry['applicable']['groups']) && empty($mountEntry['applicable']['users'])) {
+            $mountEntry['applicable']['users'] = ['all'];
+        }
+
+        $mountEntry['id'] = $storage->getId();
+
+        return $mountEntry;
+    }
+
+    /**
+     * fill in the correct values for $user
+     *
+     * @param string $user user value
+     * @param string|array $input
+     * @return string
+     */
+    public static function setUserVars($user, $input) {
+        if (is_array($input)) {
+            foreach ($input as &$value) {
+                if (is_string($value)) {
+                    $value = str_replace('$user', $user, $value);
+                }
+            }
+        } else {
+            if (is_string($input)) {
+                $input = str_replace('$user', $user, $input);
+            }
+        }
+        return $input;
+    }
+
+    /**
+     * Test connecting using the given backend configuration
+     *
+     * @param string $class backend class name
+     * @param array $options backend configuration options
+     * @param boolean $isPersonal
+     * @return int see self::STATUS_*
+     * @throws Exception
+     */
+    public static function getBackendStatus($class, $options, $isPersonal, $testOnly = true) {
+        if (self::$skipTest) {
+            return StorageNotAvailableException::STATUS_SUCCESS;
+        }
+        foreach ($options as &$option) {
+            $option = self::setUserVars(OCP\User::getUser(), $option);
+        }
+        if (class_exists($class)) {
+            try {
+                /** @var \OC\Files\Storage\Common $storage */
+                $storage = new $class($options);
+
+                try {
+                    $result = $storage->test($isPersonal, $testOnly);
+                    $storage->setAvailability($result);
+                    if ($result) {
+                        return StorageNotAvailableException::STATUS_SUCCESS;
+                    }
+                } catch (\Exception $e) {
+                    $storage->setAvailability(false);
+                    throw $e;
+                }
+            } catch (Exception $exception) {
+                \OCP\Util::logException('files_external', $exception);
+                throw $exception;
+            }
+        }
+        return StorageNotAvailableException::STATUS_ERROR;
+    }
+
+    /**
+     * Read the mount points in the config file into an array
+     *
+     * @param string|null $user If not null, personal for $user, otherwise system
+     * @return array
+     */
+    public static function readData($user = null) {
+        if (isset($user)) {
+            $jsonFile = \OC::$server->getUserManager()->get($user)->getHome() . '/mount.json';
+        } else {
+            $config = \OC::$server->getConfig();
+            $datadir = $config->getSystemValue('datadirectory', \OC::$SERVERROOT . '/data/');
+            $jsonFile = $config->getSystemValue('mount_file', $datadir . '/mount.json');
+        }
+        if (is_file($jsonFile)) {
+            $mountPoints = json_decode(file_get_contents($jsonFile), true);
+            if (is_array($mountPoints)) {
+                return $mountPoints;
+            }
+        }
+        return array();
+    }
+
+    /**
+     * Get backend dependency message
+     * TODO: move into AppFramework along with templates
+     *
+     * @param Backend[] $backends
+     * @return string
+     */
+    public static function dependencyMessage($backends) {
+        $l = \OC::$server->getL10N('files_external');
+        $message = '';
+        $dependencyGroups = [];
+
+        foreach ($backends as $backend) {
+            foreach ($backend->checkDependencies() as $dependency) {
+                if ($message = $dependency->getMessage()) {
+                    $message .= '<p>' . $message . '</p>';
+                } else {
+                    $dependencyGroups[$dependency->getDependency()][] = $backend;
+                }
+            }
+        }
+
+        foreach ($dependencyGroups as $module => $dependants) {
+            $backends = implode(', ', array_map(function($backend) {
+                return '"' . $backend->getText() . '"';
+            }, $dependants));
+            $message .= '<p>' . OC_Mount_Config::getSingleDependencyMessage($l, $module, $backends) . '</p>';
+        }
+
+        return $message;
+    }
+
+    /**
+     * Returns a dependency missing message
+     *
+     * @param \OCP\IL10N $l
+     * @param string $module
+     * @param string $backend
+     * @return string
+     */
+    private static function getSingleDependencyMessage(\OCP\IL10N $l, $module, $backend) {
+        switch (strtolower($module)) {
+            case 'curl':
+                return (string)$l->t('The cURL support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', $backend);
+            case 'ftp':
+                return (string)$l->t('The FTP support in PHP is not enabled or installed. Mounting of %s is not possible. Please ask your system administrator to install it.', $backend);
+            default:
+                return (string)$l->t('"%s" is not installed. Mounting of %s is not possible. Please ask your system administrator to install it.', array($module, $backend));
+        }
+    }
+
+    /**
+     * Encrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function encryptPasswords($options) {
+        if (isset($options['password'])) {
+            $options['password_encrypted'] = self::encryptPassword($options['password']);
+            // do not unset the password, we want to keep the keys order
+            // on load... because that's how the UI currently works
+            $options['password'] = '';
+        }
+        return $options;
+    }
+
+    /**
+     * Decrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function decryptPasswords($options) {
+        // note: legacy options might still have the unencrypted password in the "password" field
+        if (isset($options['password_encrypted'])) {
+            $options['password'] = self::decryptPassword($options['password_encrypted']);
+            unset($options['password_encrypted']);
+        }
+        return $options;
+    }
+
+    /**
+     * Encrypt a single password
+     *
+     * @param string $password plain text password
+     * @return string encrypted password
+     */
+    private static function encryptPassword($password) {
+        $cipher = self::getCipher();
+        $iv = \OCP\Util::generateRandomBytes(16);
+        $cipher->setIV($iv);
+        return base64_encode($iv . $cipher->encrypt($password));
+    }
+
+    /**
+     * Decrypts a single password
+     *
+     * @param string $encryptedPassword encrypted password
+     * @return string plain text password
+     */
+    private static function decryptPassword($encryptedPassword) {
+        $cipher = self::getCipher();
+        $binaryPassword = base64_decode($encryptedPassword);
+        $iv = substr($binaryPassword, 0, 16);
+        $cipher->setIV($iv);
+        $binaryPassword = substr($binaryPassword, 16);
+        return $cipher->decrypt($binaryPassword);
+    }
+
+    /**
+     * Returns the encryption cipher
+     *
+     * @return AES
+     */
+    private static function getCipher() {
+        $cipher = new AES(AES::MODE_CBC);
+        $cipher->setKey(\OC::$server->getConfig()->getSystemValue('passwordsalt', null));
+        return $cipher;
+    }
+
+    /**
+     * Computes a hash based on the given configuration.
+     * This is mostly used to find out whether configurations
+     * are the same.
+     *
+     * @param array $config
+     * @return string
+     */
+    public static function makeConfigHash($config) {
+        $data = json_encode(
+            array(
+                'c' => $config['backend'],
+                'a' => $config['authMechanism'],
+                'm' => $config['mountpoint'],
+                'o' => $config['options'],
+                'p' => isset($config['priority']) ? $config['priority'] : -1,
+                'mo' => isset($config['mountOptions']) ? $config['mountOptions'] : [],
+            )
+        );
+        return hash('md5', $data);
+    }
 }

apps/files_external/lib/Migration/StorageMigrator.php

Indentation +91 added lines, -91 removed lines

@@ -42,107 +42,107 @@
  * Migrate mount config from mount.json to the database
  */
 class StorageMigrator {
-	/**
-	 * @var BackendService
-	 */
-	private $backendService;
+    /**
+     * @var BackendService
+     */
+    private $backendService;
 
-	/**
-	 * @var DBConfigService
-	 */
-	private $dbConfig;
+    /**
+     * @var DBConfigService
+     */
+    private $dbConfig;
 
-	/**
-	 * @var IConfig
-	 */
-	private $config;
+    /**
+     * @var IConfig
+     */
+    private $config;
 
-	/**
-	 * @var IDBConnection
-	 */
-	private $connection;
+    /**
+     * @var IDBConnection
+     */
+    private $connection;
 
-	/**
-	 * @var ILogger
-	 */
-	private $logger;
+    /**
+     * @var ILogger
+     */
+    private $logger;
 
-	/** @var IUserMountCache  */
-	private $userMountCache;
+    /** @var IUserMountCache  */
+    private $userMountCache;
 
-	/**
-	 * StorageMigrator constructor.
-	 *
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfig
-	 * @param IConfig $config
-	 * @param IDBConnection $connection
-	 * @param ILogger $logger
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(
-		BackendService $backendService,
-		DBConfigService $dbConfig,
-		IConfig $config,
-		IDBConnection $connection,
-		ILogger $logger,
-		IUserMountCache $userMountCache
-	) {
-		$this->backendService = $backendService;
-		$this->dbConfig = $dbConfig;
-		$this->config = $config;
-		$this->connection = $connection;
-		$this->logger = $logger;
-		$this->userMountCache = $userMountCache;
-	}
+    /**
+     * StorageMigrator constructor.
+     *
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfig
+     * @param IConfig $config
+     * @param IDBConnection $connection
+     * @param ILogger $logger
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(
+        BackendService $backendService,
+        DBConfigService $dbConfig,
+        IConfig $config,
+        IDBConnection $connection,
+        ILogger $logger,
+        IUserMountCache $userMountCache
+    ) {
+        $this->backendService = $backendService;
+        $this->dbConfig = $dbConfig;
+        $this->config = $config;
+        $this->connection = $connection;
+        $this->logger = $logger;
+        $this->userMountCache = $userMountCache;
+    }
 
-	private function migrate(LegacyStoragesService $legacyService, StoragesService $storageService) {
-		$existingStorage = $legacyService->getAllStorages();
+    private function migrate(LegacyStoragesService $legacyService, StoragesService $storageService) {
+        $existingStorage = $legacyService->getAllStorages();
 
-		$this->connection->beginTransaction();
-		try {
-			foreach ($existingStorage as $storage) {
-				$mountOptions = $storage->getMountOptions();
-				if (!empty($mountOptions) && !isset($mountOptions['enable_sharing'])) {
-					// existing mounts must have sharing enabled by default to avoid surprises
-					$mountOptions['enable_sharing'] = true;
-					$storage->setMountOptions($mountOptions);
-				}
-				$storageService->addStorage($storage);
-			}
-			$this->connection->commit();
-		} catch (\Exception $e) {
-			$this->logger->logException($e);
-			$this->connection->rollBack();
-		}
-	}
+        $this->connection->beginTransaction();
+        try {
+            foreach ($existingStorage as $storage) {
+                $mountOptions = $storage->getMountOptions();
+                if (!empty($mountOptions) && !isset($mountOptions['enable_sharing'])) {
+                    // existing mounts must have sharing enabled by default to avoid surprises
+                    $mountOptions['enable_sharing'] = true;
+                    $storage->setMountOptions($mountOptions);
+                }
+                $storageService->addStorage($storage);
+            }
+            $this->connection->commit();
+        } catch (\Exception $e) {
+            $this->logger->logException($e);
+            $this->connection->rollBack();
+        }
+    }
 
-	/**
-	 * Migrate admin configured storages
-	 */
-	public function migrateGlobal() {
-		$legacyService = new GlobalLegacyStoragesService($this->backendService);
-		$storageService = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->userMountCache);
+    /**
+     * Migrate admin configured storages
+     */
+    public function migrateGlobal() {
+        $legacyService = new GlobalLegacyStoragesService($this->backendService);
+        $storageService = new GlobalStoragesService($this->backendService, $this->dbConfig, $this->userMountCache);
 
-		$this->migrate($legacyService, $storageService);
-	}
+        $this->migrate($legacyService, $storageService);
+    }
 
-	/**
-	 * Migrate personal storages configured by the current user
-	 *
-	 * @param IUser $user
-	 */
-	public function migrateUser(IUser $user) {
-		$dummySession = new DummyUserSession();
-		$dummySession->setUser($user);
-		$userId = $user->getUID();
-		$userVersion = $this->config->getUserValue($userId, 'files_external', 'config_version', '0.0.0');
-		if (version_compare($userVersion, '0.5.0', '<')) {
-			$this->config->setUserValue($userId, 'files_external', 'config_version', '0.5.0');
-			$legacyService = new UserLegacyStoragesService($this->backendService, $dummySession);
-			$storageService = new UserStoragesService($this->backendService, $this->dbConfig, $dummySession, $this->userMountCache);
+    /**
+     * Migrate personal storages configured by the current user
+     *
+     * @param IUser $user
+     */
+    public function migrateUser(IUser $user) {
+        $dummySession = new DummyUserSession();
+        $dummySession->setUser($user);
+        $userId = $user->getUID();
+        $userVersion = $this->config->getUserValue($userId, 'files_external', 'config_version', '0.0.0');
+        if (version_compare($userVersion, '0.5.0', '<')) {
+            $this->config->setUserValue($userId, 'files_external', 'config_version', '0.5.0');
+            $legacyService = new UserLegacyStoragesService($this->backendService, $dummySession);
+            $storageService = new UserStoragesService($this->backendService, $this->dbConfig, $dummySession, $this->userMountCache);
 
-			$this->migrate($legacyService, $storageService);
-		}
-	}
+            $this->migrate($legacyService, $storageService);
+        }
+    }
 }

apps/files_external/lib/Migration/DummyUserSession.php

Indentation +17 added lines, -17 removed lines

@@ -28,26 +28,26 @@
 
 class DummyUserSession implements IUserSession {
 
-	/**
-	 * @var IUser
-	 */
-	private $user;
+    /**
+     * @var IUser
+     */
+    private $user;
 
-	public function login($user, $password) {
-	}
+    public function login($user, $password) {
+    }
 
-	public function logout() {
-	}
+    public function logout() {
+    }
 
-	public function setUser($user) {
-		$this->user = $user;
-	}
+    public function setUser($user) {
+        $this->user = $user;
+    }
 
-	public function getUser() {
-		return $this->user;
-	}
+    public function getUser() {
+        return $this->user;
+    }
 
-	public function isLoggedIn() {
-		return !is_null($this->user);
-	}
+    public function isLoggedIn() {
+        return !is_null($this->user);
+    }
 }

apps/files_external/lib/Command/Export.php

Indentation +25 added lines, -25 removed lines

@@ -30,30 +30,30 @@
 
 class Export extends ListCommand {
 
-	protected function configure() {
-		$this
-			->setName('files_external:export')
-			->setDescription('Export mount configurations')
-			->addArgument(
-				'user_id',
-				InputArgument::OPTIONAL,
-				'user id to export the personal mounts for, if no user is provided admin mounts will be exported'
-			)->addOption(
-				'all',
-				'a',
-				InputOption::VALUE_NONE,
-				'show both system wide mounts and all personal mounts'
-			);
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:export')
+            ->setDescription('Export mount configurations')
+            ->addArgument(
+                'user_id',
+                InputArgument::OPTIONAL,
+                'user id to export the personal mounts for, if no user is provided admin mounts will be exported'
+            )->addOption(
+                'all',
+                'a',
+                InputOption::VALUE_NONE,
+                'show both system wide mounts and all personal mounts'
+            );
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$listCommand = new ListCommand($this->globalService, $this->userService, $this->userSession, $this->userManager);
-		$listInput = new ArrayInput([], $listCommand->getDefinition());
-		$listInput->setArgument('user_id', $input->getArgument('user_id'));
-		$listInput->setOption('all', $input->getOption('all'));
-		$listInput->setOption('output', 'json_pretty');
-		$listInput->setOption('show-password', true);
-		$listInput->setOption('full', true);
-		$listCommand->execute($listInput, $output);
-	}
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $listCommand = new ListCommand($this->globalService, $this->userService, $this->userSession, $this->userManager);
+        $listInput = new ArrayInput([], $listCommand->getDefinition());
+        $listInput->setArgument('user_id', $input->getArgument('user_id'));
+        $listInput->setOption('all', $input->getOption('all'));
+        $listInput->setOption('output', 'json_pretty');
+        $listInput->setOption('show-password', true);
+        $listInput->setOption('full', true);
+        $listCommand->execute($listInput, $output);
+    }
 }

apps/files_external/lib/Command/Applicable.php

Indentation +107 added lines, -107 removed lines

@@ -35,122 +35,122 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Applicable extends Base {
-	/**
-	 * @var GlobalStoragesService
-	 */
-	protected $globalService;
+    /**
+     * @var GlobalStoragesService
+     */
+    protected $globalService;
 
-	/**
-	 * @var IUserManager
-	 */
-	private $userManager;
+    /**
+     * @var IUserManager
+     */
+    private $userManager;
 
-	/**
-	 * @var IGroupManager
-	 */
-	private $groupManager;
+    /**
+     * @var IGroupManager
+     */
+    private $groupManager;
 
-	function __construct(
-		GlobalStoragesService $globalService,
-		IUserManager $userManager,
-		IGroupManager $groupManager
-	) {
-		parent::__construct();
-		$this->globalService = $globalService;
-		$this->userManager = $userManager;
-		$this->groupManager = $groupManager;
-	}
+    function __construct(
+        GlobalStoragesService $globalService,
+        IUserManager $userManager,
+        IGroupManager $groupManager
+    ) {
+        parent::__construct();
+        $this->globalService = $globalService;
+        $this->userManager = $userManager;
+        $this->groupManager = $groupManager;
+    }
 
-	protected function configure() {
-		$this
-			->setName('files_external:applicable')
-			->setDescription('Manage applicable users and groups for a mount')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'The id of the mount to edit'
-			)->addOption(
-				'add-user',
-				null,
-				InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
-				'user to add as applicable'
-			)->addOption(
-				'remove-user',
-				null,
-				InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
-				'user to remove as applicable'
-			)->addOption(
-				'add-group',
-				null,
-				InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
-				'group to add as applicable'
-			)->addOption(
-				'remove-group',
-				null,
-				InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
-				'group to remove as applicable'
-			)->addOption(
-				'remove-all',
-				null,
-				InputOption::VALUE_NONE,
-				'Set the mount to be globally applicable'
-			);
-		parent::configure();
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:applicable')
+            ->setDescription('Manage applicable users and groups for a mount')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'The id of the mount to edit'
+            )->addOption(
+                'add-user',
+                null,
+                InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
+                'user to add as applicable'
+            )->addOption(
+                'remove-user',
+                null,
+                InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
+                'user to remove as applicable'
+            )->addOption(
+                'add-group',
+                null,
+                InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
+                'group to add as applicable'
+            )->addOption(
+                'remove-group',
+                null,
+                InputOption::VALUE_IS_ARRAY | InputOption::VALUE_REQUIRED,
+                'group to remove as applicable'
+            )->addOption(
+                'remove-all',
+                null,
+                InputOption::VALUE_NONE,
+                'Set the mount to be globally applicable'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$mountId = $input->getArgument('mount_id');
-		try {
-			$mount = $this->globalService->getStorage($mountId);
-		} catch (NotFoundException $e) {
-			$output->writeln('<error>Mount with id "' . $mountId . ' not found, check "occ files_external:list" to get available mounts</error>');
-			return 404;
-		}
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $mountId = $input->getArgument('mount_id');
+        try {
+            $mount = $this->globalService->getStorage($mountId);
+        } catch (NotFoundException $e) {
+            $output->writeln('<error>Mount with id "' . $mountId . ' not found, check "occ files_external:list" to get available mounts</error>');
+            return 404;
+        }
 
-		if ($mount->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
-			$output->writeln('<error>Can\'t change applicables on personal mounts</error>');
-			return 1;
-		}
+        if ($mount->getType() === StorageConfig::MOUNT_TYPE_PERSONAl) {
+            $output->writeln('<error>Can\'t change applicables on personal mounts</error>');
+            return 1;
+        }
 
-		$addUsers = $input->getOption('add-user');
-		$removeUsers = $input->getOption('remove-user');
-		$addGroups = $input->getOption('add-group');
-		$removeGroups = $input->getOption('remove-group');
+        $addUsers = $input->getOption('add-user');
+        $removeUsers = $input->getOption('remove-user');
+        $addGroups = $input->getOption('add-group');
+        $removeGroups = $input->getOption('remove-group');
 
-		$applicableUsers = $mount->getApplicableUsers();
-		$applicableGroups = $mount->getApplicableGroups();
+        $applicableUsers = $mount->getApplicableUsers();
+        $applicableGroups = $mount->getApplicableGroups();
 
-		if ((count($addUsers) + count($removeUsers) + count($addGroups) + count($removeGroups) > 0) || $input->getOption('remove-all')) {
-			foreach ($addUsers as $addUser) {
-				if (!$this->userManager->userExists($addUser)) {
-					$output->writeln('<error>User "' . $addUser . '" not found</error>');
-					return 404;
-				}
-			}
-			foreach ($addGroups as $addGroup) {
-				if (!$this->groupManager->groupExists($addGroup)) {
-					$output->writeln('<error>Group "' . $addGroup . '" not found</error>');
-					return 404;
-				}
-			}
+        if ((count($addUsers) + count($removeUsers) + count($addGroups) + count($removeGroups) > 0) || $input->getOption('remove-all')) {
+            foreach ($addUsers as $addUser) {
+                if (!$this->userManager->userExists($addUser)) {
+                    $output->writeln('<error>User "' . $addUser . '" not found</error>');
+                    return 404;
+                }
+            }
+            foreach ($addGroups as $addGroup) {
+                if (!$this->groupManager->groupExists($addGroup)) {
+                    $output->writeln('<error>Group "' . $addGroup . '" not found</error>');
+                    return 404;
+                }
+            }
 
-			if ($input->getOption('remove-all')) {
-				$applicableUsers = [];
-				$applicableGroups = [];
-			} else {
-				$applicableUsers = array_unique(array_merge($applicableUsers, $addUsers));
-				$applicableUsers = array_values(array_diff($applicableUsers, $removeUsers));
-				$applicableGroups = array_unique(array_merge($applicableGroups, $addGroups));
-				$applicableGroups = array_values(array_diff($applicableGroups, $removeGroups));
-			}
-			$mount->setApplicableUsers($applicableUsers);
-			$mount->setApplicableGroups($applicableGroups);
-			$this->globalService->updateStorage($mount);
-		}
+            if ($input->getOption('remove-all')) {
+                $applicableUsers = [];
+                $applicableGroups = [];
+            } else {
+                $applicableUsers = array_unique(array_merge($applicableUsers, $addUsers));
+                $applicableUsers = array_values(array_diff($applicableUsers, $removeUsers));
+                $applicableGroups = array_unique(array_merge($applicableGroups, $addGroups));
+                $applicableGroups = array_values(array_diff($applicableGroups, $removeGroups));
+            }
+            $mount->setApplicableUsers($applicableUsers);
+            $mount->setApplicableGroups($applicableGroups);
+            $this->globalService->updateStorage($mount);
+        }
 
-		$this->writeArrayInOutputFormat($input, $output, [
-			'users' => $applicableUsers,
-			'groups' => $applicableGroups
-		]);
-	}
+        $this->writeArrayInOutputFormat($input, $output, [
+            'users' => $applicableUsers,
+            'groups' => $applicableGroups
+        ]);
+    }
 }