nextcloud / server

apps/files_external/lib/Service/UserLegacyStoragesService.php

Indentation +22 added lines, -22 removed lines

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

apps/files_external/lib/Service/LegacyStoragesService.php

Indentation +175 added lines, -175 removed lines

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

apps/files_external/lib/Service/UserTrait.php

Indentation +37 added lines, -37 removed lines

@@ -30,46 +30,46 @@
  */
 trait UserTrait {
 
-	/** @var IUserSession */
-	protected $userSession;
+    /** @var IUserSession */
+    protected $userSession;
 
-	/**
-	 * User override
-	 *
-	 * @var IUser|null
-	 */
-	private $user = null;
+    /**
+     * User override
+     *
+     * @var IUser|null
+     */
+    private $user = null;
 
-	/**
-	 * @return IUser|null
-	 */
-	protected function getUser() {
-		if ($this->user) {
-			return $this->user;
-		}
-		return $this->userSession->getUser();
-	}
+    /**
+     * @return IUser|null
+     */
+    protected function getUser() {
+        if ($this->user) {
+            return $this->user;
+        }
+        return $this->userSession->getUser();
+    }
 
-	/**
-	 * Override the user from the session
-	 * Unset with ->resetUser() when finished!
-	 *
-	 * @param IUser
-	 * @return self
-	 */
-	public function setUser(IUser $user) {
-		$this->user = $user;
-		return $this;
-	}
+    /**
+     * Override the user from the session
+     * Unset with ->resetUser() when finished!
+     *
+     * @param IUser
+     * @return self
+     */
+    public function setUser(IUser $user) {
+        $this->user = $user;
+        return $this;
+    }
 
-	/**
-	 * Reset the user override
-	 *
-	 * @return self
-	 */
-	public function resetUser() {
-		$this->user = null;
-		return $this;
-	}
+    /**
+     * Reset the user override
+     *
+     * @return self
+     */
+    public function resetUser() {
+        $this->user = null;
+        return $this;
+    }
 }
 

apps/files_external/lib/Service/UserStoragesService.php

Indentation +91 added lines, -91 removed lines

@@ -40,105 +40,105 @@
  * (aka personal storages)
  */
 class UserStoragesService extends StoragesService {
-	use UserTrait;
+    use UserTrait;
 
-	/**
-	 * Create a user storages service
-	 *
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfig
-	 * @param IUserSession $userSession user session
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(
-		BackendService $backendService,
-		DBConfigService $dbConfig,
-		IUserSession $userSession,
-		IUserMountCache $userMountCache
-	) {
-		$this->userSession = $userSession;
-		parent::__construct($backendService, $dbConfig, $userMountCache);
-	}
+    /**
+     * Create a user storages service
+     *
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfig
+     * @param IUserSession $userSession user session
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(
+        BackendService $backendService,
+        DBConfigService $dbConfig,
+        IUserSession $userSession,
+        IUserMountCache $userMountCache
+    ) {
+        $this->userSession = $userSession;
+        parent::__construct($backendService, $dbConfig, $userMountCache);
+    }
 
-	protected function readDBConfig() {
-		return $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
-	}
+    protected function readDBConfig() {
+        return $this->dbConfig->getUserMountsFor(DBConfigService::APPLICABLE_TYPE_USER, $this->getUser()->getUID());
+    }
 
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	protected function triggerHooks(StorageConfig $storage, $signal) {
-		$user = $this->getUser()->getUID();
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    protected function triggerHooks(StorageConfig $storage, $signal) {
+        $user = $this->getUser()->getUID();
 
-		// trigger hook for the current user
-		$this->triggerApplicableHooks(
-			$signal,
-			$storage->getMountPoint(),
-			\OC_Mount_Config::MOUNT_TYPE_USER,
-			[$user]
-		);
-	}
+        // trigger hook for the current user
+        $this->triggerApplicableHooks(
+            $signal,
+            $storage->getMountPoint(),
+            \OC_Mount_Config::MOUNT_TYPE_USER,
+            [$user]
+        );
+    }
 
-	/**
-	 * Triggers signal_create_mount or signal_delete_mount to
-	 * accommodate for additions/deletions in applicableUsers
-	 * and applicableGroups fields.
-	 *
-	 * @param StorageConfig $oldStorage old storage data
-	 * @param StorageConfig $newStorage new storage data
-	 */
-	protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
-		// if mount point changed, it's like a deletion + creation
-		if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
-			$this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
-			$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-		}
-	}
+    /**
+     * Triggers signal_create_mount or signal_delete_mount to
+     * accommodate for additions/deletions in applicableUsers
+     * and applicableGroups fields.
+     *
+     * @param StorageConfig $oldStorage old storage data
+     * @param StorageConfig $newStorage new storage data
+     */
+    protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage) {
+        // if mount point changed, it's like a deletion + creation
+        if ($oldStorage->getMountPoint() !== $newStorage->getMountPoint()) {
+            $this->triggerHooks($oldStorage, Filesystem::signal_delete_mount);
+            $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+        }
+    }
 
-	protected function getType() {
-		return DBConfigService::MOUNT_TYPE_PERSONAl;
-	}
+    protected function getType() {
+        return DBConfigService::MOUNT_TYPE_PERSONAl;
+    }
 
-	/**
-	 * Add new storage to the configuration
-	 *
-	 * @param StorageConfig $newStorage storage attributes
-	 *
-	 * @return StorageConfig storage config, with added id
-	 */
-	public function addStorage(StorageConfig $newStorage) {
-		$newStorage->setApplicableUsers([$this->getUser()->getUID()]);
-		$config = parent::addStorage($newStorage);
-		return $config;
-	}
+    /**
+     * Add new storage to the configuration
+     *
+     * @param StorageConfig $newStorage storage attributes
+     *
+     * @return StorageConfig storage config, with added id
+     */
+    public function addStorage(StorageConfig $newStorage) {
+        $newStorage->setApplicableUsers([$this->getUser()->getUID()]);
+        $config = parent::addStorage($newStorage);
+        return $config;
+    }
 
-	/**
-	 * Update storage to the configuration
-	 *
-	 * @param StorageConfig $updatedStorage storage attributes
-	 *
-	 * @return StorageConfig storage config
-	 * @throws NotFoundException if the given storage does not exist in the config
-	 */
-	public function updateStorage(StorageConfig $updatedStorage) {
-		$updatedStorage->setApplicableUsers([$this->getUser()->getUID()]);
-		return parent::updateStorage($updatedStorage);
-	}
+    /**
+     * Update storage to the configuration
+     *
+     * @param StorageConfig $updatedStorage storage attributes
+     *
+     * @return StorageConfig storage config
+     * @throws NotFoundException if the given storage does not exist in the config
+     */
+    public function updateStorage(StorageConfig $updatedStorage) {
+        $updatedStorage->setApplicableUsers([$this->getUser()->getUID()]);
+        return parent::updateStorage($updatedStorage);
+    }
 
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	public function getVisibilityType() {
-		return BackendService::VISIBILITY_PERSONAL;
-	}
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    public function getVisibilityType() {
+        return BackendService::VISIBILITY_PERSONAL;
+    }
 
-	protected function isApplicable(StorageConfig $config) {
-		return ($config->getApplicableUsers() === [$this->getUser()->getUID()]) && $config->getType() === StorageConfig::MOUNT_TYPE_PERSONAl;
-	}
+    protected function isApplicable(StorageConfig $config) {
+        return ($config->getApplicableUsers() === [$this->getUser()->getUID()]) && $config->getType() === StorageConfig::MOUNT_TYPE_PERSONAl;
+    }
 }

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/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/Verify.php

Indentation +94 added lines, -94 removed lines

@@ -37,108 +37,108 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Verify 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:verify')
-			->setDescription('Verify mount configuration')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'The id of the mount to check'
-			)->addOption(
-				'config',
-				'c',
-				InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
-				'Additional config option to set before checking in key=value pairs, required for certain auth backends such as login credentails'
-			);
-		parent::configure();
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:verify')
+            ->setDescription('Verify mount configuration')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'The id of the mount to check'
+            )->addOption(
+                'config',
+                'c',
+                InputOption::VALUE_REQUIRED | InputOption::VALUE_IS_ARRAY,
+                'Additional config option to set before checking in key=value pairs, required for certain auth backends such as login credentails'
+            );
+        parent::configure();
+    }
 
-	protected function execute(InputInterface $input, OutputInterface $output) {
-		$mountId = $input->getArgument('mount_id');
-		$configInput = $input->getOption('config');
+    protected function execute(InputInterface $input, OutputInterface $output) {
+        $mountId = $input->getArgument('mount_id');
+        $configInput = $input->getOption('config');
 
-		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;
-		}
+        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;
+        }
 
-		$this->updateStorageStatus($mount, $configInput, $output);
+        $this->updateStorageStatus($mount, $configInput, $output);
 
-		$this->writeArrayInOutputFormat($input, $output, [
-			'status' => StorageNotAvailableException::getStateCodeName($mount->getStatus()),
-			'code' => $mount->getStatus(),
-			'message' => $mount->getStatusMessage()
-		]);
-	}
+        $this->writeArrayInOutputFormat($input, $output, [
+            'status' => StorageNotAvailableException::getStateCodeName($mount->getStatus()),
+            'code' => $mount->getStatus(),
+            'message' => $mount->getStatusMessage()
+        ]);
+    }
 
-	private function manipulateStorageConfig(StorageConfig $storage) {
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		$authMechanism->manipulateStorageConfig($storage);
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		$backend->manipulateStorageConfig($storage);
-	}
+    private function manipulateStorageConfig(StorageConfig $storage) {
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        $authMechanism->manipulateStorageConfig($storage);
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        $backend->manipulateStorageConfig($storage);
+    }
 
-	private function updateStorageStatus(StorageConfig &$storage, $configInput, OutputInterface $output) {
-		try {
-			try {
-				$this->manipulateStorageConfig($storage);
-			} catch (InsufficientDataForMeaningfulAnswerException $e) {
-				if (count($configInput) === 0) { // extra config options might solve the error
-					throw $e;
-				}
-			}
+    private function updateStorageStatus(StorageConfig &$storage, $configInput, OutputInterface $output) {
+        try {
+            try {
+                $this->manipulateStorageConfig($storage);
+            } catch (InsufficientDataForMeaningfulAnswerException $e) {
+                if (count($configInput) === 0) { // extra config options might solve the error
+                    throw $e;
+                }
+            }
 
-			foreach ($configInput as $configOption) {
-				if (!strpos($configOption, '=')) {
-					$output->writeln('<error>Invalid mount configuration option "' . $configOption . '"</error>');
-					return;
-				}
-				list($key, $value) = explode('=', $configOption, 2);
-				$storage->setBackendOption($key, $value);
-			}
+            foreach ($configInput as $configOption) {
+                if (!strpos($configOption, '=')) {
+                    $output->writeln('<error>Invalid mount configuration option "' . $configOption . '"</error>');
+                    return;
+                }
+                list($key, $value) = explode('=', $configOption, 2);
+                $storage->setBackendOption($key, $value);
+            }
 
-			/** @var Backend */
-			$backend = $storage->getBackend();
-			// update status (can be time-consuming)
-			$storage->setStatus(
-				\OC_Mount_Config::getBackendStatus(
-					$backend->getStorageClass(),
-					$storage->getBackendOptions(),
-					false
-				)
-			);
-		} catch (InsufficientDataForMeaningfulAnswerException $e) {
-			$status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
-			$storage->setStatus(
-				$status,
-				$e->getMessage()
-			);
-		} catch (StorageNotAvailableException $e) {
-			$storage->setStatus(
-				$e->getCode(),
-				$e->getMessage()
-			);
-		} catch (\Exception $e) {
-			// FIXME: convert storage exceptions to StorageNotAvailableException
-			$storage->setStatus(
-				StorageNotAvailableException::STATUS_ERROR,
-				get_class($e) . ': ' . $e->getMessage()
-			);
-		}
-	}
+            /** @var Backend */
+            $backend = $storage->getBackend();
+            // update status (can be time-consuming)
+            $storage->setStatus(
+                \OC_Mount_Config::getBackendStatus(
+                    $backend->getStorageClass(),
+                    $storage->getBackendOptions(),
+                    false
+                )
+            );
+        } catch (InsufficientDataForMeaningfulAnswerException $e) {
+            $status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
+            $storage->setStatus(
+                $status,
+                $e->getMessage()
+            );
+        } catch (StorageNotAvailableException $e) {
+            $storage->setStatus(
+                $e->getCode(),
+                $e->getMessage()
+            );
+        } catch (\Exception $e) {
+            // FIXME: convert storage exceptions to StorageNotAvailableException
+            $storage->setStatus(
+                StorageNotAvailableException::STATUS_ERROR,
+                get_class($e) . ': ' . $e->getMessage()
+            );
+        }
+    }
 }

apps/files_external/lib/Command/Option.php

Indentation +44 added lines, -44 removed lines

@@ -28,50 +28,50 @@
 use Symfony\Component\Console\Output\OutputInterface;
 
 class Option extends Config {
-	protected function configure() {
-		$this
-			->setName('files_external:option')
-			->setDescription('Manage mount options for a mount')
-			->addArgument(
-				'mount_id',
-				InputArgument::REQUIRED,
-				'The id of the mount to edit'
-			)->addArgument(
-				'key',
-				InputArgument::REQUIRED,
-				'key of the mount option to set/get'
-			)->addArgument(
-				'value',
-				InputArgument::OPTIONAL,
-				'value to set the mount option to, when no value is provided the existing value will be printed'
-			);
-	}
+    protected function configure() {
+        $this
+            ->setName('files_external:option')
+            ->setDescription('Manage mount options for a mount')
+            ->addArgument(
+                'mount_id',
+                InputArgument::REQUIRED,
+                'The id of the mount to edit'
+            )->addArgument(
+                'key',
+                InputArgument::REQUIRED,
+                'key of the mount option to set/get'
+            )->addArgument(
+                'value',
+                InputArgument::OPTIONAL,
+                'value to set the mount option to, when no value is provided the existing value will be printed'
+            );
+    }
 
-	/**
-	 * @param StorageConfig $mount
-	 * @param string $key
-	 * @param OutputInterface $output
-	 */
-	protected function getOption(StorageConfig $mount, $key, OutputInterface $output) {
-		$value = $mount->getMountOption($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) {
+        $value = $mount->getMountOption($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;
-		}
-		$mount->setMountOption($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;
+        }
+        $mount->setMountOption($key, $value);
+        $this->globalService->updateStorage($mount);
+    }
 }