nextcloud / server

apps/files_external/lib/Controller/StoragesController.php

Indentation +306 added lines, -306 removed lines

@@ -51,337 +51,337 @@
  */
 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;
 
-	/**
-	 * @var IUserSession
-	 */
-	protected $userSession;
+    /**
+     * @var IUserSession
+     */
+    protected $userSession;
 
-	/**
-	 * @var IGroupManager
-	 */
-	protected $groupManager;
+    /**
+     * @var IGroupManager
+     */
+    protected $groupManager;
 
-	/**
-	 * 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,
-		IUserSession $userSession,
-		IGroupManager $groupManager
-	) {
-		parent::__construct($AppName, $request);
-		$this->l10n = $l10n;
-		$this->service = $storagesService;
-		$this->logger = $logger;
-		$this->userSession = $userSession;
-		$this->groupManager = $groupManager;
-	}
+    /**
+     * 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,
+        IUserSession $userSession,
+        IGroupManager $groupManager
+    ) {
+        parent::__construct($AppName, $request);
+        $this->l10n = $l10n;
+        $this->service = $storagesService;
+        $this->logger = $logger;
+        $this->userSession = $userSession;
+        $this->groupManager = $groupManager;
+    }
 
-	/**
-	 * 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(
-				[
-					'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(
+                [
+                    '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(
-				[
-					'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(
+                [
+                    '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(
-				[
-					'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(
+                [
+                    '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(
-				[
-					'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(
-				[
-					'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(
+                [
+                    '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(
+                [
+                    '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(
-				[
-					'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(
+                [
+                    '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(
-				\OCA\Files_External\MountConfig::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(
+                \OCA\Files_External\MountConfig::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->formatStoragesForUI($this->service->getStorages());
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     */
+    public function index() {
+        $storages = $this->formatStoragesForUI($this->service->getStorages());
 
-		return new DataResponse(
-			$storages,
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $storages,
+            Http::STATUS_OK
+        );
+    }
 
-	protected function formatStoragesForUI(array $storages): array {
-		return array_map(function ($storage) {
-			return $this->formatStorageForUI($storage);
-		}, $storages);
-	}
+    protected function formatStoragesForUI(array $storages): array {
+        return array_map(function ($storage) {
+            return $this->formatStorageForUI($storage);
+        }, $storages);
+    }
 
-	protected function formatStorageForUI(StorageConfig $storage): StorageConfig {
-		/** @var DefinitionParameter[] $parameters */
-		$parameters = array_merge($storage->getBackend()->getParameters(), $storage->getAuthMechanism()->getParameters());
+    protected function formatStorageForUI(StorageConfig $storage): StorageConfig {
+        /** @var DefinitionParameter[] $parameters */
+        $parameters = array_merge($storage->getBackend()->getParameters(), $storage->getAuthMechanism()->getParameters());
 
-		$options = $storage->getBackendOptions();
-		foreach ($options as $key => $value) {
-			foreach ($parameters as $parameter) {
-				if ($parameter->getName() === $key && $parameter->getType() === DefinitionParameter::VALUE_PASSWORD) {
-					$storage->setBackendOption($key, DefinitionParameter::UNMODIFIED_PLACEHOLDER);
-					break;
-				}
-			}
-		}
+        $options = $storage->getBackendOptions();
+        foreach ($options as $key => $value) {
+            foreach ($parameters as $parameter) {
+                if ($parameter->getName() === $key && $parameter->getType() === DefinitionParameter::VALUE_PASSWORD) {
+                    $storage->setBackendOption($key, DefinitionParameter::UNMODIFIED_PLACEHOLDER);
+                    break;
+                }
+            }
+        }
 
-		return $storage;
-	}
+        return $storage;
+    }
 
-	/**
-	 * 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', [$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', [$id]),
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		$data = $this->formatStorageForUI($storage)->jsonSerialize();
-		$isAdmin = $this->groupManager->isAdmin($this->userSession->getUser()->getUID());
-		$data['can_edit'] = $storage->getType() === StorageConfig::MOUNT_TYPE_PERSONAl || $isAdmin;
+        $data = $this->formatStorageForUI($storage)->jsonSerialize();
+        $isAdmin = $this->groupManager->isAdmin($this->userSession->getUser()->getUID());
+        $data['can_edit'] = $storage->getType() === StorageConfig::MOUNT_TYPE_PERSONAl || $isAdmin;
 
-		return new DataResponse(
-			$data,
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $data,
+            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', [$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', [$id]),
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		return new DataResponse([], Http::STATUS_NO_CONTENT);
-	}
+        return new DataResponse([], Http::STATUS_NO_CONTENT);
+    }
 }

apps/files_external/lib/Controller/UserStoragesController.php

Indentation +177 added lines, -177 removed lines

@@ -45,181 +45,181 @@
  * User storages controller
  */
 class UserStoragesController extends StoragesController {
-	/**
-	 * 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 ILogger $logger
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		UserStoragesService $userStoragesService,
-		ILogger $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$userStoragesService,
-			$logger,
-			$userSession,
-			$groupManager
-		);
-	}
-
-	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(
-			$this->formatStorageForUI($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', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage, $testOnly);
-
-		return new DataResponse(
-			$this->formatStorageForUI($storage),
-			Http::STATUS_OK
-		);
-	}
-
-	/**
-	 * Delete storage
-	 *
-	 * @NoAdminRequired
-	 *
-	 * {@inheritdoc}
-	 */
-	public function destroy($id) {
-		return parent::destroy($id);
-	}
+    /**
+     * 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 ILogger $logger
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        UserStoragesService $userStoragesService,
+        ILogger $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $userStoragesService,
+            $logger,
+            $userSession,
+            $groupManager
+        );
+    }
+
+    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(
+            $this->formatStorageForUI($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', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage, $testOnly);
+
+        return new DataResponse(
+            $this->formatStorageForUI($storage),
+            Http::STATUS_OK
+        );
+    }
+
+    /**
+     * Delete storage
+     *
+     * @NoAdminRequired
+     *
+     * {@inheritdoc}
+     */
+    public function destroy($id) {
+        return parent::destroy($id);
+    }
 }

apps/files_external/lib/Controller/UserGlobalStoragesController.php

Indentation +162 added lines, -162 removed lines

@@ -47,166 +47,166 @@
  * User global storages controller
  */
 class UserGlobalStoragesController extends StoragesController {
-	/**
-	 * 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 ILogger $logger
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		ILogger $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$userGlobalStoragesService,
-			$logger,
-			$userSession,
-			$groupManager
-		);
-	}
-
-	/**
-	 * Get all storage entries
-	 *
-	 * @return DataResponse
-	 *
-	 * @NoAdminRequired
-	 */
-	public function index() {
-		$storages = $this->formatStoragesForUI($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', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->sanitizeStorage($storage);
-
-		$data = $this->formatStorageForUI($storage)->jsonSerialize();
-		$isAdmin = $this->groupManager->isAdmin($this->userSession->getUser()->getUID());
-		$data['can_edit'] = $storage->getType() === StorageConfig::MOUNT_TYPE_PERSONAl || $isAdmin;
-
-		return new DataResponse(
-			$data,
-			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 instanceof  UserGlobalAuth) {
-				$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 "%d" is not user editable', [$id])
-					],
-					Http::STATUS_FORBIDDEN
-				);
-			}
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => (string)$this->l10n->t('Storage with ID "%d" not found', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage, $testOnly);
-		$this->sanitizeStorage($storage);
-
-		return new DataResponse(
-			$this->formatStorageForUI($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
-			}
-		}
-	}
+    /**
+     * 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 ILogger $logger
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        ILogger $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $userGlobalStoragesService,
+            $logger,
+            $userSession,
+            $groupManager
+        );
+    }
+
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     *
+     * @NoAdminRequired
+     */
+    public function index() {
+        $storages = $this->formatStoragesForUI($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', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->sanitizeStorage($storage);
+
+        $data = $this->formatStorageForUI($storage)->jsonSerialize();
+        $isAdmin = $this->groupManager->isAdmin($this->userSession->getUser()->getUID());
+        $data['can_edit'] = $storage->getType() === StorageConfig::MOUNT_TYPE_PERSONAl || $isAdmin;
+
+        return new DataResponse(
+            $data,
+            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 instanceof  UserGlobalAuth) {
+                $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 "%d" is not user editable', [$id])
+                    ],
+                    Http::STATUS_FORBIDDEN
+                );
+            }
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage, $testOnly);
+        $this->sanitizeStorage($storage);
+
+        return new DataResponse(
+            $this->formatStorageForUI($storage),
+            Http::STATUS_OK
+        );
+    }
+
+    /**
+     * Remove sensitive data from a StorageConfig before returning it to the user
+     *
+     * @param StorageConfig $storage
+     */
+    protected function sanitizeStorage(StorageConfig $storage) {
+        $storage->setBackendOptions([]);
+        $storage->setMountOptions([]);
+
+        if ($storage->getAuthMechanism() instanceof IUserProvided) {
+            try {
+                $storage->getAuthMechanism()->manipulateStorageConfig($storage, $this->userSession->getUser());
+            } catch (InsufficientDataForMeaningfulAnswerException $e) {
+                // not configured yet
+            }
+        }
+    }
 }

apps/files_external/lib/Controller/GlobalStoragesController.php

Indentation +140 added lines, -140 removed lines

@@ -42,154 +42,154 @@
  * 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
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$AppName,
-		IRequest $request,
-		IL10N $l10n,
-		GlobalStoragesService $globalStoragesService,
-		ILogger $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager
-	) {
-		parent::__construct(
-			$AppName,
-			$request,
-			$l10n,
-			$globalStoragesService,
-			$logger,
-			$userSession,
-			$groupManager
-		);
-	}
+    /**
+     * 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
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $AppName,
+        IRequest $request,
+        IL10N $l10n,
+        GlobalStoragesService $globalStoragesService,
+        ILogger $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager
+    ) {
+        parent::__construct(
+            $AppName,
+            $request,
+            $l10n,
+            $globalStoragesService,
+            $logger,
+            $userSession,
+            $groupManager
+        );
+    }
 
-	/**
-	 * 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;
-		}
+    /**
+     * 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;
-		}
+        $response = $this->validate($newStorage);
+        if (!empty($response)) {
+            return $response;
+        }
 
-		$newStorage = $this->service->addStorage($newStorage);
+        $newStorage = $this->service->addStorage($newStorage);
 
-		$this->updateStorageStatus($newStorage);
+        $this->updateStorageStatus($newStorage);
 
-		return new DataResponse(
-			$this->formatStorageForUI($newStorage),
-			Http::STATUS_CREATED
-		);
-	}
+        return new DataResponse(
+            $this->formatStorageForUI($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);
+    /**
+     * 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;
-		}
+        $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', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
+        try {
+            $storage = $this->service->updateStorage($storage);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => (string)$this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		$this->updateStorageStatus($storage, $testOnly);
+        $this->updateStorageStatus($storage, $testOnly);
 
-		return new DataResponse(
-			$this->formatStorageForUI($storage),
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $this->formatStorageForUI($storage),
+            Http::STATUS_OK
+        );
+    }
 }