nextcloud / server

apps/files_external/lib/Lib/Auth/PublicKey/RSA.php

Indentation +48 added lines, -48 removed lines

@@ -20,56 +20,56 @@
  */
 class RSA extends AuthMechanism {
 
-	public function __construct(
-		IL10N $l,
-		private IConfig $config,
-	) {
-		$this
-			->setIdentifier('publickey::rsa')
-			->setScheme(self::SCHEME_PUBLICKEY)
-			->setText($l->t('RSA public key'))
-			->addParameters([
-				new DefinitionParameter('user', $l->t('Login')),
-				new DefinitionParameter('public_key', $l->t('Public key')),
-				(new DefinitionParameter('private_key', 'private_key'))
-					->setType(DefinitionParameter::VALUE_PASSWORD)
-					->setFlag(DefinitionParameter::FLAG_HIDDEN),
-			])
-			->addCustomJs('auth_rsa')
-		;
-	}
+    public function __construct(
+        IL10N $l,
+        private IConfig $config,
+    ) {
+        $this
+            ->setIdentifier('publickey::rsa')
+            ->setScheme(self::SCHEME_PUBLICKEY)
+            ->setText($l->t('RSA public key'))
+            ->addParameters([
+                new DefinitionParameter('user', $l->t('Login')),
+                new DefinitionParameter('public_key', $l->t('Public key')),
+                (new DefinitionParameter('private_key', 'private_key'))
+                    ->setType(DefinitionParameter::VALUE_PASSWORD)
+                    ->setFlag(DefinitionParameter::FLAG_HIDDEN),
+            ])
+            ->addCustomJs('auth_rsa')
+        ;
+    }
 
-	/**
-	 * @return void
-	 */
-	public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
-		$auth = new RSACrypt();
-		$auth->setPassword($this->config->getSystemValue('secret', ''));
-		if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
-			// Add fallback routine for a time where secret was not enforced to be exists
-			$auth->setPassword('');
-			if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
-				throw new \RuntimeException('unable to load private key');
-			}
-		}
-		$storage->setBackendOption('public_key_auth', $auth);
-	}
+    /**
+     * @return void
+     */
+    public function manipulateStorageConfig(StorageConfig &$storage, ?IUser $user = null) {
+        $auth = new RSACrypt();
+        $auth->setPassword($this->config->getSystemValue('secret', ''));
+        if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
+            // Add fallback routine for a time where secret was not enforced to be exists
+            $auth->setPassword('');
+            if (!$auth->loadKey($storage->getBackendOption('private_key'))) {
+                throw new \RuntimeException('unable to load private key');
+            }
+        }
+        $storage->setBackendOption('public_key_auth', $auth);
+    }
 
-	/**
-	 * Generate a keypair
-	 *
-	 * @param int $keyLenth
-	 * @return array ['privatekey' => $privateKey, 'publickey' => $publicKey]
-	 */
-	public function createKey($keyLength) {
-		$rsa = new RSACrypt();
-		$rsa->setPublicKeyFormat(RSACrypt::PUBLIC_FORMAT_OPENSSH);
-		$rsa->setPassword($this->config->getSystemValue('secret', ''));
+    /**
+     * Generate a keypair
+     *
+     * @param int $keyLenth
+     * @return array ['privatekey' => $privateKey, 'publickey' => $publicKey]
+     */
+    public function createKey($keyLength) {
+        $rsa = new RSACrypt();
+        $rsa->setPublicKeyFormat(RSACrypt::PUBLIC_FORMAT_OPENSSH);
+        $rsa->setPassword($this->config->getSystemValue('secret', ''));
 
-		if ($keyLength !== 1024 && $keyLength !== 2048 && $keyLength !== 4096) {
-			$keyLength = 1024;
-		}
+        if ($keyLength !== 1024 && $keyLength !== 2048 && $keyLength !== 4096) {
+            $keyLength = 1024;
+        }
 
-		return $rsa->createKey($keyLength);
-	}
+        return $rsa->createKey($keyLength);
+    }
 }

apps/files_external/lib/Lib/Backend/SFTP.php

Indentation +19 added lines, -19 removed lines

@@ -13,23 +13,23 @@
 use OCP\IL10N;
 
 class SFTP extends Backend {
-	public function __construct(IL10N $l, Password $legacyAuth) {
-		$this
-			->setIdentifier('sftp')
-			->addIdentifierAlias('\OC\Files\Storage\SFTP') // legacy compat
-			->setStorageClass('\OCA\Files_External\Lib\Storage\SFTP')
-			->setText($l->t('SFTP'))
-			->addParameters([
-				new DefinitionParameter('host', $l->t('Host')),
-				(new DefinitionParameter('port', $l->t('Port')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-				(new DefinitionParameter('root', $l->t('Root')))
-					->setFlag(DefinitionParameter::FLAG_OPTIONAL),
-			])
-			->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
-			->addAuthScheme(AuthMechanism::SCHEME_PUBLICKEY)
-			->addAuthScheme(AuthMechanism::SCHEME_OAUTH2)
-			->setLegacyAuthMechanism($legacyAuth)
-		;
-	}
+    public function __construct(IL10N $l, Password $legacyAuth) {
+        $this
+            ->setIdentifier('sftp')
+            ->addIdentifierAlias('\OC\Files\Storage\SFTP') // legacy compat
+            ->setStorageClass('\OCA\Files_External\Lib\Storage\SFTP')
+            ->setText($l->t('SFTP'))
+            ->addParameters([
+                new DefinitionParameter('host', $l->t('Host')),
+                (new DefinitionParameter('port', $l->t('Port')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+                (new DefinitionParameter('root', $l->t('Root')))
+                    ->setFlag(DefinitionParameter::FLAG_OPTIONAL),
+            ])
+            ->addAuthScheme(AuthMechanism::SCHEME_PASSWORD)
+            ->addAuthScheme(AuthMechanism::SCHEME_PUBLICKEY)
+            ->addAuthScheme(AuthMechanism::SCHEME_OAUTH2)
+            ->setLegacyAuthMechanism($legacyAuth)
+        ;
+    }
 }

apps/files_external/lib/AppInfo/Application.php

Indentation +91 added lines, -91 removed lines

@@ -59,95 +59,95 @@
  * @package OCA\Files_External\AppInfo
  */
 class Application extends App implements IBackendProvider, IAuthMechanismProvider, IBootstrap {
-	public const APP_ID = 'files_external';
-
-	/**
-	 * Application constructor.
-	 *
-	 * @throws QueryException
-	 */
-	public function __construct(array $urlParams = []) {
-		parent::__construct(self::APP_ID, $urlParams);
-	}
-
-	public function register(IRegistrationContext $context): void {
-		$context->registerEventListener(UserDeletedEvent::class, UserDeletedListener::class);
-		$context->registerEventListener(GroupDeletedEvent::class, GroupDeletedListener::class);
-		$context->registerEventListener(LoadAdditionalScriptsEvent::class, LoadAdditionalListener::class);
-		$context->registerEventListener(UserLoggedInEvent::class, StorePasswordListener::class);
-		$context->registerEventListener(PasswordUpdatedEvent::class, StorePasswordListener::class);
-		$context->registerConfigLexicon(ConfigLexicon::class);
-	}
-
-	public function boot(IBootContext $context): void {
-		$context->injectFn(function (IMountProviderCollection $mountProviderCollection, ConfigAdapter $configAdapter): void {
-			$mountProviderCollection->registerProvider($configAdapter);
-		});
-		$context->injectFn(function (BackendService $backendService, UserPlaceholderHandler $userConfigHandler): void {
-			$backendService->registerBackendProvider($this);
-			$backendService->registerAuthMechanismProvider($this);
-			$backendService->registerConfigHandler('user', function () use ($userConfigHandler) {
-				return $userConfigHandler;
-			});
-		});
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getBackends() {
-		$container = $this->getContainer();
-
-		$backends = [
-			$container->get(Local::class),
-			$container->get(FTP::class),
-			$container->get(DAV::class),
-			$container->get(OwnCloud::class),
-			$container->get(SFTP::class),
-			$container->get(AmazonS3::class),
-			$container->get(Swift::class),
-			$container->get(SFTP_Key::class),
-			$container->get(SMB::class),
-			$container->get(SMB_OC::class),
-		];
-
-		return $backends;
-	}
-
-	/**
-	 * @{inheritdoc}
-	 */
-	public function getAuthMechanisms() {
-		$container = $this->getContainer();
-
-		return [
-			// AuthMechanism::SCHEME_NULL mechanism
-			$container->get(NullMechanism::class),
-
-			// AuthMechanism::SCHEME_BUILTIN mechanism
-			$container->get(Builtin::class),
-
-			// AuthMechanism::SCHEME_PASSWORD mechanisms
-			$container->get(Password::class),
-			$container->get(SessionCredentials::class),
-			$container->get(LoginCredentials::class),
-			$container->get(UserProvided::class),
-			$container->get(GlobalAuth::class),
-			$container->get(UserGlobalAuth::class),
-
-			// AuthMechanism::SCHEME_PUBLICKEY mechanisms
-			$container->get(RSA::class),
-			$container->get(RSAPrivateKey::class),
-
-			// AuthMechanism::SCHEME_OPENSTACK mechanisms
-			$container->get(OpenStackV2::class),
-			$container->get(OpenStackV3::class),
-			$container->get(Rackspace::class),
-
-			// Specialized mechanisms
-			$container->get(AccessKey::class),
-			$container->get(KerberosAuth::class),
-			$container->get(KerberosApacheAuth::class),
-		];
-	}
+    public const APP_ID = 'files_external';
+
+    /**
+     * Application constructor.
+     *
+     * @throws QueryException
+     */
+    public function __construct(array $urlParams = []) {
+        parent::__construct(self::APP_ID, $urlParams);
+    }
+
+    public function register(IRegistrationContext $context): void {
+        $context->registerEventListener(UserDeletedEvent::class, UserDeletedListener::class);
+        $context->registerEventListener(GroupDeletedEvent::class, GroupDeletedListener::class);
+        $context->registerEventListener(LoadAdditionalScriptsEvent::class, LoadAdditionalListener::class);
+        $context->registerEventListener(UserLoggedInEvent::class, StorePasswordListener::class);
+        $context->registerEventListener(PasswordUpdatedEvent::class, StorePasswordListener::class);
+        $context->registerConfigLexicon(ConfigLexicon::class);
+    }
+
+    public function boot(IBootContext $context): void {
+        $context->injectFn(function (IMountProviderCollection $mountProviderCollection, ConfigAdapter $configAdapter): void {
+            $mountProviderCollection->registerProvider($configAdapter);
+        });
+        $context->injectFn(function (BackendService $backendService, UserPlaceholderHandler $userConfigHandler): void {
+            $backendService->registerBackendProvider($this);
+            $backendService->registerAuthMechanismProvider($this);
+            $backendService->registerConfigHandler('user', function () use ($userConfigHandler) {
+                return $userConfigHandler;
+            });
+        });
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getBackends() {
+        $container = $this->getContainer();
+
+        $backends = [
+            $container->get(Local::class),
+            $container->get(FTP::class),
+            $container->get(DAV::class),
+            $container->get(OwnCloud::class),
+            $container->get(SFTP::class),
+            $container->get(AmazonS3::class),
+            $container->get(Swift::class),
+            $container->get(SFTP_Key::class),
+            $container->get(SMB::class),
+            $container->get(SMB_OC::class),
+        ];
+
+        return $backends;
+    }
+
+    /**
+     * @{inheritdoc}
+     */
+    public function getAuthMechanisms() {
+        $container = $this->getContainer();
+
+        return [
+            // AuthMechanism::SCHEME_NULL mechanism
+            $container->get(NullMechanism::class),
+
+            // AuthMechanism::SCHEME_BUILTIN mechanism
+            $container->get(Builtin::class),
+
+            // AuthMechanism::SCHEME_PASSWORD mechanisms
+            $container->get(Password::class),
+            $container->get(SessionCredentials::class),
+            $container->get(LoginCredentials::class),
+            $container->get(UserProvided::class),
+            $container->get(GlobalAuth::class),
+            $container->get(UserGlobalAuth::class),
+
+            // AuthMechanism::SCHEME_PUBLICKEY mechanisms
+            $container->get(RSA::class),
+            $container->get(RSAPrivateKey::class),
+
+            // AuthMechanism::SCHEME_OPENSTACK mechanisms
+            $container->get(OpenStackV2::class),
+            $container->get(OpenStackV3::class),
+            $container->get(Rackspace::class),
+
+            // Specialized mechanisms
+            $container->get(AccessKey::class),
+            $container->get(KerberosAuth::class),
+            $container->get(KerberosApacheAuth::class),
+        ];
+    }
 }

apps/files_external/lib/MountConfig.php

Indentation +160 added lines, -160 removed lines

@@ -27,176 +27,176 @@
  * Class to configure mount.json globally and for users
  */
 class MountConfig {
-	// TODO: make this class non-static and give it a proper namespace
+    // TODO: make this class non-static and give it a proper namespace
 
-	public const MOUNT_TYPE_GLOBAL = 'global';
-	public const MOUNT_TYPE_GROUP = 'group';
-	public const MOUNT_TYPE_USER = 'user';
-	public const MOUNT_TYPE_PERSONAL = 'personal';
+    public const MOUNT_TYPE_GLOBAL = 'global';
+    public const MOUNT_TYPE_GROUP = 'group';
+    public const MOUNT_TYPE_USER = 'user';
+    public const MOUNT_TYPE_PERSONAL = 'personal';
 
-	// whether to skip backend test (for unit tests, as this static class is not mockable)
-	public static $skipTest = false;
+    // whether to skip backend test (for unit tests, as this static class is not mockable)
+    public static $skipTest = false;
 
-	public function __construct(
-		private UserGlobalStoragesService $userGlobalStorageService,
-		private UserStoragesService $userStorageService,
-		private GlobalStoragesService $globalStorageService,
-	) {
-	}
+    public function __construct(
+        private UserGlobalStoragesService $userGlobalStorageService,
+        private UserStoragesService $userStorageService,
+        private GlobalStoragesService $globalStorageService,
+    ) {
+    }
 
-	/**
-	 * @param mixed $input
-	 * @param string|null $userId
-	 * @return mixed
-	 * @throws QueryException
-	 * @since 16.0.0
-	 */
-	public static function substitutePlaceholdersInConfig($input, ?string $userId = null) {
-		/** @var BackendService $backendService */
-		$backendService = Server::get(BackendService::class);
-		/** @var IConfigHandler[] $handlers */
-		$handlers = $backendService->getConfigHandlers();
-		foreach ($handlers as $handler) {
-			if ($handler instanceof UserContext && $userId !== null) {
-				$handler->setUserId($userId);
-			}
-			$input = $handler->handle($input);
-		}
-		return $input;
-	}
+    /**
+     * @param mixed $input
+     * @param string|null $userId
+     * @return mixed
+     * @throws QueryException
+     * @since 16.0.0
+     */
+    public static function substitutePlaceholdersInConfig($input, ?string $userId = null) {
+        /** @var BackendService $backendService */
+        $backendService = Server::get(BackendService::class);
+        /** @var IConfigHandler[] $handlers */
+        $handlers = $backendService->getConfigHandlers();
+        foreach ($handlers as $handler) {
+            if ($handler instanceof UserContext && $userId !== null) {
+                $handler->setUserId($userId);
+            }
+            $input = $handler->handle($input);
+        }
+        return $input;
+    }
 
-	/**
-	 * Test connecting using the given backend configuration
-	 *
-	 * @param string $class backend class name
-	 * @param array $options backend configuration options
-	 * @param boolean $isPersonal
-	 * @return int see self::STATUS_*
-	 * @throws \Exception
-	 */
-	public static function getBackendStatus($class, $options) {
-		if (self::$skipTest) {
-			return StorageNotAvailableException::STATUS_SUCCESS;
-		}
-		foreach ($options as $key => &$option) {
-			if ($key === 'password') {
-				// no replacements in passwords
-				continue;
-			}
-			$option = self::substitutePlaceholdersInConfig($option);
-		}
-		if (class_exists($class)) {
-			try {
-				/** @var Common $storage */
-				$storage = new $class($options);
+    /**
+     * Test connecting using the given backend configuration
+     *
+     * @param string $class backend class name
+     * @param array $options backend configuration options
+     * @param boolean $isPersonal
+     * @return int see self::STATUS_*
+     * @throws \Exception
+     */
+    public static function getBackendStatus($class, $options) {
+        if (self::$skipTest) {
+            return StorageNotAvailableException::STATUS_SUCCESS;
+        }
+        foreach ($options as $key => &$option) {
+            if ($key === 'password') {
+                // no replacements in passwords
+                continue;
+            }
+            $option = self::substitutePlaceholdersInConfig($option);
+        }
+        if (class_exists($class)) {
+            try {
+                /** @var Common $storage */
+                $storage = new $class($options);
 
-				try {
-					$result = $storage->test();
-					$storage->setAvailability($result);
-					if ($result) {
-						return StorageNotAvailableException::STATUS_SUCCESS;
-					}
-				} catch (\Exception $e) {
-					$storage->setAvailability(false);
-					throw $e;
-				}
-			} catch (\Exception $exception) {
-				Server::get(LoggerInterface::class)->error($exception->getMessage(), ['exception' => $exception, 'app' => 'files_external']);
-				throw $exception;
-			}
-		}
-		return StorageNotAvailableException::STATUS_ERROR;
-	}
+                try {
+                    $result = $storage->test();
+                    $storage->setAvailability($result);
+                    if ($result) {
+                        return StorageNotAvailableException::STATUS_SUCCESS;
+                    }
+                } catch (\Exception $e) {
+                    $storage->setAvailability(false);
+                    throw $e;
+                }
+            } catch (\Exception $exception) {
+                Server::get(LoggerInterface::class)->error($exception->getMessage(), ['exception' => $exception, 'app' => 'files_external']);
+                throw $exception;
+            }
+        }
+        return StorageNotAvailableException::STATUS_ERROR;
+    }
 
-	/**
-	 * Encrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function encryptPasswords($options) {
-		if (isset($options['password'])) {
-			$options['password_encrypted'] = self::encryptPassword($options['password']);
-			// do not unset the password, we want to keep the keys order
-			// on load... because that's how the UI currently works
-			$options['password'] = '';
-		}
-		return $options;
-	}
+    /**
+     * Encrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function encryptPasswords($options) {
+        if (isset($options['password'])) {
+            $options['password_encrypted'] = self::encryptPassword($options['password']);
+            // do not unset the password, we want to keep the keys order
+            // on load... because that's how the UI currently works
+            $options['password'] = '';
+        }
+        return $options;
+    }
 
-	/**
-	 * Decrypt passwords in the given config options
-	 *
-	 * @param array $options mount options
-	 * @return array updated options
-	 */
-	public static function decryptPasswords($options) {
-		// note: legacy options might still have the unencrypted password in the "password" field
-		if (isset($options['password_encrypted'])) {
-			$options['password'] = self::decryptPassword($options['password_encrypted']);
-			unset($options['password_encrypted']);
-		}
-		return $options;
-	}
+    /**
+     * Decrypt passwords in the given config options
+     *
+     * @param array $options mount options
+     * @return array updated options
+     */
+    public static function decryptPasswords($options) {
+        // note: legacy options might still have the unencrypted password in the "password" field
+        if (isset($options['password_encrypted'])) {
+            $options['password'] = self::decryptPassword($options['password_encrypted']);
+            unset($options['password_encrypted']);
+        }
+        return $options;
+    }
 
-	/**
-	 * Encrypt a single password
-	 *
-	 * @param string $password plain text password
-	 * @return string encrypted password
-	 */
-	private static function encryptPassword($password) {
-		$cipher = self::getCipher();
-		$iv = Server::get(ISecureRandom::class)->generate(16);
-		$cipher->setIV($iv);
-		return base64_encode($iv . $cipher->encrypt($password));
-	}
+    /**
+     * Encrypt a single password
+     *
+     * @param string $password plain text password
+     * @return string encrypted password
+     */
+    private static function encryptPassword($password) {
+        $cipher = self::getCipher();
+        $iv = Server::get(ISecureRandom::class)->generate(16);
+        $cipher->setIV($iv);
+        return base64_encode($iv . $cipher->encrypt($password));
+    }
 
-	/**
-	 * Decrypts a single password
-	 *
-	 * @param string $encryptedPassword encrypted password
-	 * @return string plain text password
-	 */
-	private static function decryptPassword($encryptedPassword) {
-		$cipher = self::getCipher();
-		$binaryPassword = base64_decode($encryptedPassword);
-		$iv = substr($binaryPassword, 0, 16);
-		$cipher->setIV($iv);
-		$binaryPassword = substr($binaryPassword, 16);
-		return $cipher->decrypt($binaryPassword);
-	}
+    /**
+     * Decrypts a single password
+     *
+     * @param string $encryptedPassword encrypted password
+     * @return string plain text password
+     */
+    private static function decryptPassword($encryptedPassword) {
+        $cipher = self::getCipher();
+        $binaryPassword = base64_decode($encryptedPassword);
+        $iv = substr($binaryPassword, 0, 16);
+        $cipher->setIV($iv);
+        $binaryPassword = substr($binaryPassword, 16);
+        return $cipher->decrypt($binaryPassword);
+    }
 
-	/**
-	 * Returns the encryption cipher
-	 *
-	 * @return AES
-	 */
-	private static function getCipher() {
-		$cipher = new AES(AES::MODE_CBC);
-		$cipher->setKey(Server::get(IConfig::class)->getSystemValue('passwordsalt', null));
-		return $cipher;
-	}
+    /**
+     * Returns the encryption cipher
+     *
+     * @return AES
+     */
+    private static function getCipher() {
+        $cipher = new AES(AES::MODE_CBC);
+        $cipher->setKey(Server::get(IConfig::class)->getSystemValue('passwordsalt', null));
+        return $cipher;
+    }
 
-	/**
-	 * Computes a hash based on the given configuration.
-	 * This is mostly used to find out whether configurations
-	 * are the same.
-	 *
-	 * @param array $config
-	 * @return string
-	 */
-	public static function makeConfigHash($config) {
-		$data = json_encode(
-			[
-				'c' => $config['backend'],
-				'a' => $config['authMechanism'],
-				'm' => $config['mountpoint'],
-				'o' => $config['options'],
-				'p' => $config['priority'] ?? -1,
-				'mo' => $config['mountOptions'] ?? [],
-			]
-		);
-		return hash('md5', $data);
-	}
+    /**
+     * Computes a hash based on the given configuration.
+     * This is mostly used to find out whether configurations
+     * are the same.
+     *
+     * @param array $config
+     * @return string
+     */
+    public static function makeConfigHash($config) {
+        $data = json_encode(
+            [
+                'c' => $config['backend'],
+                'a' => $config['authMechanism'],
+                'm' => $config['mountpoint'],
+                'o' => $config['options'],
+                'p' => $config['priority'] ?? -1,
+                'mo' => $config['mountOptions'] ?? [],
+            ]
+        );
+        return hash('md5', $data);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -149,7 +149,7 @@
 		$cipher = self::getCipher();
 		$iv = Server::get(ISecureRandom::class)->generate(16);
 		$cipher->setIV($iv);
-		return base64_encode($iv . $cipher->encrypt($password));
+		return base64_encode($iv.$cipher->encrypt($password));
 	}
 
 	/**

apps/files_external/lib/Controller/GlobalStoragesController.php

Indentation +152 added lines, -152 removed lines

@@ -23,167 +23,167 @@
  * 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 LoggerInterface $logger
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 * @param IConfig $config
-	 */
-	public function __construct(
-		$appName,
-		IRequest $request,
-		IL10N $l10n,
-		GlobalStoragesService $globalStoragesService,
-		LoggerInterface $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager,
-		IConfig $config,
-	) {
-		parent::__construct(
-			$appName,
-			$request,
-			$l10n,
-			$globalStoragesService,
-			$logger,
-			$userSession,
-			$groupManager,
-			$config
-		);
-	}
+    /**
+     * 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 LoggerInterface $logger
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     * @param IConfig $config
+     */
+    public function __construct(
+        $appName,
+        IRequest $request,
+        IL10N $l10n,
+        GlobalStoragesService $globalStoragesService,
+        LoggerInterface $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager,
+        IConfig $config,
+    ) {
+        parent::__construct(
+            $appName,
+            $request,
+            $l10n,
+            $globalStoragesService,
+            $logger,
+            $userSession,
+            $groupManager,
+            $config
+        );
+    }
 
-	/**
-	 * 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
-	 */
-	#[PasswordConfirmationRequired(strict: true)]
-	public function create(
-		string $mountPoint,
-		string $backend,
-		string $authMechanism,
-		$backendOptions,
-		$mountOptions,
-		$applicableUsers,
-		$applicableGroups,
-		$priority,
-	) {
-		$canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
-		if (!$canCreateNewLocalStorage && $backend === 'local') {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Forbidden to manage local mounts')
-				],
-				Http::STATUS_FORBIDDEN
-			);
-		}
+    /**
+     * 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
+     */
+    #[PasswordConfirmationRequired(strict: true)]
+    public function create(
+        string $mountPoint,
+        string $backend,
+        string $authMechanism,
+        $backendOptions,
+        $mountOptions,
+        $applicableUsers,
+        $applicableGroups,
+        $priority,
+    ) {
+        $canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
+        if (!$canCreateNewLocalStorage && $backend === 'local') {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Forbidden to manage local mounts')
+                ],
+                Http::STATUS_FORBIDDEN
+            );
+        }
 
-		$newStorage = $this->createStorage(
-			$mountPoint,
-			$backend,
-			$authMechanism,
-			$backendOptions,
-			$mountOptions,
-			$applicableUsers,
-			$applicableGroups,
-			$priority
-		);
-		if ($newStorage instanceof DataResponse) {
-			return $newStorage;
-		}
+        $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(
-			$newStorage->jsonSerialize(true),
-			Http::STATUS_CREATED
-		);
-	}
+        return new DataResponse(
+            $newStorage->jsonSerialize(true),
+            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 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
-	 */
-	#[PasswordConfirmationRequired(strict: true)]
-	public function update(
-		int $id,
-		string $mountPoint,
-		string $backend,
-		string $authMechanism,
-		$backendOptions,
-		$mountOptions,
-		$applicableUsers,
-		$applicableGroups,
-		$priority,
-	) {
-		$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 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
+     */
+    #[PasswordConfirmationRequired(strict: true)]
+    public function update(
+        int $id,
+        string $mountPoint,
+        string $backend,
+        string $authMechanism,
+        $backendOptions,
+        $mountOptions,
+        $applicableUsers,
+        $applicableGroups,
+        $priority,
+    ) {
+        $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' => $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' => $this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		$this->updateStorageStatus($storage);
+        $this->updateStorageStatus($storage);
 
-		return new DataResponse(
-			$storage->jsonSerialize(true),
-			Http::STATUS_OK
-		);
-	}
+        return new DataResponse(
+            $storage->jsonSerialize(true),
+            Http::STATUS_OK
+        );
+    }
 }

apps/files_external/lib/Controller/UserGlobalStoragesController.php

Indentation +160 added lines, -160 removed lines

@@ -30,164 +30,164 @@
  * 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 LoggerInterface $logger
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$appName,
-		IRequest $request,
-		IL10N $l10n,
-		UserGlobalStoragesService $userGlobalStoragesService,
-		LoggerInterface $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager,
-		IConfig $config,
-	) {
-		parent::__construct(
-			$appName,
-			$request,
-			$l10n,
-			$userGlobalStoragesService,
-			$logger,
-			$userSession,
-			$groupManager,
-			$config
-		);
-	}
-
-	/**
-	 * Get all storage entries
-	 *
-	 * @return DataResponse
-	 */
-	#[NoAdminRequired]
-	public function index() {
-		/** @var UserGlobalStoragesService */
-		$service = $this->service;
-		$storages = array_map(function ($storage) {
-			// remove configuration data, this must be kept private
-			$this->sanitizeStorage($storage);
-			return $storage->jsonSerialize(true);
-		}, $service->getUniqueStorages());
-
-		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
-	 * @return DataResponse
-	 */
-	#[NoAdminRequired]
-	public function show($id) {
-		try {
-			$storage = $this->service->getStorage($id);
-
-			$this->updateStorageStatus($storage);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Storage with ID "%d" not found', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->sanitizeStorage($storage);
-
-		$data = $storage->jsonSerialize(true);
-		$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
-	 *
-	 * @return DataResponse
-	 */
-	#[NoAdminRequired]
-	#[PasswordConfirmationRequired(strict: true)]
-	public function update(
-		int $id,
-		$backendOptions,
-	) {
-		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' => $this->l10n->t('Storage with ID "%d" is not editable by non-admins', [$id])
-					],
-					Http::STATUS_FORBIDDEN
-				);
-			}
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Storage with ID "%d" not found', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage);
-		$this->sanitizeStorage($storage);
-
-		return new DataResponse(
-			$storage->jsonSerialize(true),
-			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 LoggerInterface $logger
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $appName,
+        IRequest $request,
+        IL10N $l10n,
+        UserGlobalStoragesService $userGlobalStoragesService,
+        LoggerInterface $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager,
+        IConfig $config,
+    ) {
+        parent::__construct(
+            $appName,
+            $request,
+            $l10n,
+            $userGlobalStoragesService,
+            $logger,
+            $userSession,
+            $groupManager,
+            $config
+        );
+    }
+
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     */
+    #[NoAdminRequired]
+    public function index() {
+        /** @var UserGlobalStoragesService */
+        $service = $this->service;
+        $storages = array_map(function ($storage) {
+            // remove configuration data, this must be kept private
+            $this->sanitizeStorage($storage);
+            return $storage->jsonSerialize(true);
+        }, $service->getUniqueStorages());
+
+        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
+     * @return DataResponse
+     */
+    #[NoAdminRequired]
+    public function show($id) {
+        try {
+            $storage = $this->service->getStorage($id);
+
+            $this->updateStorageStatus($storage);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->sanitizeStorage($storage);
+
+        $data = $storage->jsonSerialize(true);
+        $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
+     *
+     * @return DataResponse
+     */
+    #[NoAdminRequired]
+    #[PasswordConfirmationRequired(strict: true)]
+    public function update(
+        int $id,
+        $backendOptions,
+    ) {
+        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' => $this->l10n->t('Storage with ID "%d" is not editable by non-admins', [$id])
+                    ],
+                    Http::STATUS_FORBIDDEN
+                );
+            }
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage);
+        $this->sanitizeStorage($storage);
+
+        return new DataResponse(
+            $storage->jsonSerialize(true),
+            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/StoragesController.php

Indentation +265 added lines, -265 removed lines

@@ -30,288 +30,288 @@
  * Base class for storages controllers
  */
 abstract class StoragesController extends Controller {
-	/**
-	 * 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 LoggerInterface $logger
-	 */
-	public function __construct(
-		$appName,
-		IRequest $request,
-		protected IL10N $l10n,
-		protected StoragesService $service,
-		protected LoggerInterface $logger,
-		protected IUserSession $userSession,
-		protected IGroupManager $groupManager,
-		protected IConfig $config,
-	) {
-		parent::__construct($appName, $request);
-	}
+    /**
+     * 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 LoggerInterface $logger
+     */
+    public function __construct(
+        $appName,
+        IRequest $request,
+        protected IL10N $l10n,
+        protected StoragesService $service,
+        protected LoggerInterface $logger,
+        protected IUserSession $userSession,
+        protected IGroupManager $groupManager,
+        protected IConfig $config,
+    ) {
+        parent::__construct($appName, $request);
+    }
 
-	/**
-	 * 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(
-		string $mountPoint,
-		string $backend,
-		string $authMechanism,
-		$backendOptions,
-		$mountOptions = null,
-		$applicableUsers = null,
-		$applicableGroups = null,
-		$priority = null,
-	) {
-		$canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
-		if (!$canCreateNewLocalStorage && $backend === 'local') {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Forbidden to manage local mounts')
-				],
-				Http::STATUS_FORBIDDEN
-			);
-		}
+    /**
+     * 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(
+        string $mountPoint,
+        string $backend,
+        string $authMechanism,
+        $backendOptions,
+        $mountOptions = null,
+        $applicableUsers = null,
+        $applicableGroups = null,
+        $priority = null,
+    ) {
+        $canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
+        if (!$canCreateNewLocalStorage && $backend === 'local') {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Forbidden to manage local mounts')
+                ],
+                Http::STATUS_FORBIDDEN
+            );
+        }
 
-		try {
-			return $this->service->createStorage(
-				$mountPoint,
-				$backend,
-				$authMechanism,
-				$backendOptions,
-				$mountOptions,
-				$applicableUsers,
-				$applicableGroups,
-				$priority
-			);
-		} catch (\InvalidArgumentException $e) {
-			$this->logger->error($e->getMessage(), ['exception' => $e]);
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Invalid backend or authentication mechanism class')
-				],
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
-	}
+        try {
+            return $this->service->createStorage(
+                $mountPoint,
+                $backend,
+                $authMechanism,
+                $backendOptions,
+                $mountOptions,
+                $applicableUsers,
+                $applicableGroups,
+                $priority
+            );
+        } catch (\InvalidArgumentException $e) {
+            $this->logger->error($e->getMessage(), ['exception' => $e]);
+            return new DataResponse(
+                [
+                    'message' => $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' => $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' => $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' => $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' => $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' => $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' => $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' => $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' => $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' => $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' => $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' => $this->l10n->t('Unsatisfied backend parameters'),
-				],
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
-		if (!$authMechanism->validateStorage($storage)) {
-			// unsatisfied parameters
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Unsatisfied authentication mechanism parameters'),
-				],
-				Http::STATUS_UNPROCESSABLE_ENTITY
-			);
-		}
+        if (!$backend->validateStorage($storage)) {
+            // unsatisfied parameters
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Unsatisfied backend parameters'),
+                ],
+                Http::STATUS_UNPROCESSABLE_ENTITY
+            );
+        }
+        if (!$authMechanism->validateStorage($storage)) {
+            // unsatisfied parameters
+            return new DataResponse(
+                [
+                    'message' => $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
-	 */
-	protected function updateStorageStatus(StorageConfig &$storage) {
-		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
+     */
+    protected function updateStorageStatus(StorageConfig &$storage) {
+        try {
+            $this->manipulateStorageConfig($storage);
 
-			/** @var Backend */
-			$backend = $storage->getBackend();
-			// update status (can be time-consuming)
-			$storage->setStatus(
-				MountConfig::getBackendStatus(
-					$backend->getStorageClass(),
-					$storage->getBackendOptions(),
-				)
-			);
-		} catch (InsufficientDataForMeaningfulAnswerException $e) {
-			$status = $e->getCode() ?: StorageNotAvailableException::STATUS_INDETERMINATE;
-			$storage->setStatus(
-				(int)$status,
-				$this->l10n->t('Insufficient data: %s', [$e->getMessage()])
-			);
-		} catch (StorageNotAvailableException $e) {
-			$storage->setStatus(
-				(int)$e->getCode(),
-				$e->getMessage(),
-			);
-		} catch (\Exception $e) {
-			// FIXME: convert storage exceptions to StorageNotAvailableException
-			$storage->setStatus(
-				StorageNotAvailableException::STATUS_ERROR,
-				get_class($e) . ': ' . $e->getMessage()
-			);
-		}
-	}
+            /** @var Backend */
+            $backend = $storage->getBackend();
+            // update status (can be time-consuming)
+            $storage->setStatus(
+                MountConfig::getBackendStatus(
+                    $backend->getStorageClass(),
+                    $storage->getBackendOptions(),
+                )
+            );
+        } catch (InsufficientDataForMeaningfulAnswerException $e) {
+            $status = $e->getCode() ?: StorageNotAvailableException::STATUS_INDETERMINATE;
+            $storage->setStatus(
+                (int)$status,
+                $this->l10n->t('Insufficient data: %s', [$e->getMessage()])
+            );
+        } catch (StorageNotAvailableException $e) {
+            $storage->setStatus(
+                (int)$e->getCode(),
+                $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 = array_map(static fn ($storage) => $storage->jsonSerialize(true), $this->service->getStorages());
+    /**
+     * Get all storage entries
+     *
+     * @return DataResponse
+     */
+    public function index() {
+        $storages = array_map(static fn ($storage) => $storage->jsonSerialize(true), $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
-	 *
-	 * @return DataResponse
-	 */
-	public function show(int $id) {
-		try {
-			$storage = $this->service->getStorage($id);
+    /**
+     * Get an external storage entry.
+     *
+     * @param int $id storage id
+     *
+     * @return DataResponse
+     */
+    public function show(int $id) {
+        try {
+            $storage = $this->service->getStorage($id);
 
-			$this->updateStorageStatus($storage);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Storage with ID "%d" not found', [$id]),
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
+            $this->updateStorageStatus($storage);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Storage with ID "%d" not found', [$id]),
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
 
-		$data = $storage->jsonSerialize(true);
-		$isAdmin = $this->groupManager->isAdmin($this->userSession->getUser()->getUID());
-		$data['can_edit'] = $storage->getType() === StorageConfig::MOUNT_TYPE_PERSONAL || $isAdmin;
+        $data = $storage->jsonSerialize(true);
+        $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
-	 */
-	#[PasswordConfirmationRequired(strict: true)]
-	public function destroy(int $id) {
-		try {
-			$this->service->removeStorage($id);
-		} catch (NotFoundException $e) {
-			return new DataResponse(
-				[
-					'message' => $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
+     */
+    #[PasswordConfirmationRequired(strict: true)]
+    public function destroy(int $id) {
+        try {
+            $this->service->removeStorage($id);
+        } catch (NotFoundException $e) {
+            return new DataResponse(
+                [
+                    'message' => $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);
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -214,7 +214,7 @@ 
 	 *
 	 * @param StorageConfig $storage storage configuration
 	 */
-	protected function updateStorageStatus(StorageConfig &$storage) {
+	protected function updateStorageStatus(StorageConfig & $storage) {
 		try {
 			$this->manipulateStorageConfig($storage);
 
@@ -230,19 +230,19 @@ 
 		} catch (InsufficientDataForMeaningfulAnswerException $e) {
 			$status = $e->getCode() ?: StorageNotAvailableException::STATUS_INDETERMINATE;
 			$storage->setStatus(
-				(int)$status,
+				(int) $status,
 				$this->l10n->t('Insufficient data: %s', [$e->getMessage()])
 			);
 		} catch (StorageNotAvailableException $e) {
 			$storage->setStatus(
-				(int)$e->getCode(),
+				(int) $e->getCode(),
 				$e->getMessage(),
 			);
 		} catch (\Exception $e) {
 			// FIXME: convert storage exceptions to StorageNotAvailableException
 			$storage->setStatus(
 				StorageNotAvailableException::STATUS_ERROR,
-				get_class($e) . ': ' . $e->getMessage()
+				get_class($e).': '.$e->getMessage()
 			);
 		}
 	}

apps/files_external/lib/Controller/UserStoragesController.php

Indentation +185 added lines, -185 removed lines

@@ -27,189 +27,189 @@
  * 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 LoggerInterface $logger
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$appName,
-		IRequest $request,
-		IL10N $l10n,
-		UserStoragesService $userStoragesService,
-		LoggerInterface $logger,
-		IUserSession $userSession,
-		IGroupManager $groupManager,
-		IConfig $config,
-	) {
-		parent::__construct(
-			$appName,
-			$request,
-			$l10n,
-			$userStoragesService,
-			$logger,
-			$userSession,
-			$groupManager,
-			$config
-		);
-	}
-
-	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
-	 *
-	 * @return DataResponse
-	 */
-	#[NoAdminRequired]
-	public function index() {
-		return parent::index();
-	}
-
-	/**
-	 * Return storage
-	 *
-	 * {@inheritdoc}
-	 */
-	#[NoAdminRequired]
-	public function show(int $id) {
-		return parent::show($id);
-	}
-
-	/**
-	 * 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]
-	#[PasswordConfirmationRequired(strict: true)]
-	public function create(
-		string $mountPoint,
-		string $backend,
-		string $authMechanism,
-		$backendOptions,
-		$mountOptions,
-	) {
-		$canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
-		if (!$canCreateNewLocalStorage && $backend === 'local') {
-			return new DataResponse(
-				[
-					'message' => $this->l10n->t('Forbidden to manage local mounts')
-				],
-				Http::STATUS_FORBIDDEN
-			);
-		}
-		$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);
-
-		$newStorage->setType(StorageConfig::MOUNT_TYPE_PERSONAL);
-		return new DataResponse(
-			$newStorage->jsonSerialize(true),
-			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
-	 *
-	 * @return DataResponse
-	 */
-	#[NoAdminRequired]
-	#[PasswordConfirmationRequired(strict: true)]
-	public function update(
-		int $id,
-		string $mountPoint,
-		string $backend,
-		string $authMechanism,
-		$backendOptions,
-		$mountOptions,
-	) {
-		$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' => $this->l10n->t('Storage with ID "%d" not found', [$id])
-				],
-				Http::STATUS_NOT_FOUND
-			);
-		}
-
-		$this->updateStorageStatus($storage);
-
-		return new DataResponse(
-			$storage->jsonSerialize(true),
-			Http::STATUS_OK
-		);
-	}
-
-	/**
-	 * Delete storage
-	 *
-	 * {@inheritdoc}
-	 */
-	#[NoAdminRequired]
-	#[PasswordConfirmationRequired(strict: true)]
-	public function destroy(int $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 LoggerInterface $logger
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $appName,
+        IRequest $request,
+        IL10N $l10n,
+        UserStoragesService $userStoragesService,
+        LoggerInterface $logger,
+        IUserSession $userSession,
+        IGroupManager $groupManager,
+        IConfig $config,
+    ) {
+        parent::__construct(
+            $appName,
+            $request,
+            $l10n,
+            $userStoragesService,
+            $logger,
+            $userSession,
+            $groupManager,
+            $config
+        );
+    }
+
+    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
+     *
+     * @return DataResponse
+     */
+    #[NoAdminRequired]
+    public function index() {
+        return parent::index();
+    }
+
+    /**
+     * Return storage
+     *
+     * {@inheritdoc}
+     */
+    #[NoAdminRequired]
+    public function show(int $id) {
+        return parent::show($id);
+    }
+
+    /**
+     * 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]
+    #[PasswordConfirmationRequired(strict: true)]
+    public function create(
+        string $mountPoint,
+        string $backend,
+        string $authMechanism,
+        $backendOptions,
+        $mountOptions,
+    ) {
+        $canCreateNewLocalStorage = $this->config->getSystemValue('files_external_allow_create_new_local', true);
+        if (!$canCreateNewLocalStorage && $backend === 'local') {
+            return new DataResponse(
+                [
+                    'message' => $this->l10n->t('Forbidden to manage local mounts')
+                ],
+                Http::STATUS_FORBIDDEN
+            );
+        }
+        $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);
+
+        $newStorage->setType(StorageConfig::MOUNT_TYPE_PERSONAL);
+        return new DataResponse(
+            $newStorage->jsonSerialize(true),
+            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
+     *
+     * @return DataResponse
+     */
+    #[NoAdminRequired]
+    #[PasswordConfirmationRequired(strict: true)]
+    public function update(
+        int $id,
+        string $mountPoint,
+        string $backend,
+        string $authMechanism,
+        $backendOptions,
+        $mountOptions,
+    ) {
+        $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' => $this->l10n->t('Storage with ID "%d" not found', [$id])
+                ],
+                Http::STATUS_NOT_FOUND
+            );
+        }
+
+        $this->updateStorageStatus($storage);
+
+        return new DataResponse(
+            $storage->jsonSerialize(true),
+            Http::STATUS_OK
+        );
+    }
+
+    /**
+     * Delete storage
+     *
+     * {@inheritdoc}
+     */
+    #[NoAdminRequired]
+    #[PasswordConfirmationRequired(strict: true)]
+    public function destroy(int $id) {
+        return parent::destroy($id);
+    }
 }

apps/files_external/lib/Controller/AjaxController.php

Indentation +99 added lines, -99 removed lines

@@ -21,113 +21,113 @@
 use OCP\IUserSession;
 
 class AjaxController extends Controller {
-	/**
-	 * @param string $appName
-	 * @param IRequest $request
-	 * @param RSA $rsaMechanism
-	 * @param GlobalAuth $globalAuth
-	 * @param IUserSession $userSession
-	 * @param IGroupManager $groupManager
-	 */
-	public function __construct(
-		$appName,
-		IRequest $request,
-		private RSA $rsaMechanism,
-		private GlobalAuth $globalAuth,
-		private IUserSession $userSession,
-		private IGroupManager $groupManager,
-		private IUserManager $userManager,
-		private IL10N $l10n,
-	) {
-		parent::__construct($appName, $request);
-	}
+    /**
+     * @param string $appName
+     * @param IRequest $request
+     * @param RSA $rsaMechanism
+     * @param GlobalAuth $globalAuth
+     * @param IUserSession $userSession
+     * @param IGroupManager $groupManager
+     */
+    public function __construct(
+        $appName,
+        IRequest $request,
+        private RSA $rsaMechanism,
+        private GlobalAuth $globalAuth,
+        private IUserSession $userSession,
+        private IGroupManager $groupManager,
+        private IUserManager $userManager,
+        private IL10N $l10n,
+    ) {
+        parent::__construct($appName, $request);
+    }
 
-	/**
-	 * Returns a list of users and groups that match the given pattern.
-	 * Used for user and group picker in the admin settings.
-	 *
-	 * @param string $pattern The search pattern
-	 * @param int|null $limit The maximum number of results to return
-	 * @param int|null $offset The offset from which to start returning results
-	 * @return JSONResponse
-	 */
-	public function getApplicableEntities(string $pattern = '', ?int $limit = null, ?int $offset = null): JSONResponse {
-		$groups = [];
-		foreach ($this->groupManager->search($pattern, $limit, $offset) as $group) {
-			$groups[$group->getGID()] = $group->getDisplayName();
-		}
+    /**
+     * Returns a list of users and groups that match the given pattern.
+     * Used for user and group picker in the admin settings.
+     *
+     * @param string $pattern The search pattern
+     * @param int|null $limit The maximum number of results to return
+     * @param int|null $offset The offset from which to start returning results
+     * @return JSONResponse
+     */
+    public function getApplicableEntities(string $pattern = '', ?int $limit = null, ?int $offset = null): JSONResponse {
+        $groups = [];
+        foreach ($this->groupManager->search($pattern, $limit, $offset) as $group) {
+            $groups[$group->getGID()] = $group->getDisplayName();
+        }
 
-		$users = [];
-		foreach ($this->userManager->searchDisplayName($pattern, $limit, $offset) as $user) {
-			$users[$user->getUID()] = $user->getDisplayName();
-		}
+        $users = [];
+        foreach ($this->userManager->searchDisplayName($pattern, $limit, $offset) as $user) {
+            $users[$user->getUID()] = $user->getDisplayName();
+        }
 
-		$results = ['groups' => $groups, 'users' => $users];
-		return new JSONResponse($results);
-	}
+        $results = ['groups' => $groups, 'users' => $users];
+        return new JSONResponse($results);
+    }
 
-	/**
-	 * @param int $keyLength
-	 * @return array
-	 */
-	private function generateSshKeys($keyLength) {
-		$key = $this->rsaMechanism->createKey($keyLength);
-		// Replace the placeholder label with a more meaningful one
-		$key['publickey'] = str_replace('phpseclib-generated-key', gethostname(), $key['publickey']);
+    /**
+     * @param int $keyLength
+     * @return array
+     */
+    private function generateSshKeys($keyLength) {
+        $key = $this->rsaMechanism->createKey($keyLength);
+        // Replace the placeholder label with a more meaningful one
+        $key['publickey'] = str_replace('phpseclib-generated-key', gethostname(), $key['publickey']);
 
-		return $key;
-	}
+        return $key;
+    }
 
-	/**
-	 * Generates an SSH public/private key pair.
-	 *
-	 * @param int $keyLength
-	 */
-	#[NoAdminRequired]
-	public function getSshKeys($keyLength = 1024) {
-		$key = $this->generateSshKeys($keyLength);
-		return new JSONResponse([
-			'data' => [
-				'private_key' => $key['privatekey'],
-				'public_key' => $key['publickey']
-			],
-			'status' => 'success',
-		]);
-	}
+    /**
+     * Generates an SSH public/private key pair.
+     *
+     * @param int $keyLength
+     */
+    #[NoAdminRequired]
+    public function getSshKeys($keyLength = 1024) {
+        $key = $this->generateSshKeys($keyLength);
+        return new JSONResponse([
+            'data' => [
+                'private_key' => $key['privatekey'],
+                'public_key' => $key['publickey']
+            ],
+            'status' => 'success',
+        ]);
+    }
 
-	/**
-	 * @param string $uid
-	 * @param string $user
-	 * @param string $password
-	 * @return JSONResponse
-	 */
-	#[NoAdminRequired]
-	#[PasswordConfirmationRequired(strict: true)]
-	public function saveGlobalCredentials($uid, $user, $password): JSONResponse {
-		$currentUser = $this->userSession->getUser();
-		if ($currentUser === null) {
-			return new JSONResponse([
-				'status' => 'error',
-				'message' => $this->l10n->t('You are not logged in'),
-			], Http::STATUS_UNAUTHORIZED);
-		}
+    /**
+     * @param string $uid
+     * @param string $user
+     * @param string $password
+     * @return JSONResponse
+     */
+    #[NoAdminRequired]
+    #[PasswordConfirmationRequired(strict: true)]
+    public function saveGlobalCredentials($uid, $user, $password): JSONResponse {
+        $currentUser = $this->userSession->getUser();
+        if ($currentUser === null) {
+            return new JSONResponse([
+                'status' => 'error',
+                'message' => $this->l10n->t('You are not logged in'),
+            ], Http::STATUS_UNAUTHORIZED);
+        }
 
-		// Non-admins can only edit their own credentials
-		// Admin can edit global credentials
-		$allowedToEdit = $uid === ''
-			? $this->groupManager->isAdmin($currentUser->getUID())
-			: $currentUser->getUID() === $uid;
+        // Non-admins can only edit their own credentials
+        // Admin can edit global credentials
+        $allowedToEdit = $uid === ''
+            ? $this->groupManager->isAdmin($currentUser->getUID())
+            : $currentUser->getUID() === $uid;
 
-		if ($allowedToEdit) {
-			$this->globalAuth->saveAuth($uid, $user, $password);
-			return new JSONResponse([
-				'status' => 'success',
-			]);
-		}
+        if ($allowedToEdit) {
+            $this->globalAuth->saveAuth($uid, $user, $password);
+            return new JSONResponse([
+                'status' => 'success',
+            ]);
+        }
 
-		return new JSONResponse([
-			'status' => 'success',
-			'message' => $this->l10n->t('Permission denied'),
-		], Http::STATUS_FORBIDDEN);
-	}
+        return new JSONResponse([
+            'status' => 'success',
+            'message' => $this->l10n->t('Permission denied'),
+        ], Http::STATUS_FORBIDDEN);
+    }
 }