nextcloud / server

apps/files_external/lib/Service/StoragesService.php

Spacing +12 added lines, -12 removed lines

@@ -72,17 +72,17 @@ 
 	}
 
 	protected function getStorageConfigFromDBMount(array $mount) {
-		$applicableUsers = array_filter($mount['applicable'], function ($applicable) {
+		$applicableUsers = array_filter($mount['applicable'], function($applicable) {
 			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
 		});
-		$applicableUsers = array_map(function ($applicable) {
+		$applicableUsers = array_map(function($applicable) {
 			return $applicable['value'];
 		}, $applicableUsers);
 
-		$applicableGroups = array_filter($mount['applicable'], function ($applicable) {
+		$applicableGroups = array_filter($mount['applicable'], function($applicable) {
 			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
 		});
-		$applicableGroups = array_map(function ($applicable) {
+		$applicableGroups = array_map(function($applicable) {
 			return $applicable['value'];
 		}, $applicableGroups);
 
@@ -98,7 +98,7 @@ 
 				$mount['priority']
 			);
 			$config->setType($mount['type']);
-			$config->setId((int)$mount['mount_id']);
+			$config->setId((int) $mount['mount_id']);
 			return $config;
 		} catch (\UnexpectedValueException $e) {
 			// don't die if a storage backend doesn't exist
@@ -126,11 +126,11 @@ 
 	protected function readConfig() {
 		$mounts = $this->readDBConfig();
 		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
+		$configs = array_filter($configs, function($config) {
 			return $config instanceof StorageConfig;
 		});
 
-		$keys = array_map(function (StorageConfig $config) {
+		$keys = array_map(function(StorageConfig $config) {
 			return $config->getId();
 		}, $configs);
 
@@ -149,14 +149,14 @@ 
 		$mount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($mount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 
 		$config = $this->getStorageConfigFromDBMount($mount);
 		if ($this->isApplicable($config)) {
 			return $config;
 		} else {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 	}
 
@@ -379,13 +379,13 @@ 
 		$existingMount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found while updating storage');
 		}
 
 		$oldStorage = $this->getStorageConfigFromDBMount($existingMount);
 
 		if ($oldStorage->getBackend() instanceof InvalidBackend) {
-			throw new NotFoundException('Storage with id "' . $id . '" cannot be edited due to missing backend');
+			throw new NotFoundException('Storage with id "'.$id.'" cannot be edited due to missing backend');
 		}
 
 		$removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
@@ -462,7 +462,7 @@ 
 		$existingMount = $this->dbConfig->getMountById($id);
 
 		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
+			throw new NotFoundException('Storage with ID "'.$id.'" not found');
 		}
 
 		$this->dbConfig->removeMount($id);

Indentation +444 added lines, -444 removed lines

@@ -28,448 +28,448 @@
  */
 abstract class StoragesService {
 
-	/**
-	 * @param BackendService $backendService
-	 * @param DBConfigService $dbConfig
-	 * @param IUserMountCache $userMountCache
-	 * @param IEventDispatcher $eventDispatcher
-	 */
-	public function __construct(
-		protected BackendService $backendService,
-		protected DBConfigService $dbConfig,
-		protected IUserMountCache $userMountCache,
-		protected IEventDispatcher $eventDispatcher,
-	) {
-	}
-
-	protected function readDBConfig() {
-		return $this->dbConfig->getAdminMounts();
-	}
-
-	protected function getStorageConfigFromDBMount(array $mount) {
-		$applicableUsers = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
-		});
-		$applicableUsers = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableUsers);
-
-		$applicableGroups = array_filter($mount['applicable'], function ($applicable) {
-			return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
-		});
-		$applicableGroups = array_map(function ($applicable) {
-			return $applicable['value'];
-		}, $applicableGroups);
-
-		try {
-			$config = $this->createStorage(
-				$mount['mount_point'],
-				$mount['storage_backend'],
-				$mount['auth_backend'],
-				$mount['config'],
-				$mount['options'],
-				array_values($applicableUsers),
-				array_values($applicableGroups),
-				$mount['priority']
-			);
-			$config->setType($mount['type']);
-			$config->setId((int)$mount['mount_id']);
-			return $config;
-		} catch (\UnexpectedValueException $e) {
-			// don't die if a storage backend doesn't exist
-			Server::get(LoggerInterface::class)->error('Could not load storage.', [
-				'app' => 'files_external',
-				'exception' => $e,
-			]);
-			return null;
-		} catch (\InvalidArgumentException $e) {
-			Server::get(LoggerInterface::class)->error('Could not load storage.', [
-				'app' => 'files_external',
-				'exception' => $e,
-			]);
-			return null;
-		}
-	}
-
-	/**
-	 * Read the external storage config
-	 *
-	 * @return array map of storage id to storage config
-	 */
-	protected function readConfig() {
-		$mounts = $this->readDBConfig();
-		$configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
-		$configs = array_filter($configs, function ($config) {
-			return $config instanceof StorageConfig;
-		});
-
-		$keys = array_map(function (StorageConfig $config) {
-			return $config->getId();
-		}, $configs);
-
-		return array_combine($keys, $configs);
-	}
-
-	/**
-	 * Get a storage with status
-	 *
-	 * @param int $id storage id
-	 *
-	 * @return StorageConfig
-	 * @throws NotFoundException if the storage with the given id was not found
-	 */
-	public function getStorage(int $id) {
-		$mount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($mount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$config = $this->getStorageConfigFromDBMount($mount);
-		if ($this->isApplicable($config)) {
-			return $config;
-		} else {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-	}
-
-	/**
-	 * Check whether this storage service should provide access to a storage
-	 *
-	 * @param StorageConfig $config
-	 * @return bool
-	 */
-	abstract protected function isApplicable(StorageConfig $config);
-
-	/**
-	 * Gets all storages, valid or not
-	 *
-	 * @return StorageConfig[] array of storage configs
-	 */
-	public function getAllStorages() {
-		return $this->readConfig();
-	}
-
-	/**
-	 * Gets all valid storages
-	 *
-	 * @return StorageConfig[]
-	 */
-	public function getStorages() {
-		return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
-	}
-
-	/**
-	 * Validate storage
-	 * FIXME: De-duplicate with StoragesController::validate()
-	 *
-	 * @param StorageConfig $storage
-	 * @return bool
-	 */
-	protected function validateStorage(StorageConfig $storage) {
-		/** @var Backend */
-		$backend = $storage->getBackend();
-		/** @var AuthMechanism */
-		$authMechanism = $storage->getAuthMechanism();
-
-		if (!$backend->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use backend
-			return false;
-		}
-		if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
-			// not permitted to use auth mechanism
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Get the visibility type for this controller, used in validation
-	 *
-	 * @return int BackendService::VISIBILITY_* constants
-	 */
-	abstract public function getVisibilityType();
-
-	/**
-	 * @return integer
-	 */
-	protected function getType() {
-		return DBConfigService::MOUNT_TYPE_ADMIN;
-	}
-
-	/**
-	 * Add new storage to the configuration
-	 *
-	 * @param StorageConfig $newStorage storage attributes
-	 *
-	 * @return StorageConfig storage config, with added id
-	 */
-	public function addStorage(StorageConfig $newStorage) {
-		$allStorages = $this->readConfig();
-
-		$configId = $this->dbConfig->addMount(
-			$newStorage->getMountPoint(),
-			$newStorage->getBackend()->getIdentifier(),
-			$newStorage->getAuthMechanism()->getIdentifier(),
-			$newStorage->getPriority(),
-			$this->getType()
-		);
-
-		$newStorage->setId($configId);
-
-		foreach ($newStorage->getApplicableUsers() as $user) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($newStorage->getApplicableGroups() as $group) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($newStorage->getBackendOptions() as $key => $value) {
-			$this->dbConfig->setConfig($configId, $key, $value);
-		}
-		foreach ($newStorage->getMountOptions() as $key => $value) {
-			$this->dbConfig->setOption($configId, $key, $value);
-		}
-
-		if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
-			$this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		// add new storage
-		$allStorages[$configId] = $newStorage;
-
-		$this->triggerHooks($newStorage, Filesystem::signal_create_mount);
-
-		$newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
-		return $newStorage;
-	}
-
-	/**
-	 * Create a storage from its parameters
-	 *
-	 * @param string $mountPoint storage mount point
-	 * @param string $backendIdentifier backend identifier
-	 * @param string $authMechanismIdentifier authentication mechanism identifier
-	 * @param array $backendOptions backend-specific options
-	 * @param array|null $mountOptions mount-specific options
-	 * @param array|null $applicableUsers users for which to mount the storage
-	 * @param array|null $applicableGroups groups for which to mount the storage
-	 * @param int|null $priority priority
-	 *
-	 * @return StorageConfig
-	 */
-	public function createStorage(
-		$mountPoint,
-		$backendIdentifier,
-		$authMechanismIdentifier,
-		$backendOptions,
-		$mountOptions = null,
-		$applicableUsers = null,
-		$applicableGroups = null,
-		$priority = null,
-	) {
-		$backend = $this->backendService->getBackend($backendIdentifier);
-		if (!$backend) {
-			$backend = new InvalidBackend($backendIdentifier);
-		}
-		$authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
-		if (!$authMechanism) {
-			$authMechanism = new InvalidAuth($authMechanismIdentifier);
-		}
-		$newStorage = new StorageConfig();
-		$newStorage->setMountPoint($mountPoint);
-		$newStorage->setBackend($backend);
-		$newStorage->setAuthMechanism($authMechanism);
-		$newStorage->setBackendOptions($backendOptions);
-		if (isset($mountOptions)) {
-			$newStorage->setMountOptions($mountOptions);
-		}
-		if (isset($applicableUsers)) {
-			$newStorage->setApplicableUsers($applicableUsers);
-		}
-		if (isset($applicableGroups)) {
-			$newStorage->setApplicableGroups($applicableGroups);
-		}
-		if (isset($priority)) {
-			$newStorage->setPriority($priority);
-		}
-
-		return $newStorage;
-	}
-
-	/**
-	 * Triggers the given hook signal for all the applicables given
-	 *
-	 * @param string $signal signal
-	 * @param string $mountPoint hook mount point param
-	 * @param string $mountType hook mount type param
-	 * @param array $applicableArray array of applicable users/groups for which to trigger the hook
-	 */
-	protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray): void {
-		$this->eventDispatcher->dispatchTyped(new InvalidateMountCacheEvent(null));
-		foreach ($applicableArray as $applicable) {
-			Util::emitHook(
-				Filesystem::CLASSNAME,
-				$signal,
-				[
-					Filesystem::signal_param_path => $mountPoint,
-					Filesystem::signal_param_mount_type => $mountType,
-					Filesystem::signal_param_users => $applicable,
-				]
-			);
-		}
-	}
-
-	/**
-	 * Triggers $signal for all applicable users of the given
-	 * storage
-	 *
-	 * @param StorageConfig $storage storage data
-	 * @param string $signal signal to trigger
-	 */
-	abstract protected function triggerHooks(StorageConfig $storage, $signal);
-
-	/**
-	 * Triggers signal_create_mount or signal_delete_mount to
-	 * accommodate for additions/deletions in applicableUsers
-	 * and applicableGroups fields.
-	 *
-	 * @param StorageConfig $oldStorage old storage data
-	 * @param StorageConfig $newStorage new storage data
-	 */
-	abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
-
-	/**
-	 * Update storage to the configuration
-	 *
-	 * @param StorageConfig $updatedStorage storage attributes
-	 *
-	 * @return StorageConfig storage config
-	 * @throws NotFoundException if the given storage does not exist in the config
-	 */
-	public function updateStorage(StorageConfig $updatedStorage) {
-		$id = $updatedStorage->getId();
-
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
-		}
-
-		$oldStorage = $this->getStorageConfigFromDBMount($existingMount);
-
-		if ($oldStorage->getBackend() instanceof InvalidBackend) {
-			throw new NotFoundException('Storage with id "' . $id . '" cannot be edited due to missing backend');
-		}
-
-		$removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
-		$removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
-		$addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
-		$addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
-
-		$oldUserCount = count($oldStorage->getApplicableUsers());
-		$oldGroupCount = count($oldStorage->getApplicableGroups());
-		$newUserCount = count($updatedStorage->getApplicableUsers());
-		$newGroupCount = count($updatedStorage->getApplicableGroups());
-		$wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
-		$isGlobal = ($newUserCount + $newGroupCount) === 0;
-
-		foreach ($removedUsers as $user) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($removedGroups as $group) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-		foreach ($addedUsers as $user) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
-		}
-		foreach ($addedGroups as $group) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
-		}
-
-		if ($wasGlobal && !$isGlobal) {
-			$this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		} elseif (!$wasGlobal && $isGlobal) {
-			$this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
-		}
-
-		$changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
-		$changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
-
-		foreach ($changedConfig as $key => $value) {
-			if ($value !== DefinitionParameter::UNMODIFIED_PLACEHOLDER) {
-				$this->dbConfig->setConfig($id, $key, $value);
-			}
-		}
-		foreach ($changedOptions as $key => $value) {
-			$this->dbConfig->setOption($id, $key, $value);
-		}
-
-		if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
-			$this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
-		}
-
-		if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
-			$this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
-		}
-
-		$this->triggerChangeHooks($oldStorage, $updatedStorage);
-
-		if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
-			$this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
-		} else {
-			$storageId = $this->getStorageId($updatedStorage);
-			foreach ($removedUsers as $userId) {
-				$this->userMountCache->removeUserStorageMount($storageId, $userId);
-			}
-		}
-
-		return $this->getStorage($id);
-	}
-
-	/**
-	 * Delete the storage with the given id.
-	 *
-	 * @param int $id storage id
-	 *
-	 * @throws NotFoundException if no storage was found with the given id
-	 */
-	public function removeStorage(int $id) {
-		$existingMount = $this->dbConfig->getMountById($id);
-
-		if (!is_array($existingMount)) {
-			throw new NotFoundException('Storage with ID "' . $id . '" not found');
-		}
-
-		$this->dbConfig->removeMount($id);
-
-		$deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
-		$this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
-
-		// delete oc_storages entries and oc_filecache
-		Storage::cleanByMountId($id);
-	}
-
-	/**
-	 * Construct the storage implementation
-	 *
-	 * @param StorageConfig $storageConfig
-	 * @return int
-	 */
-	private function getStorageId(StorageConfig $storageConfig) {
-		try {
-			$class = $storageConfig->getBackend()->getStorageClass();
-			/** @var \OC\Files\Storage\Storage $storage */
-			$storage = new $class($storageConfig->getBackendOptions());
-
-			// auth mechanism should fire first
-			$storage = $storageConfig->getBackend()->wrapStorage($storage);
-			$storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
-
-			/** @var \OC\Files\Storage\Storage $storage */
-			return $storage->getStorageCache()->getNumericId();
-		} catch (\Exception $e) {
-			return -1;
-		}
-	}
+    /**
+     * @param BackendService $backendService
+     * @param DBConfigService $dbConfig
+     * @param IUserMountCache $userMountCache
+     * @param IEventDispatcher $eventDispatcher
+     */
+    public function __construct(
+        protected BackendService $backendService,
+        protected DBConfigService $dbConfig,
+        protected IUserMountCache $userMountCache,
+        protected IEventDispatcher $eventDispatcher,
+    ) {
+    }
+
+    protected function readDBConfig() {
+        return $this->dbConfig->getAdminMounts();
+    }
+
+    protected function getStorageConfigFromDBMount(array $mount) {
+        $applicableUsers = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_USER;
+        });
+        $applicableUsers = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableUsers);
+
+        $applicableGroups = array_filter($mount['applicable'], function ($applicable) {
+            return $applicable['type'] === DBConfigService::APPLICABLE_TYPE_GROUP;
+        });
+        $applicableGroups = array_map(function ($applicable) {
+            return $applicable['value'];
+        }, $applicableGroups);
+
+        try {
+            $config = $this->createStorage(
+                $mount['mount_point'],
+                $mount['storage_backend'],
+                $mount['auth_backend'],
+                $mount['config'],
+                $mount['options'],
+                array_values($applicableUsers),
+                array_values($applicableGroups),
+                $mount['priority']
+            );
+            $config->setType($mount['type']);
+            $config->setId((int)$mount['mount_id']);
+            return $config;
+        } catch (\UnexpectedValueException $e) {
+            // don't die if a storage backend doesn't exist
+            Server::get(LoggerInterface::class)->error('Could not load storage.', [
+                'app' => 'files_external',
+                'exception' => $e,
+            ]);
+            return null;
+        } catch (\InvalidArgumentException $e) {
+            Server::get(LoggerInterface::class)->error('Could not load storage.', [
+                'app' => 'files_external',
+                'exception' => $e,
+            ]);
+            return null;
+        }
+    }
+
+    /**
+     * Read the external storage config
+     *
+     * @return array map of storage id to storage config
+     */
+    protected function readConfig() {
+        $mounts = $this->readDBConfig();
+        $configs = array_map([$this, 'getStorageConfigFromDBMount'], $mounts);
+        $configs = array_filter($configs, function ($config) {
+            return $config instanceof StorageConfig;
+        });
+
+        $keys = array_map(function (StorageConfig $config) {
+            return $config->getId();
+        }, $configs);
+
+        return array_combine($keys, $configs);
+    }
+
+    /**
+     * Get a storage with status
+     *
+     * @param int $id storage id
+     *
+     * @return StorageConfig
+     * @throws NotFoundException if the storage with the given id was not found
+     */
+    public function getStorage(int $id) {
+        $mount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($mount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $config = $this->getStorageConfigFromDBMount($mount);
+        if ($this->isApplicable($config)) {
+            return $config;
+        } else {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+    }
+
+    /**
+     * Check whether this storage service should provide access to a storage
+     *
+     * @param StorageConfig $config
+     * @return bool
+     */
+    abstract protected function isApplicable(StorageConfig $config);
+
+    /**
+     * Gets all storages, valid or not
+     *
+     * @return StorageConfig[] array of storage configs
+     */
+    public function getAllStorages() {
+        return $this->readConfig();
+    }
+
+    /**
+     * Gets all valid storages
+     *
+     * @return StorageConfig[]
+     */
+    public function getStorages() {
+        return array_filter($this->getAllStorages(), [$this, 'validateStorage']);
+    }
+
+    /**
+     * Validate storage
+     * FIXME: De-duplicate with StoragesController::validate()
+     *
+     * @param StorageConfig $storage
+     * @return bool
+     */
+    protected function validateStorage(StorageConfig $storage) {
+        /** @var Backend */
+        $backend = $storage->getBackend();
+        /** @var AuthMechanism */
+        $authMechanism = $storage->getAuthMechanism();
+
+        if (!$backend->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use backend
+            return false;
+        }
+        if (!$authMechanism->isVisibleFor($this->getVisibilityType())) {
+            // not permitted to use auth mechanism
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Get the visibility type for this controller, used in validation
+     *
+     * @return int BackendService::VISIBILITY_* constants
+     */
+    abstract public function getVisibilityType();
+
+    /**
+     * @return integer
+     */
+    protected function getType() {
+        return DBConfigService::MOUNT_TYPE_ADMIN;
+    }
+
+    /**
+     * Add new storage to the configuration
+     *
+     * @param StorageConfig $newStorage storage attributes
+     *
+     * @return StorageConfig storage config, with added id
+     */
+    public function addStorage(StorageConfig $newStorage) {
+        $allStorages = $this->readConfig();
+
+        $configId = $this->dbConfig->addMount(
+            $newStorage->getMountPoint(),
+            $newStorage->getBackend()->getIdentifier(),
+            $newStorage->getAuthMechanism()->getIdentifier(),
+            $newStorage->getPriority(),
+            $this->getType()
+        );
+
+        $newStorage->setId($configId);
+
+        foreach ($newStorage->getApplicableUsers() as $user) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($newStorage->getApplicableGroups() as $group) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($newStorage->getBackendOptions() as $key => $value) {
+            $this->dbConfig->setConfig($configId, $key, $value);
+        }
+        foreach ($newStorage->getMountOptions() as $key => $value) {
+            $this->dbConfig->setOption($configId, $key, $value);
+        }
+
+        if (count($newStorage->getApplicableUsers()) === 0 && count($newStorage->getApplicableGroups()) === 0) {
+            $this->dbConfig->addApplicable($configId, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        // add new storage
+        $allStorages[$configId] = $newStorage;
+
+        $this->triggerHooks($newStorage, Filesystem::signal_create_mount);
+
+        $newStorage->setStatus(StorageNotAvailableException::STATUS_SUCCESS);
+        return $newStorage;
+    }
+
+    /**
+     * Create a storage from its parameters
+     *
+     * @param string $mountPoint storage mount point
+     * @param string $backendIdentifier backend identifier
+     * @param string $authMechanismIdentifier authentication mechanism identifier
+     * @param array $backendOptions backend-specific options
+     * @param array|null $mountOptions mount-specific options
+     * @param array|null $applicableUsers users for which to mount the storage
+     * @param array|null $applicableGroups groups for which to mount the storage
+     * @param int|null $priority priority
+     *
+     * @return StorageConfig
+     */
+    public function createStorage(
+        $mountPoint,
+        $backendIdentifier,
+        $authMechanismIdentifier,
+        $backendOptions,
+        $mountOptions = null,
+        $applicableUsers = null,
+        $applicableGroups = null,
+        $priority = null,
+    ) {
+        $backend = $this->backendService->getBackend($backendIdentifier);
+        if (!$backend) {
+            $backend = new InvalidBackend($backendIdentifier);
+        }
+        $authMechanism = $this->backendService->getAuthMechanism($authMechanismIdentifier);
+        if (!$authMechanism) {
+            $authMechanism = new InvalidAuth($authMechanismIdentifier);
+        }
+        $newStorage = new StorageConfig();
+        $newStorage->setMountPoint($mountPoint);
+        $newStorage->setBackend($backend);
+        $newStorage->setAuthMechanism($authMechanism);
+        $newStorage->setBackendOptions($backendOptions);
+        if (isset($mountOptions)) {
+            $newStorage->setMountOptions($mountOptions);
+        }
+        if (isset($applicableUsers)) {
+            $newStorage->setApplicableUsers($applicableUsers);
+        }
+        if (isset($applicableGroups)) {
+            $newStorage->setApplicableGroups($applicableGroups);
+        }
+        if (isset($priority)) {
+            $newStorage->setPriority($priority);
+        }
+
+        return $newStorage;
+    }
+
+    /**
+     * Triggers the given hook signal for all the applicables given
+     *
+     * @param string $signal signal
+     * @param string $mountPoint hook mount point param
+     * @param string $mountType hook mount type param
+     * @param array $applicableArray array of applicable users/groups for which to trigger the hook
+     */
+    protected function triggerApplicableHooks($signal, $mountPoint, $mountType, $applicableArray): void {
+        $this->eventDispatcher->dispatchTyped(new InvalidateMountCacheEvent(null));
+        foreach ($applicableArray as $applicable) {
+            Util::emitHook(
+                Filesystem::CLASSNAME,
+                $signal,
+                [
+                    Filesystem::signal_param_path => $mountPoint,
+                    Filesystem::signal_param_mount_type => $mountType,
+                    Filesystem::signal_param_users => $applicable,
+                ]
+            );
+        }
+    }
+
+    /**
+     * Triggers $signal for all applicable users of the given
+     * storage
+     *
+     * @param StorageConfig $storage storage data
+     * @param string $signal signal to trigger
+     */
+    abstract protected function triggerHooks(StorageConfig $storage, $signal);
+
+    /**
+     * Triggers signal_create_mount or signal_delete_mount to
+     * accommodate for additions/deletions in applicableUsers
+     * and applicableGroups fields.
+     *
+     * @param StorageConfig $oldStorage old storage data
+     * @param StorageConfig $newStorage new storage data
+     */
+    abstract protected function triggerChangeHooks(StorageConfig $oldStorage, StorageConfig $newStorage);
+
+    /**
+     * Update storage to the configuration
+     *
+     * @param StorageConfig $updatedStorage storage attributes
+     *
+     * @return StorageConfig storage config
+     * @throws NotFoundException if the given storage does not exist in the config
+     */
+    public function updateStorage(StorageConfig $updatedStorage) {
+        $id = $updatedStorage->getId();
+
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found while updating storage');
+        }
+
+        $oldStorage = $this->getStorageConfigFromDBMount($existingMount);
+
+        if ($oldStorage->getBackend() instanceof InvalidBackend) {
+            throw new NotFoundException('Storage with id "' . $id . '" cannot be edited due to missing backend');
+        }
+
+        $removedUsers = array_diff($oldStorage->getApplicableUsers(), $updatedStorage->getApplicableUsers());
+        $removedGroups = array_diff($oldStorage->getApplicableGroups(), $updatedStorage->getApplicableGroups());
+        $addedUsers = array_diff($updatedStorage->getApplicableUsers(), $oldStorage->getApplicableUsers());
+        $addedGroups = array_diff($updatedStorage->getApplicableGroups(), $oldStorage->getApplicableGroups());
+
+        $oldUserCount = count($oldStorage->getApplicableUsers());
+        $oldGroupCount = count($oldStorage->getApplicableGroups());
+        $newUserCount = count($updatedStorage->getApplicableUsers());
+        $newGroupCount = count($updatedStorage->getApplicableGroups());
+        $wasGlobal = ($oldUserCount + $oldGroupCount) === 0;
+        $isGlobal = ($newUserCount + $newGroupCount) === 0;
+
+        foreach ($removedUsers as $user) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($removedGroups as $group) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+        foreach ($addedUsers as $user) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_USER, $user);
+        }
+        foreach ($addedGroups as $group) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GROUP, $group);
+        }
+
+        if ($wasGlobal && !$isGlobal) {
+            $this->dbConfig->removeApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        } elseif (!$wasGlobal && $isGlobal) {
+            $this->dbConfig->addApplicable($id, DBConfigService::APPLICABLE_TYPE_GLOBAL, null);
+        }
+
+        $changedConfig = array_diff_assoc($updatedStorage->getBackendOptions(), $oldStorage->getBackendOptions());
+        $changedOptions = array_diff_assoc($updatedStorage->getMountOptions(), $oldStorage->getMountOptions());
+
+        foreach ($changedConfig as $key => $value) {
+            if ($value !== DefinitionParameter::UNMODIFIED_PLACEHOLDER) {
+                $this->dbConfig->setConfig($id, $key, $value);
+            }
+        }
+        foreach ($changedOptions as $key => $value) {
+            $this->dbConfig->setOption($id, $key, $value);
+        }
+
+        if ($updatedStorage->getMountPoint() !== $oldStorage->getMountPoint()) {
+            $this->dbConfig->setMountPoint($id, $updatedStorage->getMountPoint());
+        }
+
+        if ($updatedStorage->getAuthMechanism()->getIdentifier() !== $oldStorage->getAuthMechanism()->getIdentifier()) {
+            $this->dbConfig->setAuthBackend($id, $updatedStorage->getAuthMechanism()->getIdentifier());
+        }
+
+        $this->triggerChangeHooks($oldStorage, $updatedStorage);
+
+        if (($wasGlobal && !$isGlobal) || count($removedGroups) > 0) { // to expensive to properly handle these on the fly
+            $this->userMountCache->remoteStorageMounts($this->getStorageId($updatedStorage));
+        } else {
+            $storageId = $this->getStorageId($updatedStorage);
+            foreach ($removedUsers as $userId) {
+                $this->userMountCache->removeUserStorageMount($storageId, $userId);
+            }
+        }
+
+        return $this->getStorage($id);
+    }
+
+    /**
+     * Delete the storage with the given id.
+     *
+     * @param int $id storage id
+     *
+     * @throws NotFoundException if no storage was found with the given id
+     */
+    public function removeStorage(int $id) {
+        $existingMount = $this->dbConfig->getMountById($id);
+
+        if (!is_array($existingMount)) {
+            throw new NotFoundException('Storage with ID "' . $id . '" not found');
+        }
+
+        $this->dbConfig->removeMount($id);
+
+        $deletedStorage = $this->getStorageConfigFromDBMount($existingMount);
+        $this->triggerHooks($deletedStorage, Filesystem::signal_delete_mount);
+
+        // delete oc_storages entries and oc_filecache
+        Storage::cleanByMountId($id);
+    }
+
+    /**
+     * Construct the storage implementation
+     *
+     * @param StorageConfig $storageConfig
+     * @return int
+     */
+    private function getStorageId(StorageConfig $storageConfig) {
+        try {
+            $class = $storageConfig->getBackend()->getStorageClass();
+            /** @var \OC\Files\Storage\Storage $storage */
+            $storage = new $class($storageConfig->getBackendOptions());
+
+            // auth mechanism should fire first
+            $storage = $storageConfig->getBackend()->wrapStorage($storage);
+            $storage = $storageConfig->getAuthMechanism()->wrapStorage($storage);
+
+            /** @var \OC\Files\Storage\Storage $storage */
+            return $storage->getStorageCache()->getNumericId();
+        } catch (\Exception $e) {
+            return -1;
+        }
+    }
 }

lib/private/AppFramework/Middleware/Security/Exceptions/NotAdminException.php

Indentation +3 added lines, -3 removed lines

@@ -36,7 +36,7 @@
  * @package OC\AppFramework\Middleware\Security\Exceptions
  */
 class NotAdminException extends SecurityException {
-	public function __construct(string $message) {
-		parent::__construct($message, Http::STATUS_FORBIDDEN);
-	}
+    public function __construct(string $message) {
+        parent::__construct($message, Http::STATUS_FORBIDDEN);
+    }
 }

apps/dav/lib/Upload/ChunkingPlugin.php

Spacing +1 added lines, -1 removed lines

@@ -100,7 +100,7 @@
 
 		// casted to string because cast to float cause equality for non equal numbers
 		// and integer has the problem of limited size on 32 bit systems
-		if ((string)$expectedSize !== (string)$actualSize) {
+		if ((string) $expectedSize !== (string) $actualSize) {
 			throw new BadRequest("Chunks on server do not sum up to $expectedSize but to $actualSize bytes");
 		}
 	}

Indentation +83 added lines, -83 removed lines

@@ -18,97 +18,97 @@
 
 class ChunkingPlugin extends ServerPlugin {
 
-	/** @var Server */
-	private $server;
-	/** @var FutureFile */
-	private $sourceNode;
+    /** @var Server */
+    private $server;
+    /** @var FutureFile */
+    private $sourceNode;
 
-	/**
-	 * @inheritdoc
-	 */
-	public function initialize(Server $server) {
-		$server->on('beforeMove', [$this, 'beforeMove']);
-		$this->server = $server;
-	}
+    /**
+     * @inheritdoc
+     */
+    public function initialize(Server $server) {
+        $server->on('beforeMove', [$this, 'beforeMove']);
+        $this->server = $server;
+    }
 
-	/**
-	 * @param string $sourcePath source path
-	 * @param string $destination destination path
-	 * @return bool|void
-	 * @throws BadRequest
-	 * @throws NotFound
-	 */
-	public function beforeMove($sourcePath, $destination) {
-		$this->sourceNode = $this->server->tree->getNodeForPath($sourcePath);
-		if (!$this->sourceNode instanceof FutureFile) {
-			// skip handling as the source is not a chunked FutureFile
-			return;
-		}
+    /**
+     * @param string $sourcePath source path
+     * @param string $destination destination path
+     * @return bool|void
+     * @throws BadRequest
+     * @throws NotFound
+     */
+    public function beforeMove($sourcePath, $destination) {
+        $this->sourceNode = $this->server->tree->getNodeForPath($sourcePath);
+        if (!$this->sourceNode instanceof FutureFile) {
+            // skip handling as the source is not a chunked FutureFile
+            return;
+        }
 
-		try {
-			/** @var INode $destinationNode */
-			$destinationNode = $this->server->tree->getNodeForPath($destination);
-			if ($destinationNode instanceof Directory) {
-				throw new BadRequest("The given destination $destination is a directory.");
-			}
-		} catch (NotFound $e) {
-			// If the destination does not exist yet it's not a directory either ;)
-		}
+        try {
+            /** @var INode $destinationNode */
+            $destinationNode = $this->server->tree->getNodeForPath($destination);
+            if ($destinationNode instanceof Directory) {
+                throw new BadRequest("The given destination $destination is a directory.");
+            }
+        } catch (NotFound $e) {
+            // If the destination does not exist yet it's not a directory either ;)
+        }
 
-		$this->verifySize();
-		return $this->performMove($sourcePath, $destination);
-	}
+        $this->verifySize();
+        return $this->performMove($sourcePath, $destination);
+    }
 
-	/**
-	 * Move handler for future file.
-	 *
-	 * This overrides the default move behavior to prevent Sabre
-	 * to delete the target file before moving. Because deleting would
-	 * lose the file id and metadata.
-	 *
-	 * @param string $path source path
-	 * @param string $destination destination path
-	 * @return bool|void false to stop handling, void to skip this handler
-	 */
-	public function performMove($path, $destination) {
-		$fileExists = $this->server->tree->nodeExists($destination);
-		// do a move manually, skipping Sabre's default "delete" for existing nodes
-		try {
-			$this->server->tree->move($path, $destination);
-		} catch (Forbidden $e) {
-			$sourceNode = $this->server->tree->getNodeForPath($path);
-			if ($sourceNode instanceof FutureFile) {
-				$sourceNode->delete();
-			}
-			throw $e;
-		}
+    /**
+     * Move handler for future file.
+     *
+     * This overrides the default move behavior to prevent Sabre
+     * to delete the target file before moving. Because deleting would
+     * lose the file id and metadata.
+     *
+     * @param string $path source path
+     * @param string $destination destination path
+     * @return bool|void false to stop handling, void to skip this handler
+     */
+    public function performMove($path, $destination) {
+        $fileExists = $this->server->tree->nodeExists($destination);
+        // do a move manually, skipping Sabre's default "delete" for existing nodes
+        try {
+            $this->server->tree->move($path, $destination);
+        } catch (Forbidden $e) {
+            $sourceNode = $this->server->tree->getNodeForPath($path);
+            if ($sourceNode instanceof FutureFile) {
+                $sourceNode->delete();
+            }
+            throw $e;
+        }
 
-		// trigger all default events (copied from CorePlugin::move)
-		$this->server->emit('afterMove', [$path, $destination]);
-		$this->server->emit('afterUnbind', [$path]);
-		$this->server->emit('afterBind', [$destination]);
+        // trigger all default events (copied from CorePlugin::move)
+        $this->server->emit('afterMove', [$path, $destination]);
+        $this->server->emit('afterUnbind', [$path]);
+        $this->server->emit('afterBind', [$destination]);
 
-		$response = $this->server->httpResponse;
-		$response->setHeader('Content-Length', '0');
-		$response->setStatus($fileExists ? Http::STATUS_NO_CONTENT : Http::STATUS_CREATED);
+        $response = $this->server->httpResponse;
+        $response->setHeader('Content-Length', '0');
+        $response->setStatus($fileExists ? Http::STATUS_NO_CONTENT : Http::STATUS_CREATED);
 
-		return false;
-	}
+        return false;
+    }
 
-	/**
-	 * @throws BadRequest
-	 */
-	private function verifySize() {
-		$expectedSize = $this->server->httpRequest->getHeader('OC-Total-Length');
-		if ($expectedSize === null) {
-			return;
-		}
-		$actualSize = $this->sourceNode->getSize();
+    /**
+     * @throws BadRequest
+     */
+    private function verifySize() {
+        $expectedSize = $this->server->httpRequest->getHeader('OC-Total-Length');
+        if ($expectedSize === null) {
+            return;
+        }
+        $actualSize = $this->sourceNode->getSize();
 
-		// casted to string because cast to float cause equality for non equal numbers
-		// and integer has the problem of limited size on 32 bit systems
-		if ((string)$expectedSize !== (string)$actualSize) {
-			throw new BadRequest("Chunks on server do not sum up to $expectedSize but to $actualSize bytes");
-		}
-	}
+        // casted to string because cast to float cause equality for non equal numbers
+        // and integer has the problem of limited size on 32 bit systems
+        if ((string)$expectedSize !== (string)$actualSize) {
+            throw new BadRequest("Chunks on server do not sum up to $expectedSize but to $actualSize bytes");
+        }
+    }
 }

core/Migrations/Version14000Date20180129121024.php

Indentation +22 added lines, -22 removed lines

@@ -30,30 +30,30 @@
  * Delete the admin|personal sections and settings tables
  */
 class Version14000Date20180129121024 extends SimpleMigrationStep {
-	public function name(): string {
-		return 'Drop obsolete settings tables';
-	}
+    public function name(): string {
+        return 'Drop obsolete settings tables';
+    }
 
-	public function description(): string {
-		return 'Drops the following obsolete tables: "admin_sections", "admin_settings", "personal_sections" and "personal_settings"';
-	}
+    public function description(): string {
+        return 'Drops the following obsolete tables: "admin_sections", "admin_settings", "personal_sections" and "personal_settings"';
+    }
 
-	/**
-	 * @param IOutput $output
-	 * @param \Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
-	 * @param array $options
-	 * @return null|ISchemaWrapper
-	 * @since 13.0.0
-	 */
-	public function changeSchema(IOutput $output, \Closure $schemaClosure, array $options) {
-		/** @var ISchemaWrapper $schema */
-		$schema = $schemaClosure();
+    /**
+     * @param IOutput $output
+     * @param \Closure $schemaClosure The `\Closure` returns a `ISchemaWrapper`
+     * @param array $options
+     * @return null|ISchemaWrapper
+     * @since 13.0.0
+     */
+    public function changeSchema(IOutput $output, \Closure $schemaClosure, array $options) {
+        /** @var ISchemaWrapper $schema */
+        $schema = $schemaClosure();
 
-		$schema->dropTable('admin_sections');
-		$schema->dropTable('admin_settings');
-		$schema->dropTable('personal_sections');
-		$schema->dropTable('personal_settings');
+        $schema->dropTable('admin_sections');
+        $schema->dropTable('admin_settings');
+        $schema->dropTable('personal_sections');
+        $schema->dropTable('personal_settings');
 
-		return $schema;
-	}
+        return $schema;
+    }
 }

lib/public/SystemTag/SystemTagsEntityEvent.php

Spacing +1 added lines, -1 removed lines

@@ -62,7 +62,7 @@
 	 */
 	public function addEntityCollection(string $name, \Closure $entityExistsFunction) {
 		if (isset($this->collections[$name])) {
-			throw new \OutOfBoundsException('Duplicate entity name "' . $name . '"');
+			throw new \OutOfBoundsException('Duplicate entity name "'.$name.'"');
 		}
 
 		$this->collections[$name] = $entityExistsFunction;

Indentation +41 added lines, -41 removed lines

@@ -17,45 +17,45 @@
  * @since 28.0.0 Dispatched as a typed event
  */
 class SystemTagsEntityEvent extends Event {
-	/**
-	 * @since 9.1.0
-	 * @deprecated 22.0.0 Listen to the typed event instead
-	 */
-	public const EVENT_ENTITY = 'OCP\SystemTag\ISystemTagManager::registerEntity';
-
-	/** @var \Closure[] */
-	protected $collections;
-
-	/**
-	 * @since 9.1.0
-	 */
-	public function __construct() {
-		parent::__construct();
-		$this->collections = [];
-	}
-
-	/**
-	 * @param string $name
-	 * @param \Closure $entityExistsFunction The closure should take one
-	 *                                       argument, which is the id of the entity, that tags
-	 *                                       should be handled for. The return should then be bool,
-	 *                                       depending on whether tags are allowed (true) or not.
-	 * @throws \OutOfBoundsException when the entity name is already taken
-	 * @since 9.1.0
-	 */
-	public function addEntityCollection(string $name, \Closure $entityExistsFunction) {
-		if (isset($this->collections[$name])) {
-			throw new \OutOfBoundsException('Duplicate entity name "' . $name . '"');
-		}
-
-		$this->collections[$name] = $entityExistsFunction;
-	}
-
-	/**
-	 * @return \Closure[]
-	 * @since 9.1.0
-	 */
-	public function getEntityCollections(): array {
-		return $this->collections;
-	}
+    /**
+     * @since 9.1.0
+     * @deprecated 22.0.0 Listen to the typed event instead
+     */
+    public const EVENT_ENTITY = 'OCP\SystemTag\ISystemTagManager::registerEntity';
+
+    /** @var \Closure[] */
+    protected $collections;
+
+    /**
+     * @since 9.1.0
+     */
+    public function __construct() {
+        parent::__construct();
+        $this->collections = [];
+    }
+
+    /**
+     * @param string $name
+     * @param \Closure $entityExistsFunction The closure should take one
+     *                                       argument, which is the id of the entity, that tags
+     *                                       should be handled for. The return should then be bool,
+     *                                       depending on whether tags are allowed (true) or not.
+     * @throws \OutOfBoundsException when the entity name is already taken
+     * @since 9.1.0
+     */
+    public function addEntityCollection(string $name, \Closure $entityExistsFunction) {
+        if (isset($this->collections[$name])) {
+            throw new \OutOfBoundsException('Duplicate entity name "' . $name . '"');
+        }
+
+        $this->collections[$name] = $entityExistsFunction;
+    }
+
+    /**
+     * @return \Closure[]
+     * @since 9.1.0
+     */
+    public function getEntityCollections(): array {
+        return $this->collections;
+    }
 }

lib/public/User/Backend/ABackend.php

Spacing +1 added lines, -1 removed lines

@@ -67,6 +67,6 @@
 			$implements |= Backend::COUNT_USERS;
 		}
 
-		return (bool)($actions & $implements);
+		return (bool) ($actions & $implements);
 	}
 }

Indentation +35 added lines, -35 removed lines

@@ -34,41 +34,41 @@
  * @since 14.0.0
  */
 abstract class ABackend implements IUserBackend, UserInterface {
-	/**
-	 * @deprecated 14.0.0
-	 * @since 14.0.0
-	 *
-	 * @param int $actions The action to check for
-	 * @return bool
-	 */
-	public function implementsActions($actions): bool {
-		$implements = 0;
+    /**
+     * @deprecated 14.0.0
+     * @since 14.0.0
+     *
+     * @param int $actions The action to check for
+     * @return bool
+     */
+    public function implementsActions($actions): bool {
+        $implements = 0;
 
-		if ($this instanceof ICreateUserBackend) {
-			$implements |= Backend::CREATE_USER;
-		}
-		if ($this instanceof ISetPasswordBackend) {
-			$implements |= Backend::SET_PASSWORD;
-		}
-		if ($this instanceof ICheckPasswordBackend) {
-			$implements |= Backend::CHECK_PASSWORD;
-		}
-		if ($this instanceof IGetHomeBackend) {
-			$implements |= Backend::GET_HOME;
-		}
-		if ($this instanceof IGetDisplayNameBackend) {
-			$implements |= Backend::GET_DISPLAYNAME;
-		}
-		if ($this instanceof ISetDisplayNameBackend) {
-			$implements |= Backend::SET_DISPLAYNAME;
-		}
-		if ($this instanceof IProvideAvatarBackend) {
-			$implements |= Backend::PROVIDE_AVATAR;
-		}
-		if ($this instanceof ICountUsersBackend) {
-			$implements |= Backend::COUNT_USERS;
-		}
+        if ($this instanceof ICreateUserBackend) {
+            $implements |= Backend::CREATE_USER;
+        }
+        if ($this instanceof ISetPasswordBackend) {
+            $implements |= Backend::SET_PASSWORD;
+        }
+        if ($this instanceof ICheckPasswordBackend) {
+            $implements |= Backend::CHECK_PASSWORD;
+        }
+        if ($this instanceof IGetHomeBackend) {
+            $implements |= Backend::GET_HOME;
+        }
+        if ($this instanceof IGetDisplayNameBackend) {
+            $implements |= Backend::GET_DISPLAYNAME;
+        }
+        if ($this instanceof ISetDisplayNameBackend) {
+            $implements |= Backend::SET_DISPLAYNAME;
+        }
+        if ($this instanceof IProvideAvatarBackend) {
+            $implements |= Backend::PROVIDE_AVATAR;
+        }
+        if ($this instanceof ICountUsersBackend) {
+            $implements |= Backend::COUNT_USERS;
+        }
 
-		return (bool)($actions & $implements);
-	}
+        return (bool)($actions & $implements);
+    }
 }

apps/files_external/lib/Lib/Auth/SMB/KerberosAuth.php

Indentation +6 added lines, -6 removed lines

@@ -25,10 +25,10 @@
 use OCP\IL10N;
 
 class KerberosAuth extends AuthMechanism {
-	public function __construct(IL10N $l) {
-		$this
-			->setIdentifier('smb::kerberos')
-			->setScheme(self::SCHEME_SMB)
-			->setText($l->t('Kerberos ticket'));
-	}
+    public function __construct(IL10N $l) {
+        $this
+            ->setIdentifier('smb::kerberos')
+            ->setScheme(self::SCHEME_SMB)
+            ->setText($l->t('Kerberos ticket'));
+    }
 }

lib/private/Authentication/Token/PublicKeyTokenMapper.php

Spacing +1 added lines, -1 removed lines

@@ -129,7 +129,7 @@
 		$data = $result->fetchAll();
 		$result->closeCursor();
 
-		$entities = array_map(function ($row) {
+		$entities = array_map(function($row) {
 			return PublicKeyToken::fromRow($row);
 		}, $data);
 

Indentation +231 added lines, -231 removed lines

@@ -18,235 +18,235 @@
  * @template-extends QBMapper<PublicKeyToken>
  */
 class PublicKeyTokenMapper extends QBMapper {
-	public function __construct(IDBConnection $db) {
-		parent::__construct($db, 'authtoken');
-	}
-
-	/**
-	 * Invalidate (delete) a given token
-	 */
-	public function invalidate(string $token) {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$qb->delete($this->tableName)
-			->where($qb->expr()->eq('token', $qb->createNamedParameter($token)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
-			->executeStatement();
-	}
-
-	/**
-	 * @param int $olderThan
-	 * @param int $type
-	 * @param int|null $remember
-	 */
-	public function invalidateOld(int $olderThan, int $type = IToken::TEMPORARY_TOKEN, ?int $remember = null) {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$delete = $qb->delete($this->tableName)
-			->where($qb->expr()->lt('last_activity', $qb->createNamedParameter($olderThan, IQueryBuilder::PARAM_INT)))
-			->andWhere($qb->expr()->eq('type', $qb->createNamedParameter($type, IQueryBuilder::PARAM_INT)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
-		if ($remember !== null) {
-			$delete->andWhere($qb->expr()->eq('remember', $qb->createNamedParameter($remember, IQueryBuilder::PARAM_INT)));
-		}
-		$delete->executeStatement();
-	}
-
-	public function invalidateLastUsedBefore(string $uid, int $before): int {
-		$qb = $this->db->getQueryBuilder();
-		$qb->delete($this->tableName)
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->andWhere($qb->expr()->lt('last_activity', $qb->createNamedParameter($before, IQueryBuilder::PARAM_INT)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
-		return $qb->executeStatement();
-	}
-
-	/**
-	 * Get the user UID for the given token
-	 *
-	 * @throws DoesNotExistException
-	 */
-	public function getToken(string $token): PublicKeyToken {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$result = $qb->select('*')
-			->from($this->tableName)
-			->where($qb->expr()->eq('token', $qb->createNamedParameter($token)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
-			->executeQuery();
-
-		$data = $result->fetch();
-		$result->closeCursor();
-		if ($data === false) {
-			throw new DoesNotExistException('token does not exist');
-		}
-		return PublicKeyToken::fromRow($data);
-	}
-
-	/**
-	 * Get the token for $id
-	 *
-	 * @throws DoesNotExistException
-	 */
-	public function getTokenById(int $id): PublicKeyToken {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$result = $qb->select('*')
-			->from($this->tableName)
-			->where($qb->expr()->eq('id', $qb->createNamedParameter($id)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
-			->executeQuery();
-
-		$data = $result->fetch();
-		$result->closeCursor();
-		if ($data === false) {
-			throw new DoesNotExistException('token does not exist');
-		}
-		return PublicKeyToken::fromRow($data);
-	}
-
-	/**
-	 * Get all tokens of a user
-	 *
-	 * The provider may limit the number of result rows in case of an abuse
-	 * where a high number of (session) tokens is generated
-	 *
-	 * @param string $uid
-	 * @return PublicKeyToken[]
-	 */
-	public function getTokenByUser(string $uid): array {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$qb->select('*')
-			->from($this->tableName)
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
-			->setMaxResults(1000);
-		$result = $qb->executeQuery();
-		$data = $result->fetchAll();
-		$result->closeCursor();
-
-		$entities = array_map(function ($row) {
-			return PublicKeyToken::fromRow($row);
-		}, $data);
-
-		return $entities;
-	}
-
-	public function getTokenByUserAndId(string $uid, int $id): ?string {
-		/* @var $qb IQueryBuilder */
-		$qb = $this->db->getQueryBuilder();
-		$qb->select('token')
-			->from($this->tableName)
-			->where($qb->expr()->eq('id', $qb->createNamedParameter($id)))
-			->andWhere($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
-		return $qb->executeQuery()->fetchOne() ?: null;
-	}
-
-	/**
-	 * delete all auth token which belong to a specific client if the client was deleted
-	 *
-	 * @param string $name
-	 */
-	public function deleteByName(string $name) {
-		$qb = $this->db->getQueryBuilder();
-		$qb->delete($this->tableName)
-			->where($qb->expr()->eq('name', $qb->createNamedParameter($name), IQueryBuilder::PARAM_STR))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
-		$qb->executeStatement();
-	}
-
-	public function deleteTempToken(PublicKeyToken $except) {
-		$qb = $this->db->getQueryBuilder();
-
-		$qb->delete($this->tableName)
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($except->getUID())))
-			->andWhere($qb->expr()->eq('type', $qb->createNamedParameter(IToken::TEMPORARY_TOKEN)))
-			->andWhere($qb->expr()->neq('id', $qb->createNamedParameter($except->getId())))
-			->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
-
-		$qb->executeStatement();
-	}
-
-	public function hasExpiredTokens(string $uid): bool {
-		$qb = $this->db->getQueryBuilder();
-		$qb->select('*')
-			->from($this->tableName)
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
-			->andWhere($qb->expr()->eq('password_invalid', $qb->createNamedParameter(true), IQueryBuilder::PARAM_BOOL))
-			->setMaxResults(1);
-
-		$cursor = $qb->executeQuery();
-		$data = $cursor->fetchAll();
-		$cursor->closeCursor();
-
-		return count($data) === 1;
-	}
-
-	/**
-	 * Update the last activity timestamp
-	 *
-	 * In highly concurrent setups it can happen that two parallel processes
-	 * trigger the update at (nearly) the same time. In that special case it's
-	 * not necessary to hit the database with two actual updates. Therefore the
-	 * target last activity is included in the WHERE clause with a few seconds
-	 * of tolerance.
-	 *
-	 * Example:
-	 * - process 1 (P1) reads the token at timestamp 1500
-	 * - process 1 (P2) reads the token at timestamp 1501
-	 * - activity update interval is 100
-	 *
-	 * This means
-	 *
-	 * - P1 will see a last_activity smaller than the current time and update
-	 *   the token row
-	 * - If P2 reads after P1 had written, it will see 1600 as last activity
-	 *   and the comparison on last_activity won't be truthy. This means no rows
-	 *   need to be updated a second time
-	 * - If P2 reads before P1 had written, it will see 1501 as last activity,
-	 *   but the comparison on last_activity will still not be truthy and the
-	 *   token row is not updated a second time
-	 *
-	 * @param IToken $token
-	 * @param int $now
-	 */
-	public function updateActivity(IToken $token, int $now): void {
-		$qb = $this->db->getQueryBuilder();
-		$update = $qb->update($this->getTableName())
-			->set('last_activity', $qb->createNamedParameter($now, IQueryBuilder::PARAM_INT))
-			->where(
-				$qb->expr()->eq('id', $qb->createNamedParameter($token->getId(), IQueryBuilder::PARAM_INT), IQueryBuilder::PARAM_INT),
-				$qb->expr()->lt('last_activity', $qb->createNamedParameter($now - 15, IQueryBuilder::PARAM_INT), IQueryBuilder::PARAM_INT)
-			);
-		$update->executeStatement();
-	}
-
-	public function updateHashesForUser(string $userId, string $passwordHash): void {
-		$qb = $this->db->getQueryBuilder();
-		$update = $qb->update($this->getTableName())
-			->set('password_hash', $qb->createNamedParameter($passwordHash))
-			->where(
-				$qb->expr()->eq('uid', $qb->createNamedParameter($userId))
-			);
-		$update->executeStatement();
-	}
-
-	public function getFirstTokenForUser(string $userId): ?PublicKeyToken {
-		$qb = $this->db->getQueryBuilder();
-		$qb->select('*')
-			->from($this->getTableName())
-			->where($qb->expr()->eq('uid', $qb->createNamedParameter($userId)))
-			->setMaxResults(1)
-			->orderBy('id');
-		$result = $qb->executeQuery();
-
-		$data = $result->fetch();
-		$result->closeCursor();
-		if ($data === false) {
-			return null;
-		}
-		return PublicKeyToken::fromRow($data);
-	}
+    public function __construct(IDBConnection $db) {
+        parent::__construct($db, 'authtoken');
+    }
+
+    /**
+     * Invalidate (delete) a given token
+     */
+    public function invalidate(string $token) {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $qb->delete($this->tableName)
+            ->where($qb->expr()->eq('token', $qb->createNamedParameter($token)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
+            ->executeStatement();
+    }
+
+    /**
+     * @param int $olderThan
+     * @param int $type
+     * @param int|null $remember
+     */
+    public function invalidateOld(int $olderThan, int $type = IToken::TEMPORARY_TOKEN, ?int $remember = null) {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $delete = $qb->delete($this->tableName)
+            ->where($qb->expr()->lt('last_activity', $qb->createNamedParameter($olderThan, IQueryBuilder::PARAM_INT)))
+            ->andWhere($qb->expr()->eq('type', $qb->createNamedParameter($type, IQueryBuilder::PARAM_INT)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
+        if ($remember !== null) {
+            $delete->andWhere($qb->expr()->eq('remember', $qb->createNamedParameter($remember, IQueryBuilder::PARAM_INT)));
+        }
+        $delete->executeStatement();
+    }
+
+    public function invalidateLastUsedBefore(string $uid, int $before): int {
+        $qb = $this->db->getQueryBuilder();
+        $qb->delete($this->tableName)
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->andWhere($qb->expr()->lt('last_activity', $qb->createNamedParameter($before, IQueryBuilder::PARAM_INT)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
+        return $qb->executeStatement();
+    }
+
+    /**
+     * Get the user UID for the given token
+     *
+     * @throws DoesNotExistException
+     */
+    public function getToken(string $token): PublicKeyToken {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $result = $qb->select('*')
+            ->from($this->tableName)
+            ->where($qb->expr()->eq('token', $qb->createNamedParameter($token)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
+            ->executeQuery();
+
+        $data = $result->fetch();
+        $result->closeCursor();
+        if ($data === false) {
+            throw new DoesNotExistException('token does not exist');
+        }
+        return PublicKeyToken::fromRow($data);
+    }
+
+    /**
+     * Get the token for $id
+     *
+     * @throws DoesNotExistException
+     */
+    public function getTokenById(int $id): PublicKeyToken {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $result = $qb->select('*')
+            ->from($this->tableName)
+            ->where($qb->expr()->eq('id', $qb->createNamedParameter($id)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
+            ->executeQuery();
+
+        $data = $result->fetch();
+        $result->closeCursor();
+        if ($data === false) {
+            throw new DoesNotExistException('token does not exist');
+        }
+        return PublicKeyToken::fromRow($data);
+    }
+
+    /**
+     * Get all tokens of a user
+     *
+     * The provider may limit the number of result rows in case of an abuse
+     * where a high number of (session) tokens is generated
+     *
+     * @param string $uid
+     * @return PublicKeyToken[]
+     */
+    public function getTokenByUser(string $uid): array {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $qb->select('*')
+            ->from($this->tableName)
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)))
+            ->setMaxResults(1000);
+        $result = $qb->executeQuery();
+        $data = $result->fetchAll();
+        $result->closeCursor();
+
+        $entities = array_map(function ($row) {
+            return PublicKeyToken::fromRow($row);
+        }, $data);
+
+        return $entities;
+    }
+
+    public function getTokenByUserAndId(string $uid, int $id): ?string {
+        /* @var $qb IQueryBuilder */
+        $qb = $this->db->getQueryBuilder();
+        $qb->select('token')
+            ->from($this->tableName)
+            ->where($qb->expr()->eq('id', $qb->createNamedParameter($id)))
+            ->andWhere($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
+        return $qb->executeQuery()->fetchOne() ?: null;
+    }
+
+    /**
+     * delete all auth token which belong to a specific client if the client was deleted
+     *
+     * @param string $name
+     */
+    public function deleteByName(string $name) {
+        $qb = $this->db->getQueryBuilder();
+        $qb->delete($this->tableName)
+            ->where($qb->expr()->eq('name', $qb->createNamedParameter($name), IQueryBuilder::PARAM_STR))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
+        $qb->executeStatement();
+    }
+
+    public function deleteTempToken(PublicKeyToken $except) {
+        $qb = $this->db->getQueryBuilder();
+
+        $qb->delete($this->tableName)
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($except->getUID())))
+            ->andWhere($qb->expr()->eq('type', $qb->createNamedParameter(IToken::TEMPORARY_TOKEN)))
+            ->andWhere($qb->expr()->neq('id', $qb->createNamedParameter($except->getId())))
+            ->andWhere($qb->expr()->eq('version', $qb->createNamedParameter(PublicKeyToken::VERSION, IQueryBuilder::PARAM_INT)));
+
+        $qb->executeStatement();
+    }
+
+    public function hasExpiredTokens(string $uid): bool {
+        $qb = $this->db->getQueryBuilder();
+        $qb->select('*')
+            ->from($this->tableName)
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($uid)))
+            ->andWhere($qb->expr()->eq('password_invalid', $qb->createNamedParameter(true), IQueryBuilder::PARAM_BOOL))
+            ->setMaxResults(1);
+
+        $cursor = $qb->executeQuery();
+        $data = $cursor->fetchAll();
+        $cursor->closeCursor();
+
+        return count($data) === 1;
+    }
+
+    /**
+     * Update the last activity timestamp
+     *
+     * In highly concurrent setups it can happen that two parallel processes
+     * trigger the update at (nearly) the same time. In that special case it's
+     * not necessary to hit the database with two actual updates. Therefore the
+     * target last activity is included in the WHERE clause with a few seconds
+     * of tolerance.
+     *
+     * Example:
+     * - process 1 (P1) reads the token at timestamp 1500
+     * - process 1 (P2) reads the token at timestamp 1501
+     * - activity update interval is 100
+     *
+     * This means
+     *
+     * - P1 will see a last_activity smaller than the current time and update
+     *   the token row
+     * - If P2 reads after P1 had written, it will see 1600 as last activity
+     *   and the comparison on last_activity won't be truthy. This means no rows
+     *   need to be updated a second time
+     * - If P2 reads before P1 had written, it will see 1501 as last activity,
+     *   but the comparison on last_activity will still not be truthy and the
+     *   token row is not updated a second time
+     *
+     * @param IToken $token
+     * @param int $now
+     */
+    public function updateActivity(IToken $token, int $now): void {
+        $qb = $this->db->getQueryBuilder();
+        $update = $qb->update($this->getTableName())
+            ->set('last_activity', $qb->createNamedParameter($now, IQueryBuilder::PARAM_INT))
+            ->where(
+                $qb->expr()->eq('id', $qb->createNamedParameter($token->getId(), IQueryBuilder::PARAM_INT), IQueryBuilder::PARAM_INT),
+                $qb->expr()->lt('last_activity', $qb->createNamedParameter($now - 15, IQueryBuilder::PARAM_INT), IQueryBuilder::PARAM_INT)
+            );
+        $update->executeStatement();
+    }
+
+    public function updateHashesForUser(string $userId, string $passwordHash): void {
+        $qb = $this->db->getQueryBuilder();
+        $update = $qb->update($this->getTableName())
+            ->set('password_hash', $qb->createNamedParameter($passwordHash))
+            ->where(
+                $qb->expr()->eq('uid', $qb->createNamedParameter($userId))
+            );
+        $update->executeStatement();
+    }
+
+    public function getFirstTokenForUser(string $userId): ?PublicKeyToken {
+        $qb = $this->db->getQueryBuilder();
+        $qb->select('*')
+            ->from($this->getTableName())
+            ->where($qb->expr()->eq('uid', $qb->createNamedParameter($userId)))
+            ->setMaxResults(1)
+            ->orderBy('id');
+        $result = $qb->executeQuery();
+
+        $data = $result->fetch();
+        $result->closeCursor();
+        if ($data === false) {
+            return null;
+        }
+        return PublicKeyToken::fromRow($data);
+    }
 }

lib/public/IL10N.php

Spacing +1 added lines, -1 removed lines

@@ -107,7 +107,7 @@
 	 * @return string language
 	 * @since 7.0.0
 	 */
-	public function getLanguageCode(): string ;
+	public function getLanguageCode(): string;
 
 	/**
 	 * * The code (en_US, fr_CA, ...) of the locale that is used for this IL10N object

Indentation +68 added lines, -68 removed lines

@@ -17,77 +17,77 @@
  * @since 6.0.0
  */
 interface IL10N {
-	/**
-	 * Translating
-	 * @param string $text The text we need a translation for
-	 * @param array|string $parameters default:array() Parameters for sprintf
-	 * @return string Translation or the same text
-	 *
-	 * Returns the translation. If no translation is found, $text will be
-	 * returned.
-	 * @since 6.0.0
-	 */
-	public function t(string $text, $parameters = []): string;
+    /**
+     * Translating
+     * @param string $text The text we need a translation for
+     * @param array|string $parameters default:array() Parameters for sprintf
+     * @return string Translation or the same text
+     *
+     * Returns the translation. If no translation is found, $text will be
+     * returned.
+     * @since 6.0.0
+     */
+    public function t(string $text, $parameters = []): string;
 
-	/**
-	 * Translating
-	 * @param string $text_singular the string to translate for exactly one object
-	 * @param string $text_plural the string to translate for n objects
-	 * @param integer $count Number of objects
-	 * @param array $parameters default:array() Parameters for sprintf
-	 * @return string Translation or the same text
-	 *
-	 * Returns the translation. If no translation is found, $text will be
-	 * returned. %n will be replaced with the number of objects.
-	 *
-	 * The correct plural is determined by the plural_forms-function
-	 * provided by the po file.
-	 * @since 6.0.0
-	 *
-	 */
-	public function n(string $text_singular, string $text_plural, int $count, array $parameters = []): string;
+    /**
+     * Translating
+     * @param string $text_singular the string to translate for exactly one object
+     * @param string $text_plural the string to translate for n objects
+     * @param integer $count Number of objects
+     * @param array $parameters default:array() Parameters for sprintf
+     * @return string Translation or the same text
+     *
+     * Returns the translation. If no translation is found, $text will be
+     * returned. %n will be replaced with the number of objects.
+     *
+     * The correct plural is determined by the plural_forms-function
+     * provided by the po file.
+     * @since 6.0.0
+     *
+     */
+    public function n(string $text_singular, string $text_plural, int $count, array $parameters = []): string;
 
-	/**
-	 * Localization
-	 * @param string $type Type of localization
-	 * @param \DateTime|int|string $data parameters for this localization
-	 * @param array $options currently supports following options:
-	 *                       - 'width': handed into \Punic\Calendar::formatDate as second parameter
-	 * @return string|int|false
-	 *
-	 * Returns the localized data.
-	 *
-	 * Implemented types:
-	 *  - date
-	 *    - Creates a date
-	 *    - l10n-field: date
-	 *    - params: timestamp (int/string)
-	 *  - datetime
-	 *    - Creates date and time
-	 *    - l10n-field: datetime
-	 *    - params: timestamp (int/string)
-	 *  - time
-	 *    - Creates a time
-	 *    - l10n-field: time
-	 *    - params: timestamp (int/string)
-	 * @since 6.0.0 - parameter $options was added in 8.0.0
-	 */
-	public function l(string $type, $data, array $options = []);
+    /**
+     * Localization
+     * @param string $type Type of localization
+     * @param \DateTime|int|string $data parameters for this localization
+     * @param array $options currently supports following options:
+     *                       - 'width': handed into \Punic\Calendar::formatDate as second parameter
+     * @return string|int|false
+     *
+     * Returns the localized data.
+     *
+     * Implemented types:
+     *  - date
+     *    - Creates a date
+     *    - l10n-field: date
+     *    - params: timestamp (int/string)
+     *  - datetime
+     *    - Creates date and time
+     *    - l10n-field: datetime
+     *    - params: timestamp (int/string)
+     *  - time
+     *    - Creates a time
+     *    - l10n-field: time
+     *    - params: timestamp (int/string)
+     * @since 6.0.0 - parameter $options was added in 8.0.0
+     */
+    public function l(string $type, $data, array $options = []);
 
 
-	/**
-	 * The code (en, de, ...) of the language that is used for this IL10N object
-	 *
-	 * @return string language
-	 * @since 7.0.0
-	 */
-	public function getLanguageCode(): string ;
+    /**
+     * The code (en, de, ...) of the language that is used for this IL10N object
+     *
+     * @return string language
+     * @since 7.0.0
+     */
+    public function getLanguageCode(): string ;
 
-	/**
-	 * * The code (en_US, fr_CA, ...) of the locale that is used for this IL10N object
-	 *
-	 * @return string locale
-	 * @since 14.0.0
-	 */
-	public function getLocaleCode(): string;
+    /**
+     * * The code (en_US, fr_CA, ...) of the locale that is used for this IL10N object
+     *
+     * @return string locale
+     * @since 14.0.0
+     */
+    public function getLocaleCode(): string;
 }