nextcloud / server

apps/updatenotification/lib/Notification/Notifier.php

Indentation +137 added lines, -137 removed lines

@@ -36,141 +36,141 @@
 
 class Notifier implements INotifier {
 
-	/** @var IURLGenerator */
-	protected $url;
-
-	/** @var IConfig */
-	protected $config;
-
-	/** @var IManager */
-	protected $notificationManager;
-
-	/** @var IFactory */
-	protected $l10NFactory;
-
-	/** @var IUserSession */
-	protected $userSession;
-
-	/** @var IGroupManager */
-	protected $groupManager;
-
-	/** @var string[] */
-	protected $appVersions;
-
-	/**
-	 * Notifier constructor.
-	 *
-	 * @param IURLGenerator $url
-	 * @param IConfig $config
-	 * @param IManager $notificationManager
-	 * @param IFactory $l10NFactory
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(IURLGenerator $url, IConfig $config, IManager $notificationManager, IFactory $l10NFactory, IUserSession $userSession, IGroupManager $groupManager) {
-		$this->url = $url;
-		$this->notificationManager = $notificationManager;
-		$this->config = $config;
-		$this->l10NFactory = $l10NFactory;
-		$this->userSession = $userSession;
-		$this->groupManager = $groupManager;
-		$this->appVersions = $this->getAppVersions();
-	}
-
-	/**
-	 * @param INotification $notification
-	 * @param string $languageCode The code of the language that should be used to prepare the notification
-	 * @return INotification
-	 * @throws \InvalidArgumentException When the notification was not prepared by a notifier
-	 * @since 9.0.0
-	 */
-	public function prepare(INotification $notification, $languageCode) {
-		if ($notification->getApp() !== 'updatenotification') {
-			throw new \InvalidArgumentException();
-		}
-
-		$l = $this->l10NFactory->get('updatenotification', $languageCode);
-		if ($notification->getSubject() === 'connection_error') {
-			$errors = (int) $this->config->getAppValue('updatenotification', 'update_check_errors', 0);
-			if ($errors === 0) {
-				$this->notificationManager->markProcessed($notification);
-				throw new \InvalidArgumentException();
-			}
-
-			$notification->setParsedSubject($l->t('The update server could not be reached since %d days to check for new updates.', [$errors]))
-				->setParsedMessage($l->t('Please check the Nextcloud and server log files for errors.'));
-		} elseif ($notification->getObjectType() === 'core') {
-			$this->updateAlreadyInstalledCheck($notification, $this->getCoreVersions());
-
-			$parameters = $notification->getSubjectParameters();
-			$notification->setParsedSubject($l->t('Update to %1$s is available.', [$parameters['version']]));
-
-			if ($this->isAdmin()) {
-				$notification->setLink($this->url->linkToRouteAbsolute('settings.AdminSettings.index') . '#updater');
-			}
-		} else {
-			$appInfo = $this->getAppInfo($notification->getObjectType());
-			$appName = ($appInfo === null) ? $notification->getObjectType() : $appInfo['name'];
-
-			if (isset($this->appVersions[$notification->getObjectType()])) {
-				$this->updateAlreadyInstalledCheck($notification, $this->appVersions[$notification->getObjectType()]);
-			}
-
-			$notification->setParsedSubject($l->t('Update for %1$s to version %2$s is available.', [$appName, $notification->getObjectId()]))
-				->setRichSubject($l->t('Update for {app} to version %s is available.', $notification->getObjectId()), [
-					'app' => [
-						'type' => 'app',
-						'id' => $notification->getObjectType(),
-						'name' => $appName,
-					]
-				]);
-
-			if ($this->isAdmin()) {
-				$notification->setLink($this->url->linkToRouteAbsolute('settings.AppSettings.viewApps') . '#app-' . $notification->getObjectType());
-			}
-		}
-
-		$notification->setIcon($this->url->getAbsoluteURL($this->url->imagePath('updatenotification', 'notification.svg')));
-
-		return $notification;
-	}
-
-	/**
-	 * Remove the notification and prevent rendering, when the update is installed
-	 *
-	 * @param INotification $notification
-	 * @param string $installedVersion
-	 * @throws \InvalidArgumentException When the update is already installed
-	 */
-	protected function updateAlreadyInstalledCheck(INotification $notification, $installedVersion) {
-		if (version_compare($notification->getObjectId(), $installedVersion, '<=')) {
-			$this->notificationManager->markProcessed($notification);
-			throw new \InvalidArgumentException();
-		}
-	}
-
-	/**
-	 * @return bool
-	 */
-	protected function isAdmin() {
-		$user = $this->userSession->getUser();
-
-		if ($user instanceof IUser) {
-			return $this->groupManager->isAdmin($user->getUID());
-		}
-
-		return false;
-	}
-
-	protected function getCoreVersions() {
-		return implode('.', \OCP\Util::getVersion());
-	}
-
-	protected function getAppVersions() {
-		return \OC_App::getAppVersions();
-	}
-
-	protected function getAppInfo($appId) {
-		return \OC_App::getAppInfo($appId);
-	}
+    /** @var IURLGenerator */
+    protected $url;
+
+    /** @var IConfig */
+    protected $config;
+
+    /** @var IManager */
+    protected $notificationManager;
+
+    /** @var IFactory */
+    protected $l10NFactory;
+
+    /** @var IUserSession */
+    protected $userSession;
+
+    /** @var IGroupManager */
+    protected $groupManager;
+
+    /** @var string[] */
+    protected $appVersions;
+
+    /**
+     * Notifier constructor.
+     *
+     * @param IURLGenerator $url
+     * @param IConfig $config
+     * @param IManager $notificationManager
+     * @param IFactory $l10NFactory
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(IURLGenerator $url, IConfig $config, IManager $notificationManager, IFactory $l10NFactory, IUserSession $userSession, IGroupManager $groupManager) {
+        $this->url = $url;
+        $this->notificationManager = $notificationManager;
+        $this->config = $config;
+        $this->l10NFactory = $l10NFactory;
+        $this->userSession = $userSession;
+        $this->groupManager = $groupManager;
+        $this->appVersions = $this->getAppVersions();
+    }
+
+    /**
+     * @param INotification $notification
+     * @param string $languageCode The code of the language that should be used to prepare the notification
+     * @return INotification
+     * @throws \InvalidArgumentException When the notification was not prepared by a notifier
+     * @since 9.0.0
+     */
+    public function prepare(INotification $notification, $languageCode) {
+        if ($notification->getApp() !== 'updatenotification') {
+            throw new \InvalidArgumentException();
+        }
+
+        $l = $this->l10NFactory->get('updatenotification', $languageCode);
+        if ($notification->getSubject() === 'connection_error') {
+            $errors = (int) $this->config->getAppValue('updatenotification', 'update_check_errors', 0);
+            if ($errors === 0) {
+                $this->notificationManager->markProcessed($notification);
+                throw new \InvalidArgumentException();
+            }
+
+            $notification->setParsedSubject($l->t('The update server could not be reached since %d days to check for new updates.', [$errors]))
+                ->setParsedMessage($l->t('Please check the Nextcloud and server log files for errors.'));
+        } elseif ($notification->getObjectType() === 'core') {
+            $this->updateAlreadyInstalledCheck($notification, $this->getCoreVersions());
+
+            $parameters = $notification->getSubjectParameters();
+            $notification->setParsedSubject($l->t('Update to %1$s is available.', [$parameters['version']]));
+
+            if ($this->isAdmin()) {
+                $notification->setLink($this->url->linkToRouteAbsolute('settings.AdminSettings.index') . '#updater');
+            }
+        } else {
+            $appInfo = $this->getAppInfo($notification->getObjectType());
+            $appName = ($appInfo === null) ? $notification->getObjectType() : $appInfo['name'];
+
+            if (isset($this->appVersions[$notification->getObjectType()])) {
+                $this->updateAlreadyInstalledCheck($notification, $this->appVersions[$notification->getObjectType()]);
+            }
+
+            $notification->setParsedSubject($l->t('Update for %1$s to version %2$s is available.', [$appName, $notification->getObjectId()]))
+                ->setRichSubject($l->t('Update for {app} to version %s is available.', $notification->getObjectId()), [
+                    'app' => [
+                        'type' => 'app',
+                        'id' => $notification->getObjectType(),
+                        'name' => $appName,
+                    ]
+                ]);
+
+            if ($this->isAdmin()) {
+                $notification->setLink($this->url->linkToRouteAbsolute('settings.AppSettings.viewApps') . '#app-' . $notification->getObjectType());
+            }
+        }
+
+        $notification->setIcon($this->url->getAbsoluteURL($this->url->imagePath('updatenotification', 'notification.svg')));
+
+        return $notification;
+    }
+
+    /**
+     * Remove the notification and prevent rendering, when the update is installed
+     *
+     * @param INotification $notification
+     * @param string $installedVersion
+     * @throws \InvalidArgumentException When the update is already installed
+     */
+    protected function updateAlreadyInstalledCheck(INotification $notification, $installedVersion) {
+        if (version_compare($notification->getObjectId(), $installedVersion, '<=')) {
+            $this->notificationManager->markProcessed($notification);
+            throw new \InvalidArgumentException();
+        }
+    }
+
+    /**
+     * @return bool
+     */
+    protected function isAdmin() {
+        $user = $this->userSession->getUser();
+
+        if ($user instanceof IUser) {
+            return $this->groupManager->isAdmin($user->getUID());
+        }
+
+        return false;
+    }
+
+    protected function getCoreVersions() {
+        return implode('.', \OCP\Util::getVersion());
+    }
+
+    protected function getAppVersions() {
+        return \OC_App::getAppVersions();
+    }
+
+    protected function getAppInfo($appId) {
+        return \OC_App::getAppInfo($appId);
+    }
 }

apps/files_external/lib/Service/StoragesService.php

Indentation +486 added lines, -486 removed lines

@@ -41,490 +41,490 @@
  */
 abstract class StoragesService {
 
-	/** @var BackendService */
-	protected $backendService;
-
-	/**
-	 * @var DBConfigService
-	 */
-	protected $dbConfig;
-
-	/**
-	 * @var IUserMountCache
-	 */
-	protected $userMountCache;
-
-	/**
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfigService
-	 * @param IUserMountCache $userMountCache
-	 */
-	public function __construct(BackendService $backendService, DBConfigService $dbConfigService, IUserMountCache $userMountCache) {
-		$this->backendService = $backendService;
-		$this->dbConfig = $dbConfigService;
-		$this->userMountCache = $userMountCache;
-	}
-
-	protected function readDBConfig() {
-		return $this->dbConfig->getAdminMounts();
-	}
-
-	protected function getStorageConfigFromDBMount(array $mount) {
-		$applicableUsers = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
-		});
-		$applicableUsers = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableUsers);
-
-		$applicableGroups = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
-		});
-		$applicableGroups = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableGroups);
-
-		try {
-			$config = $this->createStorage(
-				$mount['mount_point'],
-				$mount['storage_backend'],
-				$mount['auth_backend'],
-				$mount['config'],
-				$mount['options'],
-				array_values($applicableUsers),
-				array_values($applicableGroups),
-				$mount['priority']
-			);
-			$config->setType($mount['type']);
-			$config->setId((int)$mount['mount_id']);
-			return $config;
-		} 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
-			);
-			return null;
-		} catch (\InvalidArgumentException $e) {
-			\OCP\Util::writeLog(
-				'files_external',
-				'Could not load storage: "' . $e->getMessage() . '"',
-				\OCP\Util::ERROR
-			);
-			return null;
-		}
-	}
-
-	/**
-	 * Read the external storages config
-	 *
-	 * @return array map of storage id to storage config
-	 */
-	protected function readConfig() {
-		$mounts = $this->readDBConfig();
-		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
-			return $config instanceof StorageConfig;
-		});
-
-		$keys = array_map(function (StorageConfig $config) {
-			return $config->getId();
-		}, $configs);
-
-		return array_combine($keys, $configs);
-	}
-
-	/**
-	 * Get a storage with status
-	 *
-	 * @param int $id storage id
-	 *
-	 * @return StorageConfig
-	 * @throws NotFoundException if the storage with the given id was not found
-	 */
-	public function getStorage($id) {
-		$mount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($mount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$config = $this->getStorageConfigFromDBMount($mount);
-		if ($this->isApplicable($config)) {
-			return $config;
-		} else {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-	}
-
-	/**
-	 * Check whether this storage service should provide access to a storage
-	 *
-	 * @param StorageConfig $config
-	 * @return bool
-	 */
-	abstract protected function isApplicable(StorageConfig $config);
-
-	/**
-	 * Gets all storages, valid or not
-	 *
-	 * @return StorageConfig[] array of storage configs
-	 */
-	public function getAllStorages() {
-		return $this->readConfig();
-	}
-
-	/**
-	 * Gets all valid storages
-	 *
-	 * @return StorageConfig[]
-	 */
-	public function getStorages() {
-		return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
-	}
-
-	/**
-	 * Validate storage
-	 * FIXME: De-duplicate with StoragesController::validate()
-	 *
-	 * @param StorageConfig $storage
-	 * @return bool
-	 */
-	protected function validateStorage(StorageConfig $storage) {
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-
-		if (!$backend->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use backend
-			return false;
-		}
-		if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use auth mechanism
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return string BackendService::VISIBILITY_* constants
-	 */
-	abstract public function getVisibilityType();
-
-	/**
-	 * @return integer
-	 */
-	protected function getType() {
-		return DBConfigService::MOUNT_TYPE_ADMIN;
-	}
-
-	/**
-	 * Add new storage to the configuration
-	 *
-	 * @param StorageConfig $newStorage storage attributes
-	 *
-	 * @return StorageConfig storage config, with added id
-	 */
-	public function addStorage(StorageConfig $newStorage) {
-		$allStorages = $this->readConfig();
-
-		$configId = $this->dbConfig->addMount(
-			$newStorage->getMountPoint(),
-			$newStorage->getBackend()->getIdentifier(),
-			$newStorage->getAuthMechanism()->getIdentifier(),
-			$newStorage->getPriority(),
-			$this->getType()
-		);
-
-		$newStorage->setId($configId);
-
-		foreach ($newStorage->getApplicableUsers() as $user) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($newStorage->getApplicableGroups() as $group) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($newStorage->getBackendOptions() as $key => $value) {
-			$this->dbConfig->setConfig($configId, $key, $value);
-		}
-		foreach ($newStorage->getMountOptions() as $key => $value) {
-			$this->dbConfig->setOption($configId, $key, $value);
-		}
-
-		if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		// add new storage
-		$allStorages[$configId] = $newStorage;
-
-		$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-
-		$newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
-		return $newStorage;
-	}
-
-	/**
-	 * Create a storage from its parameters
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backendIdentifier backend identifier
-	 * @param string $authMechanismIdentifier authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array|null $mountOptions mount-specific options
-	 * @param array|null $applicableUsers users for which to mount the storage
-	 * @param array|null $applicableGroups groups for which to mount the storage
-	 * @param int|null $priority priority
-	 *
-	 * @return StorageConfig
-	 */
-	public function createStorage(
-		$mountPoint,
-		$backendIdentifier,
-		$authMechanismIdentifier,
-		$backendOptions,
-		$mountOptions = null,
-		$applicableUsers = null,
-		$applicableGroups = null,
-		$priority = null
-	) {
-		$backend = $this->backendService->getBackend($backendIdentifier);
-		if (!$backend) {
-			throw new \InvalidArgumentException('Unable to get backend for ' . $backendIdentifier);
-		}
-		$authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
-		if (!$authMechanism) {
-			throw new \InvalidArgumentException('Unable to get authentication mechanism for ' . $authMechanismIdentifier);
-		}
-		$newStorage = new StorageConfig();
-		$newStorage->setMountPoint($mountPoint);
-		$newStorage->setBackend($backend);
-		$newStorage->setAuthMechanism($authMechanism);
-		$newStorage->setBackendOptions($backendOptions);
-		if (isset($mountOptions)) {
-			$newStorage->setMountOptions($mountOptions);
-		}
-		if (isset($applicableUsers)) {
-			$newStorage->setApplicableUsers($applicableUsers);
-		}
-		if (isset($applicableGroups)) {
-			$newStorage->setApplicableGroups($applicableGroups);
-		}
-		if (isset($priority)) {
-			$newStorage->setPriority($priority);
-		}
-
-		return $newStorage;
-	}
-
-	/**
-	 * Triggers the given hook signal for all the applicables given
-	 *
-	 * @param string $signal signal
-	 * @param string $mountPoint hook mount pount param
-	 * @param string $mountType hook mount type param
-	 * @param array $applicableArray array of applicable users/groups for which to trigger the hook
-	 */
-	protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray) {
-		foreach ($applicableArray as $applicable) {
-			\OCP\Util::emitHook(
-				Filesystem::CLASSNAME,
-				$signal,
-				[
-					Filesystem::signal_param_path => $mountPoint,
-					Filesystem::signal_param_mount_type => $mountType,
-					Filesystem::signal_param_users => $applicable,
-				]
-			);
-		}
-	}
-
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	abstract protected function triggerHooks(StorageConfig $storage, $signal);
-
-	/**
-	 * 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
-	 */
-	abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
-
-	/**
-	 * 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) {
-		$id = $updatedStorage->getId();
-
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
-		}
-
-		$oldStorage = $this->getStorageConfigFromDBMount($existingMount);
-
-		$removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
-		$removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
-		$addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
-		$addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
-
-		$oldUserCount = count($oldStorage->getApplicableUsers());
-		$oldGroupCount = count($oldStorage->getApplicableGroups());
-		$newUserCount = count($updatedStorage->getApplicableUsers());
-		$newGroupCount = count($updatedStorage->getApplicableGroups());
-		$wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
-		$isGlobal = ($newUserCount + $newGroupCount) === 0;
-
-		foreach ($removedUsers as $user) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($removedGroups as $group) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($addedUsers as $user) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($addedGroups as $group) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-
-		if ($wasGlobal && !$isGlobal) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		} else if (!$wasGlobal && $isGlobal) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		$changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
-		$changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
-
-		foreach ($changedConfig as $key => $value) {
-			$this->dbConfig->setConfig($id, $key, $value);
-		}
-		foreach ($changedOptions as $key => $value) {
-			$this->dbConfig->setOption($id, $key, $value);
-		}
-
-		if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
-			$this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
-		}
-
-		if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
-			$this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
-		}
-
-		$this->triggerChangeHooks($oldStorage, $updatedStorage);
-
-		if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
-			$this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
-		} else {
-			$storageId = $this->getStorageId($updatedStorage);
-			foreach ($removedUsers as $userId) {
-				$this->userMountCache->removeUserStorageMount($storageId, $userId);
-			}
-		}
-
-		return $this->getStorage($id);
-	}
-
-	/**
-	 * Delete the storage with the given id.
-	 *
-	 * @param int $id storage id
-	 *
-	 * @throws NotFoundException if no storage was found with the given id
-	 */
-	public function removeStorage($id) {
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$this->dbConfig->removeMount($id);
-
-		$deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
-		$this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
-
-		// delete oc_storages entries and oc_filecache
-		try {
-			$rustyStorageId = $this->getRustyStorageIdFromConfig($deletedStorage);
-			\OC\Files\Cache\Storage::remove($rustyStorageId);
-		} catch (\Exception $e) {
-			// can happen either for invalid configs where the storage could not
-			// be instantiated or whenever $user vars where used, in which case
-			// the storage id could not be computed
-			\OCP\Util::writeLog(
-				'files_external',
-				'Exception: "' . $e->getMessage() . '"',
-				\OCP\Util::ERROR
-			);
-		}
-	}
-
-	/**
-	 * Returns the rusty storage id from oc_storages from the given storage config.
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return string rusty storage id
-	 */
-	private function getRustyStorageIdFromConfig(StorageConfig $storageConfig) {
-		// if any of the storage options contains $user, it is not possible
-		// to compute the possible storage id as we don't know which users
-		// mounted it already (and we certainly don't want to iterate over ALL users)
-		foreach ($storageConfig->getBackendOptions() as $value) {
-			if (strpos($value, '$user') !== false) {
-				throw new \Exception('Cannot compute storage id for deletion due to $user vars in the configuration');
-			}
-		}
-
-		// note: similar to ConfigAdapter->prepateStorageConfig()
-		$storageConfig->getAuthMechanism()->manipulateStorageConfig($storageConfig);
-		$storageConfig->getBackend()->manipulateStorageConfig($storageConfig);
-
-		$class = $storageConfig->getBackend()->getStorageClass();
-		$storageImpl = new $class($storageConfig->getBackendOptions());
-
-		return $storageImpl->getId();
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return int
-	 */
-	private function getStorageId(StorageConfig $storageConfig) {
-		try {
-			$class = $storageConfig->getBackend()->getStorageClass();
-			/** @var \OC\Files\Storage\Storage $storage */
-			$storage = new $class($storageConfig->getBackendOptions());
-
-			// auth mechanism should fire first
-			$storage = $storageConfig->getBackend()->wrapStorage($storage);
-			$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-			return $storage->getStorageCache()->getNumericId();
-		} catch (\Exception $e) {
-			return -1;
-		}
-	}
+    /** @var BackendService */
+    protected $backendService;
+
+    /**
+     * @var DBConfigService
+     */
+    protected $dbConfig;
+
+    /**
+     * @var IUserMountCache
+     */
+    protected $userMountCache;
+
+    /**
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfigService
+     * @param IUserMountCache $userMountCache
+     */
+    public function __construct(BackendService $backendService, DBConfigService $dbConfigService, IUserMountCache $userMountCache) {
+        $this->backendService = $backendService;
+        $this->dbConfig = $dbConfigService;
+        $this->userMountCache = $userMountCache;
+    }
+
+    protected function readDBConfig() {
+        return $this->dbConfig->getAdminMounts();
+    }
+
+    protected function getStorageConfigFromDBMount(array $mount) {
+        $applicableUsers = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
+        });
+        $applicableUsers = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableUsers);
+
+        $applicableGroups = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
+        });
+        $applicableGroups = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableGroups);
+
+        try {
+            $config = $this->createStorage(
+                $mount['mount_point'],
+                $mount['storage_backend'],
+                $mount['auth_backend'],
+                $mount['config'],
+                $mount['options'],
+                array_values($applicableUsers),
+                array_values($applicableGroups),
+                $mount['priority']
+            );
+            $config->setType($mount['type']);
+            $config->setId((int)$mount['mount_id']);
+            return $config;
+        } 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
+            );
+            return null;
+        } catch (\InvalidArgumentException $e) {
+            \OCP\Util::writeLog(
+                'files_external',
+                'Could not load storage: "' . $e->getMessage() . '"',
+                \OCP\Util::ERROR
+            );
+            return null;
+        }
+    }
+
+    /**
+     * Read the external storages config
+     *
+     * @return array map of storage id to storage config
+     */
+    protected function readConfig() {
+        $mounts = $this->readDBConfig();
+        $configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
+        $configs = array_filter($configs, function ($config) {
+            return $config instanceof StorageConfig;
+        });
+
+        $keys = array_map(function (StorageConfig $config) {
+            return $config->getId();
+        }, $configs);
+
+        return array_combine($keys, $configs);
+    }
+
+    /**
+     * Get a storage with status
+     *
+     * @param int $id storage id
+     *
+     * @return StorageConfig
+     * @throws NotFoundException if the storage with the given id was not found
+     */
+    public function getStorage($id) {
+        $mount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($mount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $config = $this->getStorageConfigFromDBMount($mount);
+        if ($this->isApplicable($config)) {
+            return $config;
+        } else {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+    }
+
+    /**
+     * Check whether this storage service should provide access to a storage
+     *
+     * @param StorageConfig $config
+     * @return bool
+     */
+    abstract protected function isApplicable(StorageConfig $config);
+
+    /**
+     * Gets all storages, valid or not
+     *
+     * @return StorageConfig[] array of storage configs
+     */
+    public function getAllStorages() {
+        return $this->readConfig();
+    }
+
+    /**
+     * Gets all valid storages
+     *
+     * @return StorageConfig[]
+     */
+    public function getStorages() {
+        return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
+    }
+
+    /**
+     * Validate storage
+     * FIXME: De-duplicate with StoragesController::validate()
+     *
+     * @param StorageConfig $storage
+     * @return bool
+     */
+    protected function validateStorage(StorageConfig $storage) {
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+
+        if (!$backend->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use backend
+            return false;
+        }
+        if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use auth mechanism
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return string BackendService::VISIBILITY_* constants
+     */
+    abstract public function getVisibilityType();
+
+    /**
+     * @return integer
+     */
+    protected function getType() {
+        return DBConfigService::MOUNT_TYPE_ADMIN;
+    }
+
+    /**
+     * Add new storage to the configuration
+     *
+     * @param StorageConfig $newStorage storage attributes
+     *
+     * @return StorageConfig storage config, with added id
+     */
+    public function addStorage(StorageConfig $newStorage) {
+        $allStorages = $this->readConfig();
+
+        $configId = $this->dbConfig->addMount(
+            $newStorage->getMountPoint(),
+            $newStorage->getBackend()->getIdentifier(),
+            $newStorage->getAuthMechanism()->getIdentifier(),
+            $newStorage->getPriority(),
+            $this->getType()
+        );
+
+        $newStorage->setId($configId);
+
+        foreach ($newStorage->getApplicableUsers() as $user) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($newStorage->getApplicableGroups() as $group) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($newStorage->getBackendOptions() as $key => $value) {
+            $this->dbConfig->setConfig($configId, $key, $value);
+        }
+        foreach ($newStorage->getMountOptions() as $key => $value) {
+            $this->dbConfig->setOption($configId, $key, $value);
+        }
+
+        if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        // add new storage
+        $allStorages[$configId] = $newStorage;
+
+        $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+
+        $newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
+        return $newStorage;
+    }
+
+    /**
+     * Create a storage from its parameters
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backendIdentifier backend identifier
+     * @param string $authMechanismIdentifier authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array|null $mountOptions mount-specific options
+     * @param array|null $applicableUsers users for which to mount the storage
+     * @param array|null $applicableGroups groups for which to mount the storage
+     * @param int|null $priority priority
+     *
+     * @return StorageConfig
+     */
+    public function createStorage(
+        $mountPoint,
+        $backendIdentifier,
+        $authMechanismIdentifier,
+        $backendOptions,
+        $mountOptions = null,
+        $applicableUsers = null,
+        $applicableGroups = null,
+        $priority = null
+    ) {
+        $backend = $this->backendService->getBackend($backendIdentifier);
+        if (!$backend) {
+            throw new \InvalidArgumentException('Unable to get backend for ' . $backendIdentifier);
+        }
+        $authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
+        if (!$authMechanism) {
+            throw new \InvalidArgumentException('Unable to get authentication mechanism for ' . $authMechanismIdentifier);
+        }
+        $newStorage = new StorageConfig();
+        $newStorage->setMountPoint($mountPoint);
+        $newStorage->setBackend($backend);
+        $newStorage->setAuthMechanism($authMechanism);
+        $newStorage->setBackendOptions($backendOptions);
+        if (isset($mountOptions)) {
+            $newStorage->setMountOptions($mountOptions);
+        }
+        if (isset($applicableUsers)) {
+            $newStorage->setApplicableUsers($applicableUsers);
+        }
+        if (isset($applicableGroups)) {
+            $newStorage->setApplicableGroups($applicableGroups);
+        }
+        if (isset($priority)) {
+            $newStorage->setPriority($priority);
+        }
+
+        return $newStorage;
+    }
+
+    /**
+     * Triggers the given hook signal for all the applicables given
+     *
+     * @param string $signal signal
+     * @param string $mountPoint hook mount pount param
+     * @param string $mountType hook mount type param
+     * @param array $applicableArray array of applicable users/groups for which to trigger the hook
+     */
+    protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray) {
+        foreach ($applicableArray as $applicable) {
+            \OCP\Util::emitHook(
+                Filesystem::CLASSNAME,
+                $signal,
+                [
+                    Filesystem::signal_param_path => $mountPoint,
+                    Filesystem::signal_param_mount_type => $mountType,
+                    Filesystem::signal_param_users => $applicable,
+                ]
+            );
+        }
+    }
+
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    abstract protected function triggerHooks(StorageConfig $storage, $signal);
+
+    /**
+     * 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
+     */
+    abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
+
+    /**
+     * 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) {
+        $id = $updatedStorage->getId();
+
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
+        }
+
+        $oldStorage = $this->getStorageConfigFromDBMount($existingMount);
+
+        $removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
+        $removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
+        $addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
+        $addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
+
+        $oldUserCount = count($oldStorage->getApplicableUsers());
+        $oldGroupCount = count($oldStorage->getApplicableGroups());
+        $newUserCount = count($updatedStorage->getApplicableUsers());
+        $newGroupCount = count($updatedStorage->getApplicableGroups());
+        $wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
+        $isGlobal = ($newUserCount + $newGroupCount) === 0;
+
+        foreach ($removedUsers as $user) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($removedGroups as $group) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($addedUsers as $user) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($addedGroups as $group) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+
+        if ($wasGlobal && !$isGlobal) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        } else if (!$wasGlobal && $isGlobal) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        $changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
+        $changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
+
+        foreach ($changedConfig as $key => $value) {
+            $this->dbConfig->setConfig($id, $key, $value);
+        }
+        foreach ($changedOptions as $key => $value) {
+            $this->dbConfig->setOption($id, $key, $value);
+        }
+
+        if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
+            $this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
+        }
+
+        if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
+            $this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
+        }
+
+        $this->triggerChangeHooks($oldStorage, $updatedStorage);
+
+        if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
+            $this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
+        } else {
+            $storageId = $this->getStorageId($updatedStorage);
+            foreach ($removedUsers as $userId) {
+                $this->userMountCache->removeUserStorageMount($storageId, $userId);
+            }
+        }
+
+        return $this->getStorage($id);
+    }
+
+    /**
+     * Delete the storage with the given id.
+     *
+     * @param int $id storage id
+     *
+     * @throws NotFoundException if no storage was found with the given id
+     */
+    public function removeStorage($id) {
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $this->dbConfig->removeMount($id);
+
+        $deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
+        $this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
+
+        // delete oc_storages entries and oc_filecache
+        try {
+            $rustyStorageId = $this->getRustyStorageIdFromConfig($deletedStorage);
+            \OC\Files\Cache\Storage::remove($rustyStorageId);
+        } catch (\Exception $e) {
+            // can happen either for invalid configs where the storage could not
+            // be instantiated or whenever $user vars where used, in which case
+            // the storage id could not be computed
+            \OCP\Util::writeLog(
+                'files_external',
+                'Exception: "' . $e->getMessage() . '"',
+                \OCP\Util::ERROR
+            );
+        }
+    }
+
+    /**
+     * Returns the rusty storage id from oc_storages from the given storage config.
+     *
+     * @param StorageConfig $storageConfig
+     * @return string rusty storage id
+     */
+    private function getRustyStorageIdFromConfig(StorageConfig $storageConfig) {
+        // if any of the storage options contains $user, it is not possible
+        // to compute the possible storage id as we don't know which users
+        // mounted it already (and we certainly don't want to iterate over ALL users)
+        foreach ($storageConfig->getBackendOptions() as $value) {
+            if (strpos($value, '$user') !== false) {
+                throw new \Exception('Cannot compute storage id for deletion due to $user vars in the configuration');
+            }
+        }
+
+        // note: similar to ConfigAdapter->prepateStorageConfig()
+        $storageConfig->getAuthMechanism()->manipulateStorageConfig($storageConfig);
+        $storageConfig->getBackend()->manipulateStorageConfig($storageConfig);
+
+        $class = $storageConfig->getBackend()->getStorageClass();
+        $storageImpl = new $class($storageConfig->getBackendOptions());
+
+        return $storageImpl->getId();
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return int
+     */
+    private function getStorageId(StorageConfig $storageConfig) {
+        try {
+            $class = $storageConfig->getBackend()->getStorageClass();
+            /** @var \OC\Files\Storage\Storage $storage */
+            $storage = new $class($storageConfig->getBackendOptions());
+
+            // auth mechanism should fire first
+            $storage = $storageConfig->getBackend()->wrapStorage($storage);
+            $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+            return $storage->getStorageCache()->getNumericId();
+        } catch (\Exception $e) {
+            return -1;
+        }
+    }
 }

Spacing +16 added lines, -16 removed lines

@@ -70,17 +70,17 @@ 
 	}
 
 	protected function getStorageConfigFromDBMount(array $mount) {
-		$applicableUsers = array_filter($mount['applicable'], function ($applicable) {
+		$applicableUsers = array_filter($mount['applicable'], function($applicable) {
 			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
 		});
-		$applicableUsers = array_map(function ($applicable) {
+		$applicableUsers = array_map(function($applicable) {
 			return $applicable['value'];
 		}, $applicableUsers);
 
-		$applicableGroups = array_filter($mount['applicable'], function ($applicable) {
+		$applicableGroups = array_filter($mount['applicable'], function($applicable) {
 			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
 		});
-		$applicableGroups = array_map(function ($applicable) {
+		$applicableGroups = array_map(function($applicable) {
 			return $applicable['value'];
 		}, $applicableGroups);
 
@@ -96,20 +96,20 @@ 
 				$mount['priority']
 			);
 			$config->setType($mount['type']);
-			$config->setId((int)$mount['mount_id']);
+			$config->setId((int) $mount['mount_id']);
 			return $config;
 		} catch (\UnexpectedValueException $e) {
 			// don't die if a storage backend doesn't exist
 			\OCP\Util::writeLog(
 				'files_external',
-				'Could not load storage: "' . $e->getMessage() . '"',
+				'Could not load storage: "'.$e->getMessage().'"',
 				\OCP\Util::ERROR
 			);
 			return null;
 		} catch (\InvalidArgumentException $e) {
 			\OCP\Util::writeLog(
 				'files_external',
-				'Could not load storage: "' . $e->getMessage() . '"',
+				'Could not load storage: "'.$e->getMessage().'"',
 				\OCP\Util::ERROR
 			);
 			return null;
@@ -124,11 +124,11 @@ 
 	protected function readConfig() {
 		$mounts = $this->readDBConfig();
 		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
+		$configs = array_filter($configs, function($config) {
 			return $config instanceof StorageConfig;
 		});
 
-		$keys = array_map(function (StorageConfig $config) {
+		$keys = array_map(function(StorageConfig $config) {
 			return $config->getId();
 		}, $configs);
 
@@ -147,14 +147,14 @@ 
 		$mount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($mount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 
 		$config = $this->getStorageConfigFromDBMount($mount);
 		if ($this->isApplicable($config)) {
 			return $config;
 		} else {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 	}
 
@@ -295,11 +295,11 @@ 
 	) {
 		$backend = $this->backendService->getBackend($backendIdentifier);
 		if (!$backend) {
-			throw new \InvalidArgumentException('Unable to get backend for ' . $backendIdentifier);
+			throw new \InvalidArgumentException('Unable to get backend for '.$backendIdentifier);
 		}
 		$authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
 		if (!$authMechanism) {
-			throw new \InvalidArgumentException('Unable to get authentication mechanism for ' . $authMechanismIdentifier);
+			throw new \InvalidArgumentException('Unable to get authentication mechanism for '.$authMechanismIdentifier);
 		}
 		$newStorage = new StorageConfig();
 		$newStorage->setMountPoint($mountPoint);
@@ -377,7 +377,7 @@ 
 		$existingMount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found while updating storage');
 		}
 
 		$oldStorage = $this->getStorageConfigFromDBMount($existingMount);
@@ -456,7 +456,7 @@ 
 		$existingMount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 
 		$this->dbConfig->removeMount($id);
@@ -474,7 +474,7 @@ 
 			// the storage id could not be computed
 			\OCP\Util::writeLog(
 				'files_external',
-				'Exception: "' . $e->getMessage() . '"',
+				'Exception: "'.$e->getMessage().'"',
 				\OCP\Util::ERROR
 			);
 		}

apps/files_external/lib/Controller/UserStoragesController.php

Indentation +180 added lines, -180 removed lines

@@ -43,185 +43,185 @@
  * User storages controller
  */
 class UserStoragesController extends StoragesController {
-	/**
-	 * @var IUserSession
-	 */
-	private $userSession;
-
-	/**
-	 * Creates a new user storages controller.
-	 *
-	 * @param string $AppName application name
-	 * @param IRequest $request request object
-	 * @param IL10N $l10n l10n service
-	 * @param UserStoragesService $userStoragesService storage service
-	 * @param IUserSession $userSession
-	 * @param ILogger $logger
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		UserStoragesService $userStoragesService,
-		IUserSession $userSession,
-		ILogger $logger
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$userStoragesService,
-			$logger
-		);
-		$this->userSession = $userSession;
-	}
-
-	protected function manipulateStorageConfig(StorageConfig $storage) {
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		$authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		$backend->manipulateStorageConfig($storage, $this->userSession->getUser());
-	}
-
-	/**
-	 * Get all storage entries
-	 *
-	 * @NoAdminRequired
-	 *
-	 * @return DataResponse
-	 */
-	public function index() {
-		return parent::index();
-	}
-
-	/**
-	 * Return storage
-	 *
-	 * @NoAdminRequired
-	 *
-	 * {@inheritdoc}
-	 */
-	public function show($id, $testOnly = true) {
-		return parent::show($id, $testOnly);
-	}
-
-	/**
-	 * Create an external storage entry.
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backend backend identifier
-	 * @param string $authMechanism authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array $mountOptions backend-specific mount options
-	 *
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function create(
-		$mountPoint,
-		$backend,
-		$authMechanism,
-		$backendOptions,
-		$mountOptions
-	) {
-		$newStorage = $this->createStorage(
-			$mountPoint,
-			$backend,
-			$authMechanism,
-			$backendOptions,
-			$mountOptions
-		);
-		if ($newStorage instanceOf DataResponse) {
-			return $newStorage;
-		}
-
-		$response = $this->validate($newStorage);
-		if (!empty($response)) {
-			return $response;
-		}
-
-		$newStorage = $this->service->addStorage($newStorage);
-		$this->updateStorageStatus($newStorage);
-
-		return new DataResponse(
-			$newStorage,
-			Http::STATUS_CREATED
-		);
-	}
-
-	/**
-	 * Update an external storage entry.
-	 *
-	 * @param int $id storage id
-	 * @param string $mountPoint storage mount point
-	 * @param string $backend backend identifier
-	 * @param string $authMechanism authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array $mountOptions backend-specific mount options
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 *
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function update(
-		$id,
-		$mountPoint,
-		$backend,
-		$authMechanism,
-		$backendOptions,
-		$mountOptions,
-		$testOnly = true
-	) {
-		$storage = $this->createStorage(
-			$mountPoint,
-			$backend,
-			$authMechanism,
-			$backendOptions,
-			$mountOptions
-		);
-		if ($storage instanceOf DataResponse) {
-			return $storage;
-		}
-		$storage->setId($id);
-
-		$response = $this->validate($storage);
-		if (!empty($response)) {
-			return $response;
-		}
-
-		try {
-			$storage = $this->service->updateStorage($storage);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage, $testOnly);
-
-		return new DataResponse(
-			$storage,
-			Http::STATUS_OK
-		);
-
-	}
-
-	/**
-	 * Delete storage
-	 *
-	 * @NoAdminRequired
-	 *
-	 * {@inheritdoc}
-	 */
-	public function destroy($id) {
-		return parent::destroy($id);
-	}
+    /**
+     * @var IUserSession
+     */
+    private $userSession;
+
+    /**
+     * Creates a new user storages controller.
+     *
+     * @param string $AppName application name
+     * @param IRequest $request request object
+     * @param IL10N $l10n l10n service
+     * @param UserStoragesService $userStoragesService storage service
+     * @param IUserSession $userSession
+     * @param ILogger $logger
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        UserStoragesService $userStoragesService,
+        IUserSession $userSession,
+        ILogger $logger
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $userStoragesService,
+            $logger
+        );
+        $this->userSession = $userSession;
+    }
+
+    protected function manipulateStorageConfig(StorageConfig $storage) {
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        $authMechanism->manipulateStorageConfig($storage, $this->userSession->getUser());
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        $backend->manipulateStorageConfig($storage, $this->userSession->getUser());
+    }
+
+    /**
+     * Get all storage entries
+     *
+     * @NoAdminRequired
+     *
+     * @return DataResponse
+     */
+    public function index() {
+        return parent::index();
+    }
+
+    /**
+     * Return storage
+     *
+     * @NoAdminRequired
+     *
+     * {@inheritdoc}
+     */
+    public function show($id, $testOnly = true) {
+        return parent::show($id, $testOnly);
+    }
+
+    /**
+     * Create an external storage entry.
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backend backend identifier
+     * @param string $authMechanism authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array $mountOptions backend-specific mount options
+     *
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function create(
+        $mountPoint,
+        $backend,
+        $authMechanism,
+        $backendOptions,
+        $mountOptions
+    ) {
+        $newStorage = $this->createStorage(
+            $mountPoint,
+            $backend,
+            $authMechanism,
+            $backendOptions,
+            $mountOptions
+        );
+        if ($newStorage instanceOf DataResponse) {
+            return $newStorage;
+        }
+
+        $response = $this->validate($newStorage);
+        if (!empty($response)) {
+            return $response;
+        }
+
+        $newStorage = $this->service->addStorage($newStorage);
+        $this->updateStorageStatus($newStorage);
+
+        return new DataResponse(
+            $newStorage,
+            Http::STATUS_CREATED
+        );
+    }
+
+    /**
+     * Update an external storage entry.
+     *
+     * @param int $id storage id
+     * @param string $mountPoint storage mount point
+     * @param string $backend backend identifier
+     * @param string $authMechanism authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array $mountOptions backend-specific mount options
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     *
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function update(
+        $id,
+        $mountPoint,
+        $backend,
+        $authMechanism,
+        $backendOptions,
+        $mountOptions,
+        $testOnly = true
+    ) {
+        $storage = $this->createStorage(
+            $mountPoint,
+            $backend,
+            $authMechanism,
+            $backendOptions,
+            $mountOptions
+        );
+        if ($storage instanceOf DataResponse) {
+            return $storage;
+        }
+        $storage->setId($id);
+
+        $response = $this->validate($storage);
+        if (!empty($response)) {
+            return $response;
+        }
+
+        try {
+            $storage = $this->service->updateStorage($storage);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage, $testOnly);
+
+        return new DataResponse(
+            $storage,
+            Http::STATUS_OK
+        );
+
+    }
+
+    /**
+     * Delete storage
+     *
+     * @NoAdminRequired
+     *
+     * {@inheritdoc}
+     */
+    public function destroy($id) {
+        return parent::destroy($id);
+    }
 
 }

Spacing +1 added lines, -1 removed lines

@@ -198,7 +198,7 @@
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);

apps/files_external/lib/Controller/UserGlobalStoragesController.php

Indentation +160 added lines, -160 removed lines

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

Spacing +3 added lines, -3 removed lines

@@ -122,7 +122,7 @@ 
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);
@@ -162,7 +162,7 @@ 
 			} else {
 				return new DataResponse(
 					[
-						'message' => (string)$this->l10n->t('Storage with ID "%i" is not user editable', array($id))
+						'message' => (string) $this->l10n->t('Storage with ID "%i" is not user editable', array($id))
 					],
 					Http::STATUS_FORBIDDEN
 				);
@@ -170,7 +170,7 @@ 
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);

apps/files_external/lib/Controller/GlobalStoragesController.php

Indentation +145 added lines, -145 removed lines

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

Spacing +1 added lines, -1 removed lines

@@ -170,7 +170,7 @@
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);

apps/files_external/lib/Controller/StoragesController.php

Indentation +272 added lines, -272 removed lines

@@ -47,298 +47,298 @@
  */
 abstract class StoragesController extends Controller {
 
-	/**
-	 * L10N service
-	 *
-	 * @var IL10N
-	 */
-	protected $l10n;
+    /**
+     * L10N service
+     *
+     * @var IL10N
+     */
+    protected $l10n;
 
-	/**
-	 * Storages service
-	 *
-	 * @var StoragesService
-	 */
-	protected $service;
+    /**
+     * Storages service
+     *
+     * @var StoragesService
+     */
+    protected $service;
 
-	/**
-	 * @var ILogger
-	 */
-	protected $logger;
+    /**
+     * @var ILogger
+     */
+    protected $logger;
 
-	/**
-	 * Creates a new storages controller.
-	 *
-	 * @param string $AppName application name
-	 * @param IRequest $request request object
-	 * @param IL10N $l10n l10n service
-	 * @param StoragesService $storagesService storage service
-	 * @param ILogger $logger
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		StoragesService $storagesService,
-		ILogger $logger
-	) {
-		parent::__construct($AppName, $request);
-		$this->l10n = $l10n;
-		$this->service = $storagesService;
-		$this->logger = $logger;
-	}
+    /**
+     * Creates a new storages controller.
+     *
+     * @param string $AppName application name
+     * @param IRequest $request request object
+     * @param IL10N $l10n l10n service
+     * @param StoragesService $storagesService storage service
+     * @param ILogger $logger
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        StoragesService $storagesService,
+        ILogger $logger
+    ) {
+        parent::__construct($AppName, $request);
+        $this->l10n = $l10n;
+        $this->service = $storagesService;
+        $this->logger = $logger;
+    }
 
-	/**
-	 * Create a storage from its parameters
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backend backend identifier
-	 * @param string $authMechanism authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array|null $mountOptions mount-specific options
-	 * @param array|null $applicableUsers users for which to mount the storage
-	 * @param array|null $applicableGroups groups for which to mount the storage
-	 * @param int|null $priority priority
-	 *
-	 * @return StorageConfig|DataResponse
-	 */
-	protected function createStorage(
-		$mountPoint,
-		$backend,
-		$authMechanism,
-		$backendOptions,
-		$mountOptions = null,
-		$applicableUsers = null,
-		$applicableGroups = null,
-		$priority = null
-	) {
-		try {
-			return $this->service->createStorage(
-				$mountPoint,
-				$backend,
-				$authMechanism,
-				$backendOptions,
-				$mountOptions,
-				$applicableUsers,
-				$applicableGroups,
-				$priority
-			);
-		} catch (\InvalidArgumentException $e) {
-			$this->logger->logException($e);
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Invalid backend or authentication mechanism class')
-				],
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
-	}
+    /**
+     * Create a storage from its parameters
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backend backend identifier
+     * @param string $authMechanism authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array|null $mountOptions mount-specific options
+     * @param array|null $applicableUsers users for which to mount the storage
+     * @param array|null $applicableGroups groups for which to mount the storage
+     * @param int|null $priority priority
+     *
+     * @return StorageConfig|DataResponse
+     */
+    protected function createStorage(
+        $mountPoint,
+        $backend,
+        $authMechanism,
+        $backendOptions,
+        $mountOptions = null,
+        $applicableUsers = null,
+        $applicableGroups = null,
+        $priority = null
+    ) {
+        try {
+            return $this->service->createStorage(
+                $mountPoint,
+                $backend,
+                $authMechanism,
+                $backendOptions,
+                $mountOptions,
+                $applicableUsers,
+                $applicableGroups,
+                $priority
+            );
+        } catch (\InvalidArgumentException $e) {
+            $this->logger->logException($e);
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Invalid backend or authentication mechanism class')
+                ],
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
+    }
 
-	/**
-	 * Validate storage config
-	 *
-	 * @param StorageConfig $storage storage config
-	 *1
-	 * @return DataResponse|null returns response in case of validation error
-	 */
-	protected function validate(StorageConfig $storage) {
-		$mountPoint = $storage->getMountPoint();
-		if ($mountPoint === '') {
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Invalid mount point')
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+    /**
+     * Validate storage config
+     *
+     * @param StorageConfig $storage storage config
+     *1
+     * @return DataResponse|null returns response in case of validation error
+     */
+    protected function validate(StorageConfig $storage) {
+        $mountPoint = $storage->getMountPoint();
+        if ($mountPoint === '') {
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Invalid mount point')
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
 
-		if ($storage->getBackendOption('objectstore')) {
-			// objectstore must not be sent from client side
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Objectstore forbidden')
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+        if ($storage->getBackendOption('objectstore')) {
+            // objectstore must not be sent from client side
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Objectstore forbidden')
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
 
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		if ($backend->checkDependencies()) {
-			// invalid backend
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Invalid storage backend "%s"', [
-						$backend->getIdentifier()
-					])
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        if ($backend->checkDependencies()) {
+            // invalid backend
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Invalid storage backend "%s"', [
+                        $backend->getIdentifier()
+                    ])
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
 
-		if (!$backend->isVisibleFor($this->service->getVisibilityType())) {
-			// not permitted to use backend
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Not permitted to use backend "%s"', [
-						$backend->getIdentifier()
-					])
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
-		if (!$authMechanism->isVisibleFor($this->service->getVisibilityType())) {
-			// not permitted to use auth mechanism
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Not permitted to use authentication mechanism "%s"', [
-						$authMechanism->getIdentifier()
-					])
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+        if (!$backend->isVisibleFor($this->service->getVisibilityType())) {
+            // not permitted to use backend
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Not permitted to use backend "%s"', [
+                        $backend->getIdentifier()
+                    ])
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
+        if (!$authMechanism->isVisibleFor($this->service->getVisibilityType())) {
+            // not permitted to use auth mechanism
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Not permitted to use authentication mechanism "%s"', [
+                        $authMechanism->getIdentifier()
+                    ])
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
 
-		if (!$backend->validateStorage($storage)) {
-			// unsatisfied parameters
-			return new DataResponse(
-				array(
-					'message' => (string)$this->l10n->t('Unsatisfied backend parameters')
-				),
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
-		if (!$authMechanism->validateStorage($storage)) {
-			// unsatisfied parameters
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Unsatisfied authentication mechanism parameters')
-				],
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+        if (!$backend->validateStorage($storage)) {
+            // unsatisfied parameters
+            return new DataResponse(
+                array(
+                    'message' => (string)$this->l10n->t('Unsatisfied backend parameters')
+                ),
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
+        if (!$authMechanism->validateStorage($storage)) {
+            // unsatisfied parameters
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Unsatisfied authentication mechanism parameters')
+                ],
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
 
-		return null;
-	}
+        return null;
+    }
 
-	protected function manipulateStorageConfig(StorageConfig $storage) {
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-		$authMechanism->manipulateStorageConfig($storage);
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		$backend->manipulateStorageConfig($storage);
-	}
+    protected function manipulateStorageConfig(StorageConfig $storage) {
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+        $authMechanism->manipulateStorageConfig($storage);
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        $backend->manipulateStorageConfig($storage);
+    }
 
-	/**
-	 * Check whether the given storage is available / valid.
-	 *
-	 * Note that this operation can be time consuming depending
-	 * on whether the remote storage is available or not.
-	 *
-	 * @param StorageConfig $storage storage configuration
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 */
-	protected function updateStorageStatus(StorageConfig &$storage, $testOnly = true) {
-		try {
-			$this->manipulateStorageConfig($storage);
+    /**
+     * Check whether the given storage is available / valid.
+     *
+     * Note that this operation can be time consuming depending
+     * on whether the remote storage is available or not.
+     *
+     * @param StorageConfig $storage storage configuration
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     */
+    protected function updateStorageStatus(StorageConfig &$storage, $testOnly = true) {
+        try {
+            $this->manipulateStorageConfig($storage);
 
-			/** @var Backend */
-			$backend = $storage->getBackend();
-			// update status (can be time-consuming)
-			$storage->setStatus(
-				\OC_Mount_Config::getBackendStatus(
-					$backend->getStorageClass(),
-					$storage->getBackendOptions(),
-					false,
-					$testOnly
-				)
-			);
-		} catch (InsufficientDataForMeaningfulAnswerException $e) {
-			$status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
-			$storage->setStatus(
-				$status,
-				$this->l10n->t('Insufficient data: %s', [$e->getMessage()])
-			);
-		} catch (StorageNotAvailableException $e) {
-			$storage->setStatus(
-				$e->getCode(),
-				$this->l10n->t('%s', [$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,
+                    $testOnly
+                )
+            );
+        } catch (InsufficientDataForMeaningfulAnswerException $e) {
+            $status = $e->getCode() ? $e->getCode() : StorageNotAvailableException::STATUS_INDETERMINATE;
+            $storage->setStatus(
+                $status,
+                $this->l10n->t('Insufficient data: %s', [$e->getMessage()])
+            );
+        } catch (StorageNotAvailableException $e) {
+            $storage->setStatus(
+                $e->getCode(),
+                $this->l10n->t('%s', [$e->getMessage()])
+            );
+        } catch (\Exception $e) {
+            // FIXME: convert storage exceptions to StorageNotAvailableException
+            $storage->setStatus(
+                StorageNotAvailableException::STATUS_ERROR,
+                get_class($e).': '.$e->getMessage()
+            );
+        }
+    }
 
-	/**
-	 * Get all storage entries
-	 *
-	 * @return DataResponse
-	 */
-	public function index() {
-		$storages = $this->service->getStorages();
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     */
+    public function index() {
+        $storages = $this->service->getStorages();
 
-		return new DataResponse(
-			$storages,
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $storages,
+            Http::STATUS_OK
+        );
+    }
 
-	/**
-	 * Get an external storage entry.
-	 *
-	 * @param int $id storage id
-	 * @param bool $testOnly whether to storage should only test the connection or do more things
-	 *
-	 * @return DataResponse
-	 */
-	public function show($id, $testOnly = true) {
-		try {
-			$storage = $this->service->getStorage($id);
+    /**
+     * Get an external storage entry.
+     *
+     * @param int $id storage id
+     * @param bool $testOnly whether to storage should only test the connection or do more things
+     *
+     * @return DataResponse
+     */
+    public function show($id, $testOnly = true) {
+        try {
+            $storage = $this->service->getStorage($id);
 
-			$this->updateStorageStatus($storage, $testOnly);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
+            $this->updateStorageStatus($storage, $testOnly);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		return new DataResponse(
-			$storage,
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $storage,
+            Http::STATUS_OK
+        );
+    }
 
-	/**
-	 * Deletes the storage with the given id.
-	 *
-	 * @param int $id storage id
-	 *
-	 * @return DataResponse
-	 */
-	public function destroy($id) {
-		try {
-			$this->service->removeStorage($id);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
+    /**
+     * Deletes the storage with the given id.
+     *
+     * @param int $id storage id
+     *
+     * @return DataResponse
+     */
+    public function destroy($id) {
+        try {
+            $this->service->removeStorage($id);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		return new DataResponse([], Http::STATUS_NO_CONTENT);
-	}
+        return new DataResponse([], Http::STATUS_NO_CONTENT);
+    }
 
 }
 

Spacing +11 added lines, -11 removed lines

@@ -127,7 +127,7 @@ 
 			$this->logger->logException($e);
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Invalid backend or authentication mechanism class')
+					'message' => (string) $this->l10n->t('Invalid backend or authentication mechanism class')
 				],
 				Http::STATUS_UNPROCESSABLE_ENTITY
 			);
@@ -146,7 +146,7 @@ 
 		if ($mountPoint === '') {
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Invalid mount point')
+					'message' => (string) $this->l10n->t('Invalid mount point')
 				),
 				Http::STATUS_UNPROCESSABLE_ENTITY
 			);
@@ -156,7 +156,7 @@ 
 			// objectstore must not be sent from client side
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Objectstore forbidden')
+					'message' => (string) $this->l10n->t('Objectstore forbidden')
 				),
 				Http::STATUS_UNPROCESSABLE_ENTITY
 			);
@@ -170,7 +170,7 @@ 
 			// invalid backend
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Invalid storage backend "%s"', [
+					'message' => (string) $this->l10n->t('Invalid storage backend "%s"', [
 						$backend->getIdentifier()
 					])
 				),
@@ -182,7 +182,7 @@ 
 			// not permitted to use backend
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Not permitted to use backend "%s"', [
+					'message' => (string) $this->l10n->t('Not permitted to use backend "%s"', [
 						$backend->getIdentifier()
 					])
 				),
@@ -193,7 +193,7 @@ 
 			// not permitted to use auth mechanism
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Not permitted to use authentication mechanism "%s"', [
+					'message' => (string) $this->l10n->t('Not permitted to use authentication mechanism "%s"', [
 						$authMechanism->getIdentifier()
 					])
 				),
@@ -205,7 +205,7 @@ 
 			// unsatisfied parameters
 			return new DataResponse(
 				array(
-					'message' => (string)$this->l10n->t('Unsatisfied backend parameters')
+					'message' => (string) $this->l10n->t('Unsatisfied backend parameters')
 				),
 				Http::STATUS_UNPROCESSABLE_ENTITY
 			);
@@ -214,7 +214,7 @@ 
 			// unsatisfied parameters
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Unsatisfied authentication mechanism parameters')
+					'message' => (string) $this->l10n->t('Unsatisfied authentication mechanism parameters')
 				],
 				Http::STATUS_UNPROCESSABLE_ENTITY
 			);
@@ -241,7 +241,7 @@ 
 	 * @param StorageConfig $storage storage configuration
 	 * @param bool $testOnly whether to storage should only test the connection or do more things
 	 */
-	protected function updateStorageStatus(StorageConfig &$storage, $testOnly = true) {
+	protected function updateStorageStatus(StorageConfig & $storage, $testOnly = true) {
 		try {
 			$this->manipulateStorageConfig($storage);
 
@@ -306,7 +306,7 @@ 
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);
@@ -331,7 +331,7 @@ 
 		} catch (NotFoundException $e) {
 			return new DataResponse(
 				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', array($id))
+					'message' => (string) $this->l10n->t('Storage with ID "%d" not found', array($id))
 				],
 				Http::STATUS_NOT_FOUND
 			);

apps/user_ldap/templates/part.wizard-loginfilter.php

Spacing +12 added lines, -12 removed lines

@@ -1,29 +1,29 @@ 
 <fieldset id="ldapWizard3">
 	<div>
 		<p>
-			<?php p($l->t('When logging in, %s will find the user based on the following attributes:', $theme->getName()));?>
+			<?php p($l->t('When logging in, %s will find the user based on the following attributes:', $theme->getName())); ?>
 		</p>
 		<p>
 			<label for="ldap_loginfilter_username">
-				<?php p($l->t('LDAP / AD Username:'));?>
+				<?php p($l->t('LDAP / AD Username:')); ?>
 			</label>
 
 			<input type="checkbox" id="ldap_loginfilter_username"
-				   title="<?php p($l->t('Allows login against the LDAP / AD username, which is either uid or sAMAccountName and will be detected.'));?>"
+				   title="<?php p($l->t('Allows login against the LDAP / AD username, which is either uid or sAMAccountName and will be detected.')); ?>"
 				   name="ldap_loginfilter_username" value="1" />
 		</p>
 		<p>
 			<label for="ldap_loginfilter_email">
-				<?php p($l->t('LDAP / AD Email Address:'));?>
+				<?php p($l->t('LDAP / AD Email Address:')); ?>
 			</label>
 
 			<input type="checkbox" id="ldap_loginfilter_email"
-				   title="<?php p($l->t('Allows login against an email attribute. Mail and mailPrimaryAddress will be allowed.'));?>"
+				   title="<?php p($l->t('Allows login against an email attribute. Mail and mailPrimaryAddress will be allowed.')); ?>"
 				   name="ldap_loginfilter_email" value="1" />
 		</p>
 		<p>
 			<label for="ldap_loginfilter_attributes">
-				<?php p($l->t('Other Attributes:'));?>
+				<?php p($l->t('Other Attributes:')); ?>
 			</label>
 
 			<select id="ldap_loginfilter_attributes" multiple="multiple"
@@ -31,17 +31,17 @@ 
 			</select>
 		</p>
 		<p>
-			<label><a id='toggleRawLoginFilter' class='ldapToggle'>↓ <?php p($l->t('Edit LDAP Query'));?></a></label>
+			<label><a id='toggleRawLoginFilter' class='ldapToggle'>↓ <?php p($l->t('Edit LDAP Query')); ?></a></label>
 		</p>
 		<p id="ldapReadOnlyLoginFilterContainer" class="hidden ldapReadOnlyFilterContainer">
-			<label><?php p($l->t('LDAP Filter:'));?></label>
+			<label><?php p($l->t('LDAP Filter:')); ?></label>
 			<span class="ldapFilterReadOnlyElement ldapInputColElement"></span>
 		</p>
 		<p id="rawLoginFilterContainer" class="invisible">
 			<textarea type="text" id="ldap_login_filter" name="ldap_login_filter"
 				class="ldapFilterInputElement"
-				placeholder="<?php p($l->t('Edit LDAP Query'));?>"
-				title="<?php p($l->t('Defines the filter to apply, when login is attempted. %%uid replaces the username in the login action. Example: "uid=%%uid"'));?>">
+				placeholder="<?php p($l->t('Edit LDAP Query')); ?>"
+				title="<?php p($l->t('Defines the filter to apply, when login is attempted. %%uid replaces the username in the login action. Example: "uid=%%uid"')); ?>">
 			</textarea>
 		</p>
 		<p>
@@ -49,11 +49,11 @@ 
 		</p>
 		<p class="ldap_verify">
 			<input type="text" id="ldap_test_loginname" name="ldap_test_loginname"
-				   placeholder="<?php p($l->t('Test Loginname'));?>"
+				   placeholder="<?php p($l->t('Test Loginname')); ?>"
 				   class="ldapVerifyInput"
 				   title="Attempts to receive a DN for the given loginname and the current login filter"/>
 			<button class="ldapVerifyLoginName" name="ldapTestLoginSettings" type="button" disabled="disabled">
-				<?php p($l->t('Verify settings'));?>
+				<?php p($l->t('Verify settings')); ?>
 			</button>
 		</p>
 		<?php print_unescaped($_['wizardControls']); ?>

apps/user_ldap/templates/part.wizard-groupfilter.php

Spacing +11 added lines, -11 removed lines

@@ -1,11 +1,11 @@ 
 <fieldset id="ldapWizard4">
 	<div>
 		<p>
-			<?php p($l->t('Groups meeting these criteria are available in %s:', $theme->getName()));?>
+			<?php p($l->t('Groups meeting these criteria are available in %s:', $theme->getName())); ?>
 		</p>
 		<p>
 			<label for="ldap_groupfilter_objectclass">
-				<?php p($l->t('Only these object classes:'));?>
+				<?php p($l->t('Only these object classes:')); ?>
 			</label>
 
 			<select id="ldap_groupfilter_objectclass" multiple="multiple"
@@ -14,10 +14,10 @@ 
 		</p>
 		<p>
 			<label for="ldap_groupfilter_groups">
-				<?php p($l->t('Only from these groups:'));?>
+				<?php p($l->t('Only from these groups:')); ?>
 			</label>
 
-			<input type="text" class="ldapManyGroupsSupport ldapManyGroupsSearch hidden" placeholder="<?php p($l->t('Search groups'));?>" />
+			<input type="text" class="ldapManyGroupsSupport ldapManyGroupsSearch hidden" placeholder="<?php p($l->t('Search groups')); ?>" />
 
 			<select id="ldap_groupfilter_groups" multiple="multiple"
 			 name="ldap_groupfilter_groups" class="multiSelectPlugin">
@@ -27,25 +27,25 @@ 
 		<p class="ldapManyGroupsSupport hidden">
 			<label></label>
 			<select class="ldapGroupList ldapGroupListAvailable" multiple="multiple"
-					title="<?php p($l->t('Available groups'));?>"></select>
+					title="<?php p($l->t('Available groups')); ?>"></select>
 			<span class="buttonSpan">
 				<button class="ldapGroupListSelect" type="button">&gt;</button><br/>
 				<button class="ldapGroupListDeselect" type="button">&lt;</button>
 			</span>
 			<select class="ldapGroupList ldapGroupListSelected" multiple="multiple"
-					title="<?php p($l->t('Selected groups'));?>"></select>
+					title="<?php p($l->t('Selected groups')); ?>"></select>
 		</p>
 		<p>
-			<label><a id='toggleRawGroupFilter' class='ldapToggle'>↓ <?php p($l->t('Edit LDAP Query'));?></a></label>
+			<label><a id='toggleRawGroupFilter' class='ldapToggle'>↓ <?php p($l->t('Edit LDAP Query')); ?></a></label>
 		</p>
 		<p id="ldapReadOnlyGroupFilterContainer" class="hidden ldapReadOnlyFilterContainer">
-			<label><?php p($l->t('LDAP Filter:'));?></label>
+			<label><?php p($l->t('LDAP Filter:')); ?></label>
 			<span class="ldapFilterReadOnlyElement ldapInputColElement"></span>
 		</p>
 		<p id="rawGroupFilterContainer" class="invisible">
 			<textarea type="text" id="ldap_group_filter" name="ldap_group_filter"
-					  placeholder="<?php p($l->t('Edit LDAP Query'));?>"
-					  title="<?php p($l->t('The filter specifies which LDAP groups shall have access to the %s instance.', $theme->getName()));?>">
+					  placeholder="<?php p($l->t('Edit LDAP Query')); ?>"
+					  title="<?php p($l->t('The filter specifies which LDAP groups shall have access to the %s instance.', $theme->getName())); ?>">
 			</textarea>
 		</p>
 		<p>
@@ -53,7 +53,7 @@ 
 		</p>
 		<p class="ldap_count">
 			<button class="ldapGetEntryCount ldapGetGroupCount" name="ldapGetEntryCount" type="button">
-				<?php p($l->t('Verify settings and count the groups'));?>
+				<?php p($l->t('Verify settings and count the groups')); ?>
 			</button>
 			<span id="ldap_group_count"></span>
 		</p>

apps/user_ldap/templates/part.wizard-server.php

Spacing +21 added lines, -21 removed lines

@@ -8,16 +8,16 @@ 
 <fieldset id="ldapWizard1">
 		<p>
 		<select id="ldap_serverconfig_chooser" name="ldap_serverconfig_chooser">
-		<?php if(count($_['serverConfigurationPrefixes']) === 0 ) {
+		<?php if (count($_['serverConfigurationPrefixes']) === 0) {
 			?>
-				<option value="" selected><?php p($l->t('1. Server'));?></option>');
+				<option value="" selected><?php p($l->t('1. Server')); ?></option>');
 			<?php
 		} else {
 			$i = 1;
 			$sel = ' selected';
-			foreach($_['serverConfigurationPrefixes'] as $prefix) {
+			foreach ($_['serverConfigurationPrefixes'] as $prefix) {
 				?>
-				<option value="<?php p($prefix); ?>"<?php p($sel); $sel = ''; ?>><?php p($l->t('%s. Server:', array($i++)));?> <?php p(' '.$_['serverConfigurationHosts'][$prefix]); ?></option>
+				<option value="<?php p($prefix); ?>"<?php p($sel); $sel = ''; ?>><?php p($l->t('%s. Server:', array($i++))); ?> <?php p(' '.$_['serverConfigurationHosts'][$prefix]); ?></option>
 				<?php
 			}
 		}
@@ -25,14 +25,14 @@ 
 		</select>
 		<button type="button" id="ldap_action_add_configuration"
 			name="ldap_action_add_configuration" class="icon-add icon-default-style"
-			title="<?php p($l->t('Add a new configuration'));?>">&nbsp;</button>
+			title="<?php p($l->t('Add a new configuration')); ?>">&nbsp;</button>
 		<button type="button" id="ldap_action_copy_configuration"
 			name="ldap_action_copy_configuration"
 			class="ldapIconCopy icon-default-style"
-			title="<?php p($l->t('Copy current configuration into new directory binding'));?>">&nbsp;</button>
+			title="<?php p($l->t('Copy current configuration into new directory binding')); ?>">&nbsp;</button>
 		<button type="button" id="ldap_action_delete_configuration"
 			name="ldap_action_delete_configuration" class="icon-delete icon-default-style"
-			title="<?php p($l->t('Delete the current configuration'));?>">&nbsp;</button>
+			title="<?php p($l->t('Delete the current configuration')); ?>">&nbsp;</button>
 		</p>
 
 		<div class="hostPortCombinator">
@@ -41,14 +41,14 @@ 
 					<div class="table">
 						<input type="text" class="host" id="ldap_host"
 							name="ldap_host"
-							placeholder="<?php p($l->t('Host'));?>"
-							title="<?php p($l->t('You can omit the protocol, unless you require SSL. If so, start with ldaps://'));?>"
+							placeholder="<?php p($l->t('Host')); ?>"
+							title="<?php p($l->t('You can omit the protocol, unless you require SSL. If so, start with ldaps://')); ?>"
 							/>
 						<span class="hostPortCombinatorSpan">
 							<input type="number" id="ldap_port" name="ldap_port"
-								placeholder="<?php p($l->t('Port'));?>" />
+								placeholder="<?php p($l->t('Port')); ?>" />
 							<button class="ldapDetectPort" name="ldapDetectPort" type="button">
-								<?php p($l->t('Detect Port'));?>
+								<?php p($l->t('Detect Port')); ?>
 							</button>
 						</span>
 					</div>
@@ -57,40 +57,40 @@ 
 			<div class="tablerow">
 				<input type="text" id="ldap_dn" name="ldap_dn"
 				class="tablecell"
-				placeholder="<?php p($l->t('User DN'));?>" autocomplete="off"
-				title="<?php p($l->t('The DN of the client user with which the bind shall be done, e.g. uid=agent,dc=example,dc=com. For anonymous access, leave DN and Password empty.'));?>"
+				placeholder="<?php p($l->t('User DN')); ?>" autocomplete="off"
+				title="<?php p($l->t('The DN of the client user with which the bind shall be done, e.g. uid=agent,dc=example,dc=com. For anonymous access, leave DN and Password empty.')); ?>"
 				/>
 			</div>
 
 			<div class="tablerow">
 				<input type="password" id="ldap_agent_password"
 				class="tablecell" name="ldap_agent_password"
-				placeholder="<?php p($l->t('Password'));?>" autocomplete="off"
-				title="<?php p($l->t('For anonymous access, leave DN and Password empty.'));?>"
+				placeholder="<?php p($l->t('Password')); ?>" autocomplete="off"
+				title="<?php p($l->t('For anonymous access, leave DN and Password empty.')); ?>"
 				/>
 			</div>
 
 			<div class="tablerow">
 				<textarea id="ldap_base" name="ldap_base"
 					class="tablecell"
-					placeholder="<?php p($l->t('One Base DN per line'));?>"
-					title="<?php p($l->t('You can specify Base DN for users and groups in the Advanced tab'));?>">
+					placeholder="<?php p($l->t('One Base DN per line')); ?>"
+					title="<?php p($l->t('You can specify Base DN for users and groups in the Advanced tab')); ?>">
 				</textarea>
 				<button class="ldapDetectBase" name="ldapDetectBase" type="button">
-					<?php p($l->t('Detect Base DN'));?>
+					<?php p($l->t('Detect Base DN')); ?>
 				</button>
 				<button class="ldapTestBase" name="ldapTestBase" type="button">
-					<?php p($l->t('Test Base DN'));?>
+					<?php p($l->t('Test Base DN')); ?>
 				</button>
 			</div>
 
 			<div class="tablerow left">
 				<input type="checkbox" id="ldap_experienced_admin" value="1"
 					name="ldap_experienced_admin" class="tablecell"
-					title="<?php p($l->t('Avoids automatic LDAP requests. Better for bigger setups, but requires some LDAP knowledge.'));?>"
+					title="<?php p($l->t('Avoids automatic LDAP requests. Better for bigger setups, but requires some LDAP knowledge.')); ?>"
 					/>
 				<label for="ldap_experienced_admin" class="tablecell">
-					<?php p($l->t('Manually enter LDAP filters (recommended for large directories)'));?>
+					<?php p($l->t('Manually enter LDAP filters (recommended for large directories)')); ?>
 				</label>
 			</div>