nextcloud / server

apps/files_external/lib/Controller/AjaxController.php

Indentation +73 added lines, -73 removed lines

@@ -37,84 +37,84 @@
 use OCP\IUserSession;
 
 class AjaxController extends Controller {
-	/** @var RSA */
-	private $rsaMechanism;
-	/** @var GlobalAuth  */
-	private $globalAuth;
-	/** @var IUserSession */
-	private $userSession;
-	/** @var IGroupManager */
-	private $groupManager;
+    /** @var RSA */
+    private $rsaMechanism;
+    /** @var GlobalAuth  */
+    private $globalAuth;
+    /** @var IUserSession */
+    private $userSession;
+    /** @var IGroupManager */
+    private $groupManager;
 
-	/**
-	 * @param string $appName
-	 * @param IRequest $request
-	 * @param RSA $rsaMechanism
-	 * @param GlobalAuth $globalAuth
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct($appName,
-								IRequest $request,
-								RSA $rsaMechanism,
-								GlobalAuth $globalAuth,
-								IUserSession $userSession,
-								IGroupManager $groupManager) {
-		parent::__construct($appName, $request);
-		$this->rsaMechanism = $rsaMechanism;
-		$this->globalAuth = $globalAuth;
-		$this->userSession = $userSession;
-		$this->groupManager = $groupManager;
-	}
+    /**
+     * @param string $appName
+     * @param IRequest $request
+     * @param RSA $rsaMechanism
+     * @param GlobalAuth $globalAuth
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct($appName,
+                                IRequest $request,
+                                RSA $rsaMechanism,
+                                GlobalAuth $globalAuth,
+                                IUserSession $userSession,
+                                IGroupManager $groupManager) {
+        parent::__construct($appName, $request);
+        $this->rsaMechanism = $rsaMechanism;
+        $this->globalAuth = $globalAuth;
+        $this->userSession = $userSession;
+        $this->groupManager = $groupManager;
+    }
 
-	/**
-	 * @return array
-	 */
-	private function generateSshKeys() {
-		$key = $this->rsaMechanism->createKey();
-		// Replace the placeholder label with a more meaningful one
-		$key['publicKey'] = str_replace('phpseclib-generated-key', gethostname(), $key['publickey']);
+    /**
+     * @return array
+     */
+    private function generateSshKeys() {
+        $key = $this->rsaMechanism->createKey();
+        // Replace the placeholder label with a more meaningful one
+        $key['publicKey'] = str_replace('phpseclib-generated-key', gethostname(), $key['publickey']);
 
-		return $key;
-	}
+        return $key;
+    }
 
-	/**
-	 * Generates an SSH public/private key pair.
-	 *
-	 * @NoAdminRequired
-	 */
-	public function getSshKeys() {
-		$key = $this->generateSshKeys();
-		return new JSONResponse(
-			array('data' => array(
-				'private_key' => $key['privatekey'],
-				'public_key' => $key['publickey']
-			),
-			'status' => 'success'
-		));
-	}
+    /**
+     * Generates an SSH public/private key pair.
+     *
+     * @NoAdminRequired
+     */
+    public function getSshKeys() {
+        $key = $this->generateSshKeys();
+        return new JSONResponse(
+            array('data' => array(
+                'private_key' => $key['privatekey'],
+                'public_key' => $key['publickey']
+            ),
+            'status' => 'success'
+        ));
+    }
 
-	/**
-	 * @NoAdminRequired
-	 *
-	 * @param string $uid
-	 * @param string $user
-	 * @param string $password
-	 * @return bool
-	 */
-	public function saveGlobalCredentials($uid, $user, $password) {
-		$currentUser = $this->userSession->getUser();
+    /**
+     * @NoAdminRequired
+     *
+     * @param string $uid
+     * @param string $user
+     * @param string $password
+     * @return bool
+     */
+    public function saveGlobalCredentials($uid, $user, $password) {
+        $currentUser = $this->userSession->getUser();
 
-		// Non-admins can only edit their own credentials
-		$allowedToEdit = (
-			$this->groupManager->isAdmin($currentUser->getUID()) || $currentUser->getUID() === $uid
-		) ? true : false;
+        // Non-admins can only edit their own credentials
+        $allowedToEdit = (
+            $this->groupManager->isAdmin($currentUser->getUID()) || $currentUser->getUID() === $uid
+        ) ? true : false;
 
-		if ($allowedToEdit) {
-			$this->globalAuth->saveAuth($uid, $user, $password);
-			return true;
-		} else {
-			return false;
-		}
-	}
+        if ($allowedToEdit) {
+            $this->globalAuth->saveAuth($uid, $user, $password);
+            return true;
+        } else {
+            return false;
+        }
+    }
 }

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.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
+        ]);
+    }
 }

apps/files_external/lib/Command/ListCommand.php

Indentation +210 added lines, -210 removed lines

@@ -37,239 +37,239 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class ListCommand extends Base {
-	/**
-	 * @var GlobalStoragesService
-	 */
-	protected $globalService;
+    /**
+     * @var GlobalStoragesService
+     */
+    protected $globalService;
 
-	/**
-	 * @var UserStoragesService
-	 */
-	protected $userService;
+    /**
+     * @var UserStoragesService
+     */
+    protected $userService;
 
-	/**
-	 * @var IUserSession
-	 */
-	protected $userSession;
+    /**
+     * @var IUserSession
+     */
+    protected $userSession;
 
-	/**
-	 * @var IUserManager
-	 */
-	protected $userManager;
+    /**
+     * @var IUserManager
+     */
+    protected $userManager;
 
-	const ALL = -1;
+    const ALL = -1;
 
-	function __construct(GlobalStoragesService $globalService, UserStoragesService $userService, IUserSession $userSession, IUserManager $userManager) {
-		parent::__construct();
-		$this->globalService = $globalService;
-		$this->userService = $userService;
-		$this->userSession = $userSession;
-		$this->userManager = $userManager;
-	}
+    function __construct(GlobalStoragesService $globalService, UserStoragesService $userService, IUserSession $userSession, IUserManager $userManager) {
+        parent::__construct();
+        $this->globalService = $globalService;
+        $this->userService = $userService;
+        $this->userSession = $userSession;
+        $this->userManager = $userManager;
+    }
 
-	protected function configure() {
-		$this
-			->setName('files_external:list')
-			->setDescription('List configured admin or personal mounts')
-			->addArgument(
-				'user_id',
-				InputArgument::OPTIONAL,
-				'user id to list the personal mounts for, if no user is provided admin mounts will be listed'
-			)->addOption(
-				'show-password',
-				null,
-				InputOption::VALUE_NONE,
-				'show passwords and secrets'
-			)->addOption(
-				'full',
-				null,
-				InputOption::VALUE_NONE,
-				'don\'t truncate long values in table output'
-			)->addOption(
-				'all',
-				'a',
-				InputOption::VALUE_NONE,
-				'show both system wide mounts and all personal mounts'
-			);
-		parent::configure();
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:list')
+            ->setDescription('List configured admin or personal mounts')
+            ->addArgument(
+                'user_id',
+                InputArgument::OPTIONAL,
+                'user id to list the personal mounts for, if no user is provided admin mounts will be listed'
+            )->addOption(
+                'show-password',
+                null,
+                InputOption::VALUE_NONE,
+                'show passwords and secrets'
+            )->addOption(
+                'full',
+                null,
+                InputOption::VALUE_NONE,
+                'don\'t truncate long values in table output'
+            )->addOption(
+                'all',
+                'a',
+                InputOption::VALUE_NONE,
+                'show both system wide mounts and all personal mounts'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		if ($input->getOption('all')) {
-			/** @var  $mounts StorageConfig[] */
-			$mounts = $this->globalService->getStorageForAllUsers();
-			$userId = self::ALL;
-		} else {
-			$userId = $input->getArgument('user_id');
-			$storageService = $this->getStorageService($userId);
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        if ($input->getOption('all')) {
+            /** @var  $mounts StorageConfig[] */
+            $mounts = $this->globalService->getStorageForAllUsers();
+            $userId = self::ALL;
+        } else {
+            $userId = $input->getArgument('user_id');
+            $storageService = $this->getStorageService($userId);
 
-			/** @var  $mounts StorageConfig[] */
-			$mounts = $storageService->getAllStorages();
-		}
+            /** @var  $mounts StorageConfig[] */
+            $mounts = $storageService->getAllStorages();
+        }
 
-		$this->listMounts($userId, $mounts, $input, $output);
-	}
+        $this->listMounts($userId, $mounts, $input, $output);
+    }
 
-	/**
-	 * @param $userId $userId
-	 * @param StorageConfig[] $mounts
-	 * @param InputInterface $input
-	 * @param OutputInterface $output
-	 */
-	public function listMounts($userId, array $mounts, InputInterface $input, OutputInterface $output) {
-		$outputType = $input->getOption('output');
-		if (count($mounts) === 0) {
-			if ($outputType === self::OUTPUT_FORMAT_JSON || $outputType === self::OUTPUT_FORMAT_JSON_PRETTY) {
-				$output->writeln('[]');
-			} else {
-				if ($userId === self::ALL) {
-					$output->writeln("<info>No mounts configured</info>");
-				} else if ($userId) {
-					$output->writeln("<info>No mounts configured by $userId</info>");
-				} else {
-					$output->writeln("<info>No admin mounts configured</info>");
-				}
-			}
-			return;
-		}
+    /**
+     * @param $userId $userId
+     * @param StorageConfig[] $mounts
+     * @param InputInterface $input
+     * @param OutputInterface $output
+     */
+    public function listMounts($userId, array $mounts, InputInterface $input, OutputInterface $output) {
+        $outputType = $input->getOption('output');
+        if (count($mounts) === 0) {
+            if ($outputType === self::OUTPUT_FORMAT_JSON || $outputType === self::OUTPUT_FORMAT_JSON_PRETTY) {
+                $output->writeln('[]');
+            } else {
+                if ($userId === self::ALL) {
+                    $output->writeln("<info>No mounts configured</info>");
+                } else if ($userId) {
+                    $output->writeln("<info>No mounts configured by $userId</info>");
+                } else {
+                    $output->writeln("<info>No admin mounts configured</info>");
+                }
+            }
+            return;
+        }
 
-		$headers = ['Mount ID', 'Mount Point', 'Storage', 'Authentication Type', 'Configuration', 'Options'];
+        $headers = ['Mount ID', 'Mount Point', 'Storage', 'Authentication Type', 'Configuration', 'Options'];
 
-		if (!$userId || $userId === self::ALL) {
-			$headers[] = 'Applicable Users';
-			$headers[] = 'Applicable Groups';
-		}
-		if ($userId === self::ALL) {
-			$headers[] = 'Type';
-		}
+        if (!$userId || $userId === self::ALL) {
+            $headers[] = 'Applicable Users';
+            $headers[] = 'Applicable Groups';
+        }
+        if ($userId === self::ALL) {
+            $headers[] = 'Type';
+        }
 
-		if (!$input->getOption('show-password')) {
-			$hideKeys = ['password', 'refresh_token', 'token', 'client_secret', 'public_key', 'private_key'];
-			foreach ($mounts as $mount) {
-				$config = $mount->getBackendOptions();
-				foreach ($config as $key => $value) {
-					if (in_array($key, $hideKeys)) {
-						$mount->setBackendOption($key, '***');
-					}
-				}
-			}
-		}
+        if (!$input->getOption('show-password')) {
+            $hideKeys = ['password', 'refresh_token', 'token', 'client_secret', 'public_key', 'private_key'];
+            foreach ($mounts as $mount) {
+                $config = $mount->getBackendOptions();
+                foreach ($config as $key => $value) {
+                    if (in_array($key, $hideKeys)) {
+                        $mount->setBackendOption($key, '***');
+                    }
+                }
+            }
+        }
 
-		if ($outputType === self::OUTPUT_FORMAT_JSON || $outputType === self::OUTPUT_FORMAT_JSON_PRETTY) {
-			$keys = array_map(function ($header) {
-				return strtolower(str_replace(' ', '_', $header));
-			}, $headers);
+        if ($outputType === self::OUTPUT_FORMAT_JSON || $outputType === self::OUTPUT_FORMAT_JSON_PRETTY) {
+            $keys = array_map(function ($header) {
+                return strtolower(str_replace(' ', '_', $header));
+            }, $headers);
 
-			$pairs = array_map(function (StorageConfig $config) use ($keys, $userId) {
-				$values = [
-					$config->getId(),
-					$config->getMountPoint(),
-					$config->getBackend()->getStorageClass(),
-					$config->getAuthMechanism()->getIdentifier(),
-					$config->getBackendOptions(),
-					$config->getMountOptions()
-				];
-				if (!$userId || $userId === self::ALL) {
-					$values[] = $config->getApplicableUsers();
-					$values[] = $config->getApplicableGroups();
-				}
-				if ($userId === self::ALL) {
-					$values[] = $config->getType() === StorageConfig::MOUNT_TYPE_ADMIN ? 'admin' : 'personal';
-				}
+            $pairs = array_map(function (StorageConfig $config) use ($keys, $userId) {
+                $values = [
+                    $config->getId(),
+                    $config->getMountPoint(),
+                    $config->getBackend()->getStorageClass(),
+                    $config->getAuthMechanism()->getIdentifier(),
+                    $config->getBackendOptions(),
+                    $config->getMountOptions()
+                ];
+                if (!$userId || $userId === self::ALL) {
+                    $values[] = $config->getApplicableUsers();
+                    $values[] = $config->getApplicableGroups();
+                }
+                if ($userId === self::ALL) {
+                    $values[] = $config->getType() === StorageConfig::MOUNT_TYPE_ADMIN ? 'admin' : 'personal';
+                }
 
-				return array_combine($keys, $values);
-			}, $mounts);
-			if ($outputType === self::OUTPUT_FORMAT_JSON) {
-				$output->writeln(json_encode(array_values($pairs)));
-			} else {
-				$output->writeln(json_encode(array_values($pairs), JSON_PRETTY_PRINT));
-			}
-		} else {
-			$full = $input->getOption('full');
-			$defaultMountOptions = [
-				'encrypt' => true,
-				'previews' => true,
-				'filesystem_check_changes' => 1,
-				'enable_sharing' => false,
-				'encoding_compatibility' => false
-			];
-			$rows = array_map(function (StorageConfig $config) use ($userId, $defaultMountOptions, $full) {
-				$storageConfig = $config->getBackendOptions();
-				$keys = array_keys($storageConfig);
-				$values = array_values($storageConfig);
+                return array_combine($keys, $values);
+            }, $mounts);
+            if ($outputType === self::OUTPUT_FORMAT_JSON) {
+                $output->writeln(json_encode(array_values($pairs)));
+            } else {
+                $output->writeln(json_encode(array_values($pairs), JSON_PRETTY_PRINT));
+            }
+        } else {
+            $full = $input->getOption('full');
+            $defaultMountOptions = [
+                'encrypt' => true,
+                'previews' => true,
+                'filesystem_check_changes' => 1,
+                'enable_sharing' => false,
+                'encoding_compatibility' => false
+            ];
+            $rows = array_map(function (StorageConfig $config) use ($userId, $defaultMountOptions, $full) {
+                $storageConfig = $config->getBackendOptions();
+                $keys = array_keys($storageConfig);
+                $values = array_values($storageConfig);
 
-				if (!$full) {
-					$values = array_map(function ($value) {
-						if (is_string($value) && strlen($value) > 32) {
-							return substr($value, 0, 6) . '...' . substr($value, -6, 6);
-						} else {
-							return $value;
-						}
-					}, $values);
-				}
+                if (!$full) {
+                    $values = array_map(function ($value) {
+                        if (is_string($value) && strlen($value) > 32) {
+                            return substr($value, 0, 6) . '...' . substr($value, -6, 6);
+                        } else {
+                            return $value;
+                        }
+                    }, $values);
+                }
 
-				$configStrings = array_map(function ($key, $value) {
-					return $key . ': ' . json_encode($value);
-				}, $keys, $values);
-				$configString = implode(', ', $configStrings);
+                $configStrings = array_map(function ($key, $value) {
+                    return $key . ': ' . json_encode($value);
+                }, $keys, $values);
+                $configString = implode(', ', $configStrings);
 
-				$mountOptions = $config->getMountOptions();
-				// hide defaults
-				foreach ($mountOptions as $key => $value) {
-					if ($value === $defaultMountOptions[$key]) {
-						unset($mountOptions[$key]);
-					}
-				}
-				$keys = array_keys($mountOptions);
-				$values = array_values($mountOptions);
+                $mountOptions = $config->getMountOptions();
+                // hide defaults
+                foreach ($mountOptions as $key => $value) {
+                    if ($value === $defaultMountOptions[$key]) {
+                        unset($mountOptions[$key]);
+                    }
+                }
+                $keys = array_keys($mountOptions);
+                $values = array_values($mountOptions);
 
-				$optionsStrings = array_map(function ($key, $value) {
-					return $key . ': ' . json_encode($value);
-				}, $keys, $values);
-				$optionsString = implode(', ', $optionsStrings);
+                $optionsStrings = array_map(function ($key, $value) {
+                    return $key . ': ' . json_encode($value);
+                }, $keys, $values);
+                $optionsString = implode(', ', $optionsStrings);
 
-				$values = [
-					$config->getId(),
-					$config->getMountPoint(),
-					$config->getBackend()->getText(),
-					$config->getAuthMechanism()->getText(),
-					$configString,
-					$optionsString
-				];
+                $values = [
+                    $config->getId(),
+                    $config->getMountPoint(),
+                    $config->getBackend()->getText(),
+                    $config->getAuthMechanism()->getText(),
+                    $configString,
+                    $optionsString
+                ];
 
-				if (!$userId || $userId === self::ALL) {
-					$applicableUsers = implode(', ', $config->getApplicableUsers());
-					$applicableGroups = implode(', ', $config->getApplicableGroups());
-					if ($applicableUsers === '' && $applicableGroups === '') {
-						$applicableUsers = 'All';
-					}
-					$values[] = $applicableUsers;
-					$values[] = $applicableGroups;
-				}
-				if ($userId === self::ALL) {
-					$values[] = $config->getType() === StorageConfig::MOUNT_TYPE_ADMIN ? 'Admin' : 'Personal';
-				}
+                if (!$userId || $userId === self::ALL) {
+                    $applicableUsers = implode(', ', $config->getApplicableUsers());
+                    $applicableGroups = implode(', ', $config->getApplicableGroups());
+                    if ($applicableUsers === '' && $applicableGroups === '') {
+                        $applicableUsers = 'All';
+                    }
+                    $values[] = $applicableUsers;
+                    $values[] = $applicableGroups;
+                }
+                if ($userId === self::ALL) {
+                    $values[] = $config->getType() === StorageConfig::MOUNT_TYPE_ADMIN ? 'Admin' : 'Personal';
+                }
 
-				return $values;
-			}, $mounts);
+                return $values;
+            }, $mounts);
 
-			$table = new Table($output);
-			$table->setHeaders($headers);
-			$table->setRows($rows);
-			$table->render();
-		}
-	}
+            $table = new Table($output);
+            $table->setHeaders($headers);
+            $table->setRows($rows);
+            $table->render();
+        }
+    }
 
-	protected function getStorageService($userId) {
-		if (!empty($userId)) {
-			$user = $this->userManager->get($userId);
-			if (is_null($user)) {
-				throw new NoUserException("user $userId not found");
-			}
-			$this->userSession->setUser($user);
-			return $this->userService;
-		} else {
-			return $this->globalService;
-		}
-	}
+    protected function getStorageService($userId) {
+        if (!empty($userId)) {
+            $user = $this->userManager->get($userId);
+            if (is_null($user)) {
+                throw new NoUserException("user $userId not found");
+            }
+            $this->userSession->setUser($user);
+            return $this->userService;
+        } else {
+            return $this->globalService;
+        }
+    }
 }

apps/files_external/lib/Command/Config.php

Indentation +77 added lines, -77 removed lines

@@ -32,87 +32,87 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Config extends Base {
-	/**
-	 * @var GlobalStoragesService
-	 */
-	protected $globalService;
+    /**
+     * @var GlobalStoragesService
+     */
+    protected $globalService;
 
-	function __construct(GlobalStoragesService $globalService) {
-		parent::__construct();
-		$this->globalService = $globalService;
-	}
+    function __construct(GlobalStoragesService $globalService) {
+        parent::__construct();
+        $this->globalService = $globalService;
+    }
 
-	protected function configure() {
-		$this
-			->setName('files_external:config')
-			->setDescription('Manage backend configuration for a mount')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'The id of the mount to edit'
-			)->addArgument(
-				'key',
-				InputArgument::REQUIRED,
-				'key of the config option to set/get'
-			)->addArgument(
-				'value',
-				InputArgument::OPTIONAL,
-				'value to set the config option to, when no value is provided the existing value will be printed'
-			);
-		parent::configure();
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:config')
+            ->setDescription('Manage backend configuration for a mount')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'The id of the mount to edit'
+            )->addArgument(
+                'key',
+                InputArgument::REQUIRED,
+                'key of the config option to set/get'
+            )->addArgument(
+                'value',
+                InputArgument::OPTIONAL,
+                'value to set the config option to, when no value is provided the existing value will be printed'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$mountId = $input->getArgument('mount_id');
-		$key = $input->getArgument('key');
-		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');
+        $key = $input->getArgument('key');
+        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;
+        }
 
-		$value = $input->getArgument('value');
-		if ($value) {
-			$this->setOption($mount, $key, $value, $output);
-		} else {
-			$this->getOption($mount, $key, $output);
-		}
-	}
+        $value = $input->getArgument('value');
+        if ($value) {
+            $this->setOption($mount, $key, $value, $output);
+        } else {
+            $this->getOption($mount, $key, $output);
+        }
+    }
 
-	/**
-	 * @param StorageConfig $mount
-	 * @param string $key
-	 * @param OutputInterface $output
-	 */
-	protected function getOption(StorageConfig $mount, $key, OutputInterface $output) {
-		if ($key === 'mountpoint' || $key === 'mount_point') {
-			$value = $mount->getMountPoint();
-		} else {
-			$value = $mount->getBackendOption($key);
-		}
-		if (!is_string($value)) { // show bools and objects correctly
-			$value = json_encode($value);
-		}
-		$output->writeln($value);
-	}
+    /**
+     * @param StorageConfig $mount
+     * @param string $key
+     * @param OutputInterface $output
+     */
+    protected function getOption(StorageConfig $mount, $key, OutputInterface $output) {
+        if ($key === 'mountpoint' || $key === 'mount_point') {
+            $value = $mount->getMountPoint();
+        } else {
+            $value = $mount->getBackendOption($key);
+        }
+        if (!is_string($value)) { // show bools and objects correctly
+            $value = json_encode($value);
+        }
+        $output->writeln($value);
+    }
 
-	/**
-	 * @param StorageConfig $mount
-	 * @param string $key
-	 * @param string $value
-	 * @param OutputInterface $output
-	 */
-	protected function setOption(StorageConfig $mount, $key, $value, OutputInterface $output) {
-		$decoded = json_decode($value, true);
-		if (!is_null($decoded)) {
-			$value = $decoded;
-		}
-		if ($key === 'mountpoint' || $key === 'mount_point') {
-			$mount->setMountPoint($value);
-		} else {
-			$mount->setBackendOption($key, $value);
-		}
-		$this->globalService->updateStorage($mount);
-	}
+    /**
+     * @param StorageConfig $mount
+     * @param string $key
+     * @param string $value
+     * @param OutputInterface $output
+     */
+    protected function setOption(StorageConfig $mount, $key, $value, OutputInterface $output) {
+        $decoded = json_decode($value, true);
+        if (!is_null($decoded)) {
+            $value = $decoded;
+        }
+        if ($key === 'mountpoint' || $key === 'mount_point') {
+            $mount->setMountPoint($value);
+        } else {
+            $mount->setBackendOption($key, $value);
+        }
+        $this->globalService->updateStorage($mount);
+    }
 }