nextcloud / server

apps/workflowengine/lib/Manager.php

Indentation +668 added lines, -668 removed lines

@@ -46,672 +46,672 @@
  * @psalm-type Check = array{id: int, class: class-string<ICheck>, operator: string, value: string, hash: string}
  */
 class Manager implements IManager {
-	/** @var array[] */
-	protected array $operations = [];
-
-	/** @var array<int, Check> */
-	protected array $checks = [];
-
-	/** @var IEntity[] */
-	protected array $registeredEntities = [];
-
-	/** @var IOperation[] */
-	protected array $registeredOperators = [];
-
-	/** @var ICheck[] */
-	protected array $registeredChecks = [];
-
-	/** @var CappedMemoryCache<int[]> */
-	protected CappedMemoryCache $operationsByScope;
-
-	public function __construct(
-		protected readonly IDBConnection $connection,
-		protected readonly ContainerInterface $container,
-		protected readonly IL10N $l,
-		protected readonly LoggerInterface $logger,
-		protected readonly IUserSession $session,
-		private readonly IEventDispatcher $dispatcher,
-		private readonly IAppConfig $appConfig,
-		private readonly ICacheFactory $cacheFactory,
-	) {
-		$this->operationsByScope = new CappedMemoryCache(64);
-	}
-
-	public function getRuleMatcher(): IRuleMatcher {
-		return new RuleMatcher(
-			$this->session,
-			$this->container,
-			$this->l,
-			$this,
-			$this->container->get(Logger::class)
-		);
-	}
-
-	public function getAllConfiguredEvents() {
-		$cache = $this->cacheFactory->createDistributed('flow');
-		$cached = $cache->get('events');
-		if ($cached !== null) {
-			return $cached;
-		}
-
-		$query = $this->connection->getQueryBuilder();
-
-		$query->select('class', 'entity')
-			->selectAlias($query->expr()->castColumn('events', IQueryBuilder::PARAM_STR), 'events')
-			->from('flow_operations')
-			->where($query->expr()->neq('events', $query->createNamedParameter('[]'), IQueryBuilder::PARAM_STR))
-			->groupBy('class', 'entity', $query->expr()->castColumn('events', IQueryBuilder::PARAM_STR));
-
-		$result = $query->executeQuery();
-		$operations = [];
-		while ($row = $result->fetchAssociative()) {
-			$eventNames = \json_decode($row['events']);
-
-			$operation = $row['class'];
-			$entity = $row['entity'];
-
-			$operations[$operation] = $operations[$row['class']] ?? [];
-			$operations[$operation][$entity] = $operations[$operation][$entity] ?? [];
-
-			$operations[$operation][$entity] = array_unique(array_merge($operations[$operation][$entity], $eventNames ?? []));
-		}
-		$result->closeCursor();
-
-		$cache->set('events', $operations, 3600);
-
-		return $operations;
-	}
-
-	/**
-	 * @param class-string<IOperation> $operationClass
-	 * @return ScopeContext[]
-	 */
-	public function getAllConfiguredScopesForOperation(string $operationClass): array {
-		/** @var array<class-string<IOperation>, ScopeContext[]> $scopesByOperation */
-		static $scopesByOperation = [];
-		if (isset($scopesByOperation[$operationClass])) {
-			return $scopesByOperation[$operationClass];
-		}
-
-		try {
-			/** @var IOperation $operation */
-			$operation = $this->container->get($operationClass);
-		} catch (ContainerExceptionInterface $e) {
-			return [];
-		}
-
-		$query = $this->connection->getQueryBuilder();
-
-		$query->selectDistinct('s.type')
-			->addSelect('s.value')
-			->from('flow_operations', 'o')
-			->leftJoin('o', 'flow_operations_scope', 's', $query->expr()->eq('o.id', 's.operation_id'))
-			->where($query->expr()->eq('o.class', $query->createParameter('operationClass')));
-
-		$query->setParameters(['operationClass' => $operationClass]);
-		$result = $query->executeQuery();
-
-		$scopesByOperation[$operationClass] = [];
-		while ($row = $result->fetchAssociative()) {
-			$scope = new ScopeContext($row['type'], $row['value']);
-
-			if (!$operation->isAvailableForScope((int)$row['type'])) {
-				continue;
-			}
-
-			$scopesByOperation[$operationClass][$scope->getHash()] = $scope;
-		}
-
-		return $scopesByOperation[$operationClass];
-	}
-
-	public function getAllOperations(ScopeContext $scopeContext): array {
-		if (isset($this->operations[$scopeContext->getHash()])) {
-			return $this->operations[$scopeContext->getHash()];
-		}
-
-		$query = $this->connection->getQueryBuilder();
-
-		$query->select('o.*')
-			->selectAlias('s.type', 'scope_type')
-			->selectAlias('s.value', 'scope_actor_id')
-			->from('flow_operations', 'o')
-			->leftJoin('o', 'flow_operations_scope', 's', $query->expr()->eq('o.id', 's.operation_id'))
-			->where($query->expr()->eq('s.type', $query->createParameter('scope')));
-
-		if ($scopeContext->getScope() === IManager::SCOPE_USER) {
-			$query->andWhere($query->expr()->eq('s.value', $query->createParameter('scopeId')));
-		}
-
-		$query->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
-		$result = $query->executeQuery();
-
-		$this->operations[$scopeContext->getHash()] = [];
-		while ($row = $result->fetchAssociative()) {
-			try {
-				/** @var IOperation $operation */
-				$operation = $this->container->get($row['class']);
-			} catch (ContainerExceptionInterface $e) {
-				continue;
-			}
-
-			if (!$operation->isAvailableForScope((int)$row['scope_type'])) {
-				continue;
-			}
-
-			if (!isset($this->operations[$scopeContext->getHash()][$row['class']])) {
-				$this->operations[$scopeContext->getHash()][$row['class']] = [];
-			}
-			$this->operations[$scopeContext->getHash()][$row['class']][] = $row;
-		}
-
-		return $this->operations[$scopeContext->getHash()];
-	}
-
-	public function getOperations(string $class, ScopeContext $scopeContext): array {
-		if (!isset($this->operations[$scopeContext->getHash()])) {
-			$this->getAllOperations($scopeContext);
-		}
-		return $this->operations[$scopeContext->getHash()][$class] ?? [];
-	}
-
-	/**
-	 * @param int $id
-	 * @return array
-	 * @throws \UnexpectedValueException
-	 */
-	protected function getOperation($id) {
-		$query = $this->connection->getQueryBuilder();
-		$query->select('*')
-			->from('flow_operations')
-			->where($query->expr()->eq('id', $query->createNamedParameter($id)));
-		$result = $query->executeQuery();
-		$row = $result->fetchAssociative();
-		$result->closeCursor();
-
-		if ($row) {
-			return $row;
-		}
-
-		throw new \UnexpectedValueException($this->l->t('Operation #%s does not exist', [$id]));
-	}
-
-	protected function insertOperation(
-		string $class,
-		string $name,
-		array $checkIds,
-		string $operation,
-		string $entity,
-		array $events,
-	): int {
-		$query = $this->connection->getQueryBuilder();
-		$query->insert('flow_operations')
-			->values([
-				'class' => $query->createNamedParameter($class),
-				'name' => $query->createNamedParameter($name),
-				'checks' => $query->createNamedParameter(json_encode(array_unique($checkIds))),
-				'operation' => $query->createNamedParameter($operation),
-				'entity' => $query->createNamedParameter($entity),
-				'events' => $query->createNamedParameter(json_encode($events))
-			]);
-		$query->executeStatement();
-
-		$this->cacheFactory->createDistributed('flow')->remove('events');
-
-		return $query->getLastInsertId();
-	}
-
-	/**
-	 * @param string $class
-	 * @param string $name
-	 * @param array<int, Check> $checks
-	 * @param string $operation
-	 * @return array The added operation
-	 * @throws \UnexpectedValueException
-	 * @throws Exception
-	 */
-	public function addOperation(
-		string $class,
-		string $name,
-		array $checks,
-		string $operation,
-		ScopeContext $scope,
-		string $entity,
-		array $events,
-	) {
-		$this->validateOperation($class, $name, $checks, $operation, $scope, $entity, $events);
-
-		$this->connection->beginTransaction();
-
-		try {
-			$checkIds = [];
-			foreach ($checks as $check) {
-				$checkIds[] = $this->addCheck($check['class'], $check['operator'], $check['value']);
-			}
-
-			$id = $this->insertOperation($class, $name, $checkIds, $operation, $entity, $events);
-			$this->addScope($id, $scope);
-
-			$this->connection->commit();
-		} catch (Exception $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-
-		return $this->getOperation($id);
-	}
-
-	protected function canModify(int $id, ScopeContext $scopeContext):bool {
-		if (isset($this->operationsByScope[$scopeContext->getHash()])) {
-			return in_array($id, $this->operationsByScope[$scopeContext->getHash()], true);
-		}
-
-		$qb = $this->connection->getQueryBuilder();
-		$qb = $qb->select('o.id')
-			->from('flow_operations', 'o')
-			->leftJoin('o', 'flow_operations_scope', 's', $qb->expr()->eq('o.id', 's.operation_id'))
-			->where($qb->expr()->eq('s.type', $qb->createParameter('scope')));
-
-		if ($scopeContext->getScope() !== IManager::SCOPE_ADMIN) {
-			$qb->andWhere($qb->expr()->eq('s.value', $qb->createParameter('scopeId')));
-		}
-
-		$qb->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
-		$result = $qb->executeQuery();
-
-		$operations = [];
-		while (($opId = $result->fetchOne()) !== false) {
-			$operations[] = (int)$opId;
-		}
-		$this->operationsByScope[$scopeContext->getHash()] = $operations;
-		$result->closeCursor();
-
-		return in_array($id, $this->operationsByScope[$scopeContext->getHash()], true);
-	}
-
-	/**
-	 * @param int $id
-	 * @param string $name
-	 * @param array[] $checks
-	 * @param string $operation
-	 * @return array The updated operation
-	 * @throws \UnexpectedValueException
-	 * @throws \DomainException
-	 * @throws Exception
-	 */
-	public function updateOperation(
-		int $id,
-		string $name,
-		array $checks,
-		string $operation,
-		ScopeContext $scopeContext,
-		string $entity,
-		array $events,
-	): array {
-		if (!$this->canModify($id, $scopeContext)) {
-			throw new \DomainException('Target operation not within scope');
-		};
-		$row = $this->getOperation($id);
-		$this->validateOperation($row['class'], $name, $checks, $operation, $scopeContext, $entity, $events);
-
-		$checkIds = [];
-		try {
-			$this->connection->beginTransaction();
-			foreach ($checks as $check) {
-				$checkIds[] = $this->addCheck($check['class'], $check['operator'], $check['value']);
-			}
-
-			$query = $this->connection->getQueryBuilder();
-			$query->update('flow_operations')
-				->set('name', $query->createNamedParameter($name))
-				->set('checks', $query->createNamedParameter(json_encode(array_unique($checkIds))))
-				->set('operation', $query->createNamedParameter($operation))
-				->set('entity', $query->createNamedParameter($entity))
-				->set('events', $query->createNamedParameter(json_encode($events)))
-				->where($query->expr()->eq('id', $query->createNamedParameter($id)));
-			$query->executeStatement();
-			$this->connection->commit();
-		} catch (Exception $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-		unset($this->operations[$scopeContext->getHash()]);
-		$this->cacheFactory->createDistributed('flow')->remove('events');
-
-		return $this->getOperation($id);
-	}
-
-	/**
-	 * @throws \UnexpectedValueException
-	 * @throws Exception
-	 * @throws \DomainException
-	 */
-	public function deleteOperation(int $id, ScopeContext $scopeContext): bool {
-		if (!$this->canModify($id, $scopeContext)) {
-			throw new \DomainException('Target operation not within scope');
-		};
-		$query = $this->connection->getQueryBuilder();
-		try {
-			$this->connection->beginTransaction();
-			$result = (bool)$query->delete('flow_operations')
-				->where($query->expr()->eq('id', $query->createNamedParameter($id)))
-				->executeStatement();
-			if ($result) {
-				$qb = $this->connection->getQueryBuilder();
-				$result = (bool)$qb->delete('flow_operations_scope')
-					->where($qb->expr()->eq('operation_id', $qb->createNamedParameter($id)))
-					->executeStatement();
-			}
-			$this->connection->commit();
-		} catch (Exception $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-
-		if (isset($this->operations[$scopeContext->getHash()])) {
-			unset($this->operations[$scopeContext->getHash()]);
-		}
-
-		$this->cacheFactory->createDistributed('flow')->remove('events');
-
-		return $result;
-	}
-
-	/**
-	 * @param class-string<IEntity> $entity
-	 * @param array $events
-	 */
-	protected function validateEvents(string $entity, array $events, IOperation $operation): void {
-		/** @psalm-suppress TaintedCallable newInstance is not called */
-		$reflection = new \ReflectionClass($entity);
-		if ($entity !== IEntity::class && !in_array(IEntity::class, $reflection->getInterfaceNames())) {
-			throw new \UnexpectedValueException($this->l->t('Entity %s is invalid', [$entity]));
-		}
-
-		try {
-			$instance = $this->container->get($entity);
-		} catch (ContainerExceptionInterface $e) {
-			throw new \UnexpectedValueException($this->l->t('Entity %s does not exist', [$entity]));
-		}
-
-		if (empty($events)) {
-			if (!$operation instanceof IComplexOperation) {
-				throw new \UnexpectedValueException($this->l->t('No events are chosen.'));
-			}
-			return;
-		}
-
-		$availableEvents = [];
-		foreach ($instance->getEvents() as $event) {
-			/** @var IEntityEvent $event */
-			$availableEvents[] = $event->getEventName();
-		}
-
-		$diff = array_diff($events, $availableEvents);
-		if (!empty($diff)) {
-			throw new \UnexpectedValueException($this->l->t('Entity %s has no event %s', [$entity, array_shift($diff)]));
-		}
-	}
-
-	/**
-	 * @param class-string<IOperation> $class
-	 * @param array<int, Check> $checks
-	 * @param array $events
-	 * @throws \UnexpectedValueException
-	 */
-	public function validateOperation(string $class, string $name, array $checks, string $operation, ScopeContext $scope, string $entity, array $events): void {
-		if (strlen($operation) > IManager::MAX_OPERATION_VALUE_BYTES) {
-			throw new \UnexpectedValueException($this->l->t('The provided operation data is too long'));
-		}
-
-		/** @psalm-suppress TaintedCallable newInstance is not called */
-		$reflection = new \ReflectionClass($class);
-		if ($class !== IOperation::class && !in_array(IOperation::class, $reflection->getInterfaceNames())) {
-			throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]) . join(', ', $reflection->getInterfaceNames()));
-		}
-
-		try {
-			/** @var IOperation $instance */
-			$instance = $this->container->get($class);
-		} catch (ContainerExceptionInterface $e) {
-			throw new \UnexpectedValueException($this->l->t('Operation %s does not exist', [$class]));
-		}
-
-		if (!$instance->isAvailableForScope($scope->getScope())) {
-			throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]));
-		}
-
-		$this->validateEvents($entity, $events, $instance);
-
-		if (count($checks) === 0) {
-			throw new \UnexpectedValueException($this->l->t('At least one check needs to be provided'));
-		}
-
-		$instance->validateOperation($name, $checks, $operation);
-
-		foreach ($checks as $check) {
-			if (!is_string($check['class'])) {
-				throw new \UnexpectedValueException($this->l->t('Invalid check provided'));
-			}
-
-			if (strlen((string)$check['value']) > IManager::MAX_CHECK_VALUE_BYTES) {
-				throw new \UnexpectedValueException($this->l->t('The provided check value is too long'));
-			}
-
-			$reflection = new \ReflectionClass($check['class']);
-			if ($check['class'] !== ICheck::class && !in_array(ICheck::class, $reflection->getInterfaceNames())) {
-				throw new \UnexpectedValueException($this->l->t('Check %s is invalid', [$class]));
-			}
-
-			try {
-				/** @var ICheck $instance */
-				$instance = $this->container->get($check['class']);
-			} catch (ContainerExceptionInterface) {
-				throw new \UnexpectedValueException($this->l->t('Check %s does not exist', [$class]));
-			}
-
-			if (!empty($instance->supportedEntities())
-				&& !in_array($entity, $instance->supportedEntities())
-			) {
-				throw new \UnexpectedValueException($this->l->t('Check %s is not allowed with this entity', [$class]));
-			}
-
-			$instance->validateCheck($check['operator'], $check['value']);
-		}
-	}
-
-	/**
-	 * @param int[] $checkIds
-	 * @return array<int, Check>
-	 */
-	public function getChecks(array $checkIds): array {
-		$checkIds = array_map('intval', $checkIds);
-
-		$checks = [];
-		foreach ($checkIds as $i => $checkId) {
-			if (isset($this->checks[$checkId])) {
-				$checks[$checkId] = $this->checks[$checkId];
-				unset($checkIds[$i]);
-			}
-		}
-
-		if (empty($checkIds)) {
-			return $checks;
-		}
-
-		$query = $this->connection->getQueryBuilder();
-		$query->select('*')
-			->from('flow_checks')
-			->where($query->expr()->in('id', $query->createNamedParameter($checkIds, IQueryBuilder::PARAM_INT_ARRAY)));
-		$result = $query->executeQuery();
-
-		while ($row = $result->fetchAssociative()) {
-			/** @var Check $row */
-			$this->checks[(int)$row['id']] = $row;
-			$checks[(int)$row['id']] = $row;
-		}
-		$result->closeCursor();
-
-		$checkIds = array_diff($checkIds, array_keys($checks));
-
-		if (!empty($checkIds)) {
-			$missingCheck = array_pop($checkIds);
-			throw new \UnexpectedValueException($this->l->t('Check #%s does not exist', (string)$missingCheck));
-		}
-
-		return $checks;
-	}
-
-	/**
-	 * @return int Check unique ID
-	 */
-	protected function addCheck(string $class, string $operator, string $value): int {
-		$hash = md5($class . '::' . $operator . '::' . $value);
-
-		$query = $this->connection->getQueryBuilder();
-		$query->select('id')
-			->from('flow_checks')
-			->where($query->expr()->eq('hash', $query->createNamedParameter($hash)));
-		$result = $query->executeQuery();
-
-		if ($row = $result->fetchAssociative()) {
-			$result->closeCursor();
-			return (int)$row['id'];
-		}
-
-		$query = $this->connection->getQueryBuilder();
-		$query->insert('flow_checks')
-			->values([
-				'class' => $query->createNamedParameter($class),
-				'operator' => $query->createNamedParameter($operator),
-				'value' => $query->createNamedParameter($value),
-				'hash' => $query->createNamedParameter($hash),
-			]);
-		$query->executeStatement();
-
-		return $query->getLastInsertId();
-	}
-
-	protected function addScope(int $operationId, ScopeContext $scope): void {
-		$query = $this->connection->getQueryBuilder();
-
-		$insertQuery = $query->insert('flow_operations_scope');
-		$insertQuery->values([
-			'operation_id' => $query->createNamedParameter($operationId),
-			'type' => $query->createNamedParameter($scope->getScope()),
-			'value' => $query->createNamedParameter($scope->getScopeId()),
-		]);
-		$insertQuery->executeStatement();
-	}
-
-	public function formatOperation(array $operation): array {
-		$checkIds = json_decode($operation['checks'], true);
-		$checks = $this->getChecks($checkIds);
-
-		$operation['checks'] = [];
-		foreach ($checks as $check) {
-			// Remove internal values
-			unset($check['id']);
-			unset($check['hash']);
-
-			$operation['checks'][] = $check;
-		}
-		$operation['events'] = json_decode($operation['events'], true) ?? [];
-
-
-		return $operation;
-	}
-
-	/**
-	 * @return IEntity[]
-	 */
-	public function getEntitiesList(): array {
-		$this->dispatcher->dispatchTyped(new RegisterEntitiesEvent($this));
-
-		return array_values(array_merge($this->getBuildInEntities(), $this->registeredEntities));
-	}
-
-	/**
-	 * @return IOperation[]
-	 */
-	public function getOperatorList(): array {
-		$this->dispatcher->dispatchTyped(new RegisterOperationsEvent($this));
-
-		return array_merge($this->getBuildInOperators(), $this->registeredOperators);
-	}
-
-	/**
-	 * @return ICheck[]
-	 */
-	public function getCheckList(): array {
-		$this->dispatcher->dispatchTyped(new RegisterChecksEvent($this));
-
-		return array_merge($this->getBuildInChecks(), $this->registeredChecks);
-	}
-
-	public function registerEntity(IEntity $entity): void {
-		$this->registeredEntities[get_class($entity)] = $entity;
-	}
-
-	public function registerOperation(IOperation $operator): void {
-		$this->registeredOperators[get_class($operator)] = $operator;
-	}
-
-	public function registerCheck(ICheck $check): void {
-		$this->registeredChecks[get_class($check)] = $check;
-	}
-
-	/**
-	 * @return IEntity[]
-	 */
-	protected function getBuildInEntities(): array {
-		try {
-			return [
-				File::class => $this->container->get(File::class),
-			];
-		} catch (ContainerExceptionInterface $e) {
-			$this->logger->error($e->getMessage(), ['exception' => $e]);
-			return [];
-		}
-	}
-
-	/**
-	 * @return IOperation[]
-	 */
-	protected function getBuildInOperators(): array {
-		try {
-			return [
-				// None yet
-			];
-		} catch (ContainerExceptionInterface $e) {
-			$this->logger->error($e->getMessage(), ['exception' => $e]);
-			return [];
-		}
-	}
-
-	/**
-	 * @return ICheck[]
-	 */
-	protected function getBuildInChecks(): array {
-		try {
-			return [
-				$this->container->get(FileMimeType::class),
-				$this->container->get(FileName::class),
-				$this->container->get(FileSize::class),
-				$this->container->get(FileSystemTags::class),
-				$this->container->get(RequestRemoteAddress::class),
-				$this->container->get(RequestTime::class),
-				$this->container->get(RequestURL::class),
-				$this->container->get(RequestUserAgent::class),
-				$this->container->get(UserGroupMembership::class),
-			];
-		} catch (ContainerExceptionInterface $e) {
-			$this->logger->error($e->getMessage(), ['exception' => $e]);
-			return [];
-		}
-	}
-
-	public function isUserScopeEnabled(): bool {
-		return !$this->appConfig->getAppValueBool('user_scope_disabled');
-	}
+    /** @var array[] */
+    protected array $operations = [];
+
+    /** @var array<int, Check> */
+    protected array $checks = [];
+
+    /** @var IEntity[] */
+    protected array $registeredEntities = [];
+
+    /** @var IOperation[] */
+    protected array $registeredOperators = [];
+
+    /** @var ICheck[] */
+    protected array $registeredChecks = [];
+
+    /** @var CappedMemoryCache<int[]> */
+    protected CappedMemoryCache $operationsByScope;
+
+    public function __construct(
+        protected readonly IDBConnection $connection,
+        protected readonly ContainerInterface $container,
+        protected readonly IL10N $l,
+        protected readonly LoggerInterface $logger,
+        protected readonly IUserSession $session,
+        private readonly IEventDispatcher $dispatcher,
+        private readonly IAppConfig $appConfig,
+        private readonly ICacheFactory $cacheFactory,
+    ) {
+        $this->operationsByScope = new CappedMemoryCache(64);
+    }
+
+    public function getRuleMatcher(): IRuleMatcher {
+        return new RuleMatcher(
+            $this->session,
+            $this->container,
+            $this->l,
+            $this,
+            $this->container->get(Logger::class)
+        );
+    }
+
+    public function getAllConfiguredEvents() {
+        $cache = $this->cacheFactory->createDistributed('flow');
+        $cached = $cache->get('events');
+        if ($cached !== null) {
+            return $cached;
+        }
+
+        $query = $this->connection->getQueryBuilder();
+
+        $query->select('class', 'entity')
+            ->selectAlias($query->expr()->castColumn('events', IQueryBuilder::PARAM_STR), 'events')
+            ->from('flow_operations')
+            ->where($query->expr()->neq('events', $query->createNamedParameter('[]'), IQueryBuilder::PARAM_STR))
+            ->groupBy('class', 'entity', $query->expr()->castColumn('events', IQueryBuilder::PARAM_STR));
+
+        $result = $query->executeQuery();
+        $operations = [];
+        while ($row = $result->fetchAssociative()) {
+            $eventNames = \json_decode($row['events']);
+
+            $operation = $row['class'];
+            $entity = $row['entity'];
+
+            $operations[$operation] = $operations[$row['class']] ?? [];
+            $operations[$operation][$entity] = $operations[$operation][$entity] ?? [];
+
+            $operations[$operation][$entity] = array_unique(array_merge($operations[$operation][$entity], $eventNames ?? []));
+        }
+        $result->closeCursor();
+
+        $cache->set('events', $operations, 3600);
+
+        return $operations;
+    }
+
+    /**
+     * @param class-string<IOperation> $operationClass
+     * @return ScopeContext[]
+     */
+    public function getAllConfiguredScopesForOperation(string $operationClass): array {
+        /** @var array<class-string<IOperation>, ScopeContext[]> $scopesByOperation */
+        static $scopesByOperation = [];
+        if (isset($scopesByOperation[$operationClass])) {
+            return $scopesByOperation[$operationClass];
+        }
+
+        try {
+            /** @var IOperation $operation */
+            $operation = $this->container->get($operationClass);
+        } catch (ContainerExceptionInterface $e) {
+            return [];
+        }
+
+        $query = $this->connection->getQueryBuilder();
+
+        $query->selectDistinct('s.type')
+            ->addSelect('s.value')
+            ->from('flow_operations', 'o')
+            ->leftJoin('o', 'flow_operations_scope', 's', $query->expr()->eq('o.id', 's.operation_id'))
+            ->where($query->expr()->eq('o.class', $query->createParameter('operationClass')));
+
+        $query->setParameters(['operationClass' => $operationClass]);
+        $result = $query->executeQuery();
+
+        $scopesByOperation[$operationClass] = [];
+        while ($row = $result->fetchAssociative()) {
+            $scope = new ScopeContext($row['type'], $row['value']);
+
+            if (!$operation->isAvailableForScope((int)$row['type'])) {
+                continue;
+            }
+
+            $scopesByOperation[$operationClass][$scope->getHash()] = $scope;
+        }
+
+        return $scopesByOperation[$operationClass];
+    }
+
+    public function getAllOperations(ScopeContext $scopeContext): array {
+        if (isset($this->operations[$scopeContext->getHash()])) {
+            return $this->operations[$scopeContext->getHash()];
+        }
+
+        $query = $this->connection->getQueryBuilder();
+
+        $query->select('o.*')
+            ->selectAlias('s.type', 'scope_type')
+            ->selectAlias('s.value', 'scope_actor_id')
+            ->from('flow_operations', 'o')
+            ->leftJoin('o', 'flow_operations_scope', 's', $query->expr()->eq('o.id', 's.operation_id'))
+            ->where($query->expr()->eq('s.type', $query->createParameter('scope')));
+
+        if ($scopeContext->getScope() === IManager::SCOPE_USER) {
+            $query->andWhere($query->expr()->eq('s.value', $query->createParameter('scopeId')));
+        }
+
+        $query->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
+        $result = $query->executeQuery();
+
+        $this->operations[$scopeContext->getHash()] = [];
+        while ($row = $result->fetchAssociative()) {
+            try {
+                /** @var IOperation $operation */
+                $operation = $this->container->get($row['class']);
+            } catch (ContainerExceptionInterface $e) {
+                continue;
+            }
+
+            if (!$operation->isAvailableForScope((int)$row['scope_type'])) {
+                continue;
+            }
+
+            if (!isset($this->operations[$scopeContext->getHash()][$row['class']])) {
+                $this->operations[$scopeContext->getHash()][$row['class']] = [];
+            }
+            $this->operations[$scopeContext->getHash()][$row['class']][] = $row;
+        }
+
+        return $this->operations[$scopeContext->getHash()];
+    }
+
+    public function getOperations(string $class, ScopeContext $scopeContext): array {
+        if (!isset($this->operations[$scopeContext->getHash()])) {
+            $this->getAllOperations($scopeContext);
+        }
+        return $this->operations[$scopeContext->getHash()][$class] ?? [];
+    }
+
+    /**
+     * @param int $id
+     * @return array
+     * @throws \UnexpectedValueException
+     */
+    protected function getOperation($id) {
+        $query = $this->connection->getQueryBuilder();
+        $query->select('*')
+            ->from('flow_operations')
+            ->where($query->expr()->eq('id', $query->createNamedParameter($id)));
+        $result = $query->executeQuery();
+        $row = $result->fetchAssociative();
+        $result->closeCursor();
+
+        if ($row) {
+            return $row;
+        }
+
+        throw new \UnexpectedValueException($this->l->t('Operation #%s does not exist', [$id]));
+    }
+
+    protected function insertOperation(
+        string $class,
+        string $name,
+        array $checkIds,
+        string $operation,
+        string $entity,
+        array $events,
+    ): int {
+        $query = $this->connection->getQueryBuilder();
+        $query->insert('flow_operations')
+            ->values([
+                'class' => $query->createNamedParameter($class),
+                'name' => $query->createNamedParameter($name),
+                'checks' => $query->createNamedParameter(json_encode(array_unique($checkIds))),
+                'operation' => $query->createNamedParameter($operation),
+                'entity' => $query->createNamedParameter($entity),
+                'events' => $query->createNamedParameter(json_encode($events))
+            ]);
+        $query->executeStatement();
+
+        $this->cacheFactory->createDistributed('flow')->remove('events');
+
+        return $query->getLastInsertId();
+    }
+
+    /**
+     * @param string $class
+     * @param string $name
+     * @param array<int, Check> $checks
+     * @param string $operation
+     * @return array The added operation
+     * @throws \UnexpectedValueException
+     * @throws Exception
+     */
+    public function addOperation(
+        string $class,
+        string $name,
+        array $checks,
+        string $operation,
+        ScopeContext $scope,
+        string $entity,
+        array $events,
+    ) {
+        $this->validateOperation($class, $name, $checks, $operation, $scope, $entity, $events);
+
+        $this->connection->beginTransaction();
+
+        try {
+            $checkIds = [];
+            foreach ($checks as $check) {
+                $checkIds[] = $this->addCheck($check['class'], $check['operator'], $check['value']);
+            }
+
+            $id = $this->insertOperation($class, $name, $checkIds, $operation, $entity, $events);
+            $this->addScope($id, $scope);
+
+            $this->connection->commit();
+        } catch (Exception $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+
+        return $this->getOperation($id);
+    }
+
+    protected function canModify(int $id, ScopeContext $scopeContext):bool {
+        if (isset($this->operationsByScope[$scopeContext->getHash()])) {
+            return in_array($id, $this->operationsByScope[$scopeContext->getHash()], true);
+        }
+
+        $qb = $this->connection->getQueryBuilder();
+        $qb = $qb->select('o.id')
+            ->from('flow_operations', 'o')
+            ->leftJoin('o', 'flow_operations_scope', 's', $qb->expr()->eq('o.id', 's.operation_id'))
+            ->where($qb->expr()->eq('s.type', $qb->createParameter('scope')));
+
+        if ($scopeContext->getScope() !== IManager::SCOPE_ADMIN) {
+            $qb->andWhere($qb->expr()->eq('s.value', $qb->createParameter('scopeId')));
+        }
+
+        $qb->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
+        $result = $qb->executeQuery();
+
+        $operations = [];
+        while (($opId = $result->fetchOne()) !== false) {
+            $operations[] = (int)$opId;
+        }
+        $this->operationsByScope[$scopeContext->getHash()] = $operations;
+        $result->closeCursor();
+
+        return in_array($id, $this->operationsByScope[$scopeContext->getHash()], true);
+    }
+
+    /**
+     * @param int $id
+     * @param string $name
+     * @param array[] $checks
+     * @param string $operation
+     * @return array The updated operation
+     * @throws \UnexpectedValueException
+     * @throws \DomainException
+     * @throws Exception
+     */
+    public function updateOperation(
+        int $id,
+        string $name,
+        array $checks,
+        string $operation,
+        ScopeContext $scopeContext,
+        string $entity,
+        array $events,
+    ): array {
+        if (!$this->canModify($id, $scopeContext)) {
+            throw new \DomainException('Target operation not within scope');
+        };
+        $row = $this->getOperation($id);
+        $this->validateOperation($row['class'], $name, $checks, $operation, $scopeContext, $entity, $events);
+
+        $checkIds = [];
+        try {
+            $this->connection->beginTransaction();
+            foreach ($checks as $check) {
+                $checkIds[] = $this->addCheck($check['class'], $check['operator'], $check['value']);
+            }
+
+            $query = $this->connection->getQueryBuilder();
+            $query->update('flow_operations')
+                ->set('name', $query->createNamedParameter($name))
+                ->set('checks', $query->createNamedParameter(json_encode(array_unique($checkIds))))
+                ->set('operation', $query->createNamedParameter($operation))
+                ->set('entity', $query->createNamedParameter($entity))
+                ->set('events', $query->createNamedParameter(json_encode($events)))
+                ->where($query->expr()->eq('id', $query->createNamedParameter($id)));
+            $query->executeStatement();
+            $this->connection->commit();
+        } catch (Exception $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+        unset($this->operations[$scopeContext->getHash()]);
+        $this->cacheFactory->createDistributed('flow')->remove('events');
+
+        return $this->getOperation($id);
+    }
+
+    /**
+     * @throws \UnexpectedValueException
+     * @throws Exception
+     * @throws \DomainException
+     */
+    public function deleteOperation(int $id, ScopeContext $scopeContext): bool {
+        if (!$this->canModify($id, $scopeContext)) {
+            throw new \DomainException('Target operation not within scope');
+        };
+        $query = $this->connection->getQueryBuilder();
+        try {
+            $this->connection->beginTransaction();
+            $result = (bool)$query->delete('flow_operations')
+                ->where($query->expr()->eq('id', $query->createNamedParameter($id)))
+                ->executeStatement();
+            if ($result) {
+                $qb = $this->connection->getQueryBuilder();
+                $result = (bool)$qb->delete('flow_operations_scope')
+                    ->where($qb->expr()->eq('operation_id', $qb->createNamedParameter($id)))
+                    ->executeStatement();
+            }
+            $this->connection->commit();
+        } catch (Exception $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+
+        if (isset($this->operations[$scopeContext->getHash()])) {
+            unset($this->operations[$scopeContext->getHash()]);
+        }
+
+        $this->cacheFactory->createDistributed('flow')->remove('events');
+
+        return $result;
+    }
+
+    /**
+     * @param class-string<IEntity> $entity
+     * @param array $events
+     */
+    protected function validateEvents(string $entity, array $events, IOperation $operation): void {
+        /** @psalm-suppress TaintedCallable newInstance is not called */
+        $reflection = new \ReflectionClass($entity);
+        if ($entity !== IEntity::class && !in_array(IEntity::class, $reflection->getInterfaceNames())) {
+            throw new \UnexpectedValueException($this->l->t('Entity %s is invalid', [$entity]));
+        }
+
+        try {
+            $instance = $this->container->get($entity);
+        } catch (ContainerExceptionInterface $e) {
+            throw new \UnexpectedValueException($this->l->t('Entity %s does not exist', [$entity]));
+        }
+
+        if (empty($events)) {
+            if (!$operation instanceof IComplexOperation) {
+                throw new \UnexpectedValueException($this->l->t('No events are chosen.'));
+            }
+            return;
+        }
+
+        $availableEvents = [];
+        foreach ($instance->getEvents() as $event) {
+            /** @var IEntityEvent $event */
+            $availableEvents[] = $event->getEventName();
+        }
+
+        $diff = array_diff($events, $availableEvents);
+        if (!empty($diff)) {
+            throw new \UnexpectedValueException($this->l->t('Entity %s has no event %s', [$entity, array_shift($diff)]));
+        }
+    }
+
+    /**
+     * @param class-string<IOperation> $class
+     * @param array<int, Check> $checks
+     * @param array $events
+     * @throws \UnexpectedValueException
+     */
+    public function validateOperation(string $class, string $name, array $checks, string $operation, ScopeContext $scope, string $entity, array $events): void {
+        if (strlen($operation) > IManager::MAX_OPERATION_VALUE_BYTES) {
+            throw new \UnexpectedValueException($this->l->t('The provided operation data is too long'));
+        }
+
+        /** @psalm-suppress TaintedCallable newInstance is not called */
+        $reflection = new \ReflectionClass($class);
+        if ($class !== IOperation::class && !in_array(IOperation::class, $reflection->getInterfaceNames())) {
+            throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]) . join(', ', $reflection->getInterfaceNames()));
+        }
+
+        try {
+            /** @var IOperation $instance */
+            $instance = $this->container->get($class);
+        } catch (ContainerExceptionInterface $e) {
+            throw new \UnexpectedValueException($this->l->t('Operation %s does not exist', [$class]));
+        }
+
+        if (!$instance->isAvailableForScope($scope->getScope())) {
+            throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]));
+        }
+
+        $this->validateEvents($entity, $events, $instance);
+
+        if (count($checks) === 0) {
+            throw new \UnexpectedValueException($this->l->t('At least one check needs to be provided'));
+        }
+
+        $instance->validateOperation($name, $checks, $operation);
+
+        foreach ($checks as $check) {
+            if (!is_string($check['class'])) {
+                throw new \UnexpectedValueException($this->l->t('Invalid check provided'));
+            }
+
+            if (strlen((string)$check['value']) > IManager::MAX_CHECK_VALUE_BYTES) {
+                throw new \UnexpectedValueException($this->l->t('The provided check value is too long'));
+            }
+
+            $reflection = new \ReflectionClass($check['class']);
+            if ($check['class'] !== ICheck::class && !in_array(ICheck::class, $reflection->getInterfaceNames())) {
+                throw new \UnexpectedValueException($this->l->t('Check %s is invalid', [$class]));
+            }
+
+            try {
+                /** @var ICheck $instance */
+                $instance = $this->container->get($check['class']);
+            } catch (ContainerExceptionInterface) {
+                throw new \UnexpectedValueException($this->l->t('Check %s does not exist', [$class]));
+            }
+
+            if (!empty($instance->supportedEntities())
+                && !in_array($entity, $instance->supportedEntities())
+            ) {
+                throw new \UnexpectedValueException($this->l->t('Check %s is not allowed with this entity', [$class]));
+            }
+
+            $instance->validateCheck($check['operator'], $check['value']);
+        }
+    }
+
+    /**
+     * @param int[] $checkIds
+     * @return array<int, Check>
+     */
+    public function getChecks(array $checkIds): array {
+        $checkIds = array_map('intval', $checkIds);
+
+        $checks = [];
+        foreach ($checkIds as $i => $checkId) {
+            if (isset($this->checks[$checkId])) {
+                $checks[$checkId] = $this->checks[$checkId];
+                unset($checkIds[$i]);
+            }
+        }
+
+        if (empty($checkIds)) {
+            return $checks;
+        }
+
+        $query = $this->connection->getQueryBuilder();
+        $query->select('*')
+            ->from('flow_checks')
+            ->where($query->expr()->in('id', $query->createNamedParameter($checkIds, IQueryBuilder::PARAM_INT_ARRAY)));
+        $result = $query->executeQuery();
+
+        while ($row = $result->fetchAssociative()) {
+            /** @var Check $row */
+            $this->checks[(int)$row['id']] = $row;
+            $checks[(int)$row['id']] = $row;
+        }
+        $result->closeCursor();
+
+        $checkIds = array_diff($checkIds, array_keys($checks));
+
+        if (!empty($checkIds)) {
+            $missingCheck = array_pop($checkIds);
+            throw new \UnexpectedValueException($this->l->t('Check #%s does not exist', (string)$missingCheck));
+        }
+
+        return $checks;
+    }
+
+    /**
+     * @return int Check unique ID
+     */
+    protected function addCheck(string $class, string $operator, string $value): int {
+        $hash = md5($class . '::' . $operator . '::' . $value);
+
+        $query = $this->connection->getQueryBuilder();
+        $query->select('id')
+            ->from('flow_checks')
+            ->where($query->expr()->eq('hash', $query->createNamedParameter($hash)));
+        $result = $query->executeQuery();
+
+        if ($row = $result->fetchAssociative()) {
+            $result->closeCursor();
+            return (int)$row['id'];
+        }
+
+        $query = $this->connection->getQueryBuilder();
+        $query->insert('flow_checks')
+            ->values([
+                'class' => $query->createNamedParameter($class),
+                'operator' => $query->createNamedParameter($operator),
+                'value' => $query->createNamedParameter($value),
+                'hash' => $query->createNamedParameter($hash),
+            ]);
+        $query->executeStatement();
+
+        return $query->getLastInsertId();
+    }
+
+    protected function addScope(int $operationId, ScopeContext $scope): void {
+        $query = $this->connection->getQueryBuilder();
+
+        $insertQuery = $query->insert('flow_operations_scope');
+        $insertQuery->values([
+            'operation_id' => $query->createNamedParameter($operationId),
+            'type' => $query->createNamedParameter($scope->getScope()),
+            'value' => $query->createNamedParameter($scope->getScopeId()),
+        ]);
+        $insertQuery->executeStatement();
+    }
+
+    public function formatOperation(array $operation): array {
+        $checkIds = json_decode($operation['checks'], true);
+        $checks = $this->getChecks($checkIds);
+
+        $operation['checks'] = [];
+        foreach ($checks as $check) {
+            // Remove internal values
+            unset($check['id']);
+            unset($check['hash']);
+
+            $operation['checks'][] = $check;
+        }
+        $operation['events'] = json_decode($operation['events'], true) ?? [];
+
+
+        return $operation;
+    }
+
+    /**
+     * @return IEntity[]
+     */
+    public function getEntitiesList(): array {
+        $this->dispatcher->dispatchTyped(new RegisterEntitiesEvent($this));
+
+        return array_values(array_merge($this->getBuildInEntities(), $this->registeredEntities));
+    }
+
+    /**
+     * @return IOperation[]
+     */
+    public function getOperatorList(): array {
+        $this->dispatcher->dispatchTyped(new RegisterOperationsEvent($this));
+
+        return array_merge($this->getBuildInOperators(), $this->registeredOperators);
+    }
+
+    /**
+     * @return ICheck[]
+     */
+    public function getCheckList(): array {
+        $this->dispatcher->dispatchTyped(new RegisterChecksEvent($this));
+
+        return array_merge($this->getBuildInChecks(), $this->registeredChecks);
+    }
+
+    public function registerEntity(IEntity $entity): void {
+        $this->registeredEntities[get_class($entity)] = $entity;
+    }
+
+    public function registerOperation(IOperation $operator): void {
+        $this->registeredOperators[get_class($operator)] = $operator;
+    }
+
+    public function registerCheck(ICheck $check): void {
+        $this->registeredChecks[get_class($check)] = $check;
+    }
+
+    /**
+     * @return IEntity[]
+     */
+    protected function getBuildInEntities(): array {
+        try {
+            return [
+                File::class => $this->container->get(File::class),
+            ];
+        } catch (ContainerExceptionInterface $e) {
+            $this->logger->error($e->getMessage(), ['exception' => $e]);
+            return [];
+        }
+    }
+
+    /**
+     * @return IOperation[]
+     */
+    protected function getBuildInOperators(): array {
+        try {
+            return [
+                // None yet
+            ];
+        } catch (ContainerExceptionInterface $e) {
+            $this->logger->error($e->getMessage(), ['exception' => $e]);
+            return [];
+        }
+    }
+
+    /**
+     * @return ICheck[]
+     */
+    protected function getBuildInChecks(): array {
+        try {
+            return [
+                $this->container->get(FileMimeType::class),
+                $this->container->get(FileName::class),
+                $this->container->get(FileSize::class),
+                $this->container->get(FileSystemTags::class),
+                $this->container->get(RequestRemoteAddress::class),
+                $this->container->get(RequestTime::class),
+                $this->container->get(RequestURL::class),
+                $this->container->get(RequestUserAgent::class),
+                $this->container->get(UserGroupMembership::class),
+            ];
+        } catch (ContainerExceptionInterface $e) {
+            $this->logger->error($e->getMessage(), ['exception' => $e]);
+            return [];
+        }
+    }
+
+    public function isUserScopeEnabled(): bool {
+        return !$this->appConfig->getAppValueBool('user_scope_disabled');
+    }
 }

Spacing +12 added lines, -12 removed lines

@@ -155,7 +155,7 @@ 
 		while ($row = $result->fetchAssociative()) {
 			$scope = new ScopeContext($row['type'], $row['value']);
 
-			if (!$operation->isAvailableForScope((int)$row['type'])) {
+			if (!$operation->isAvailableForScope((int) $row['type'])) {
 				continue;
 			}
 
@@ -195,7 +195,7 @@ 
 				continue;
 			}
 
-			if (!$operation->isAvailableForScope((int)$row['scope_type'])) {
+			if (!$operation->isAvailableForScope((int) $row['scope_type'])) {
 				continue;
 			}
 
@@ -321,7 +321,7 @@ 
 
 		$operations = [];
 		while (($opId = $result->fetchOne()) !== false) {
-			$operations[] = (int)$opId;
+			$operations[] = (int) $opId;
 		}
 		$this->operationsByScope[$scopeContext->getHash()] = $operations;
 		$result->closeCursor();
@@ -393,12 +393,12 @@ 
 		$query = $this->connection->getQueryBuilder();
 		try {
 			$this->connection->beginTransaction();
-			$result = (bool)$query->delete('flow_operations')
+			$result = (bool) $query->delete('flow_operations')
 				->where($query->expr()->eq('id', $query->createNamedParameter($id)))
 				->executeStatement();
 			if ($result) {
 				$qb = $this->connection->getQueryBuilder();
-				$result = (bool)$qb->delete('flow_operations_scope')
+				$result = (bool) $qb->delete('flow_operations_scope')
 					->where($qb->expr()->eq('operation_id', $qb->createNamedParameter($id)))
 					->executeStatement();
 			}
@@ -467,7 +467,7 @@ 
 		/** @psalm-suppress TaintedCallable newInstance is not called */
 		$reflection = new \ReflectionClass($class);
 		if ($class !== IOperation::class && !in_array(IOperation::class, $reflection->getInterfaceNames())) {
-			throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]) . join(', ', $reflection->getInterfaceNames()));
+			throw new \UnexpectedValueException($this->l->t('Operation %s is invalid', [$class]).join(', ', $reflection->getInterfaceNames()));
 		}
 
 		try {
@@ -494,7 +494,7 @@ 
 				throw new \UnexpectedValueException($this->l->t('Invalid check provided'));
 			}
 
-			if (strlen((string)$check['value']) > IManager::MAX_CHECK_VALUE_BYTES) {
+			if (strlen((string) $check['value']) > IManager::MAX_CHECK_VALUE_BYTES) {
 				throw new \UnexpectedValueException($this->l->t('The provided check value is too long'));
 			}
 
@@ -547,8 +547,8 @@ 
 
 		while ($row = $result->fetchAssociative()) {
 			/** @var Check $row */
-			$this->checks[(int)$row['id']] = $row;
-			$checks[(int)$row['id']] = $row;
+			$this->checks[(int) $row['id']] = $row;
+			$checks[(int) $row['id']] = $row;
 		}
 		$result->closeCursor();
 
@@ -556,7 +556,7 @@ 
 
 		if (!empty($checkIds)) {
 			$missingCheck = array_pop($checkIds);
-			throw new \UnexpectedValueException($this->l->t('Check #%s does not exist', (string)$missingCheck));
+			throw new \UnexpectedValueException($this->l->t('Check #%s does not exist', (string) $missingCheck));
 		}
 
 		return $checks;
@@ -566,7 +566,7 @@ 
 	 * @return int Check unique ID
 	 */
 	protected function addCheck(string $class, string $operator, string $value): int {
-		$hash = md5($class . '::' . $operator . '::' . $value);
+		$hash = md5($class.'::'.$operator.'::'.$value);
 
 		$query = $this->connection->getQueryBuilder();
 		$query->select('id')
@@ -576,7 +576,7 @@ 
 
 		if ($row = $result->fetchAssociative()) {
 			$result->closeCursor();
-			return (int)$row['id'];
+			return (int) $row['id'];
 		}
 
 		$query = $this->connection->getQueryBuilder();

apps/workflowengine/tests/ManagerTest.php

Indentation +747 added lines, -747 removed lines

@@ -39,33 +39,33 @@ 
 use Test\TestCase;
 
 class TestAdminOp implements IOperation {
-	public function getDisplayName(): string {
-		return 'Admin';
-	}
+    public function getDisplayName(): string {
+        return 'Admin';
+    }
 
-	public function getDescription(): string {
-		return '';
-	}
+    public function getDescription(): string {
+        return '';
+    }
 
-	public function getIcon(): string {
-		return '';
-	}
+    public function getIcon(): string {
+        return '';
+    }
 
-	public function isAvailableForScope(int $scope): bool {
-		return true;
-	}
+    public function isAvailableForScope(int $scope): bool {
+        return true;
+    }
 
-	public function validateOperation(string $name, array $checks, string $operation): void {
-	}
+    public function validateOperation(string $name, array $checks, string $operation): void {
+    }
 
-	public function onEvent(string $eventName, Event $event, IRuleMatcher $ruleMatcher): void {
-	}
+    public function onEvent(string $eventName, Event $event, IRuleMatcher $ruleMatcher): void {
+    }
 }
 
 class TestUserOp extends TestAdminOp {
-	public function getDisplayName(): string {
-		return 'User';
-	}
+    public function getDisplayName(): string {
+        return 'User';
+    }
 }
 
 /**
@@ -75,732 +75,732 @@ 
  */
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class ManagerTest extends TestCase {
-	protected Manager $manager;
-	protected IDBConnection $db;
-	protected LoggerInterface&MockObject $logger;
-	protected ContainerInterface&MockObject $container;
-	protected IUserSession&MockObject $session;
-	protected IL10N&MockObject $l;
-	protected IEventDispatcher&MockObject $dispatcher;
-	protected IAppConfig&MockObject $config;
-	protected ICacheFactory&MockObject $cacheFactory;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->db = Server::get(IDBConnection::class);
-		$this->container = $this->createMock(ContainerInterface::class);
-		$this->l = $this->createMock(IL10N::class);
-		$this->l->method('t')
-			->willReturnCallback(function ($text, $parameters = []) {
-				return vsprintf($text, $parameters);
-			});
-
-		$this->logger = $this->createMock(LoggerInterface::class);
-		$this->session = $this->createMock(IUserSession::class);
-		$this->dispatcher = $this->createMock(IEventDispatcher::class);
-		$this->config = $this->createMock(IAppConfig::class);
-		$this->cacheFactory = $this->createMock(ICacheFactory::class);
-
-		$this->manager = new Manager(
-			$this->db,
-			$this->container,
-			$this->l,
-			$this->logger,
-			$this->session,
-			$this->dispatcher,
-			$this->config,
-			$this->cacheFactory
-		);
-		$this->clearTables();
-	}
-
-	protected function tearDown(): void {
-		$this->clearTables();
-		parent::tearDown();
-	}
-
-	protected function buildScope(?string $scopeId = null): MockObject&ScopeContext {
-		$scopeContext = $this->createMock(ScopeContext::class);
-		$scopeContext->expects($this->any())
-			->method('getScope')
-			->willReturn($scopeId ? IManager::SCOPE_USER : IManager::SCOPE_ADMIN);
-		$scopeContext->expects($this->any())
-			->method('getScopeId')
-			->willReturn($scopeId ?? '');
-		$scopeContext->expects($this->any())
-			->method('getHash')
-			->willReturn(md5($scopeId ?? ''));
-
-		return $scopeContext;
-	}
-
-	public function clearTables() {
-		$query = $this->db->getQueryBuilder();
-		foreach (['flow_checks', 'flow_operations', 'flow_operations_scope'] as $table) {
-			$query->delete($table)
-				->executeStatement();
-		}
-	}
-
-	public function testChecks(): void {
-		$check1 = $this->invokePrivate($this->manager, 'addCheck', ['Test', 'equal', 1]);
-		$check2 = $this->invokePrivate($this->manager, 'addCheck', ['Test', '!equal', 2]);
-
-		$data = $this->manager->getChecks([$check1]);
-		$this->assertArrayHasKey($check1, $data);
-		$this->assertArrayNotHasKey($check2, $data);
-
-		$data = $this->manager->getChecks([$check1, $check2]);
-		$this->assertArrayHasKey($check1, $data);
-		$this->assertArrayHasKey($check2, $data);
-
-		$data = $this->manager->getChecks([$check2, $check1]);
-		$this->assertArrayHasKey($check1, $data);
-		$this->assertArrayHasKey($check2, $data);
-
-		$data = $this->manager->getChecks([$check2]);
-		$this->assertArrayNotHasKey($check1, $data);
-		$this->assertArrayHasKey($check2, $data);
-	}
-
-	public function testScope(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$opId1 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test01', [11, 22], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
-
-		$opId2 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test02', [33, 22], 'bar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
-		$opId3 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test03', [11, 44], 'foobar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
-
-		$this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId1, $adminScope]));
-		$this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId2, $adminScope]));
-		$this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId3, $adminScope]));
-
-		$this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId1, $userScope]));
-		$this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId2, $userScope]));
-		$this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId3, $userScope]));
-	}
-
-	public function testGetAllOperations(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$adminOperation = $this->createMock(IOperation::class);
-		$adminOperation->expects($this->any())
-			->method('isAvailableForScope')
-			->willReturnMap([
-				[IManager::SCOPE_ADMIN, true],
-				[IManager::SCOPE_USER, false],
-			]);
-		$userOperation = $this->createMock(IOperation::class);
-		$userOperation->expects($this->any())
-			->method('isAvailableForScope')
-			->willReturnMap([
-				[IManager::SCOPE_ADMIN, false],
-				[IManager::SCOPE_USER, true],
-			]);
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($adminOperation, $userOperation) {
-				switch ($className) {
-					case 'OCA\WFE\TestAdminOp':
-						return $adminOperation;
-					case 'OCA\WFE\TestUserOp':
-						return $userOperation;
-				}
-			});
-
-		$opId1 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestAdminOp', 'Test01', [11, 22], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
-
-		$opId2 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestUserOp', 'Test02', [33, 22], 'bar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
-		$opId3 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestUserOp', 'Test03', [11, 44], 'foobar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
-
-		$opId4 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestAdminOp', 'Test04', [41, 10, 4], 'NoBar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId4, $userScope]);
-
-		$adminOps = $this->manager->getAllOperations($adminScope);
-		$userOps = $this->manager->getAllOperations($userScope);
-
-		$this->assertSame(1, count($adminOps));
-		$this->assertTrue(array_key_exists('OCA\WFE\TestAdminOp', $adminOps));
-		$this->assertFalse(array_key_exists('OCA\WFE\TestUserOp', $adminOps));
-
-		$this->assertSame(1, count($userOps));
-		$this->assertFalse(array_key_exists('OCA\WFE\TestAdminOp', $userOps));
-		$this->assertTrue(array_key_exists('OCA\WFE\TestUserOp', $userOps));
-		$this->assertSame(2, count($userOps['OCA\WFE\TestUserOp']));
-	}
-
-	public function testGetOperations(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$opId1 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test01', [11, 22], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
-		$opId4 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\OtherTestOp', 'Test04', [5], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId4, $adminScope]);
-
-		$opId2 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test02', [33, 22], 'bar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
-		$opId3 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestOp', 'Test03', [11, 44], 'foobar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
-		$opId5 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\OtherTestOp', 'Test05', [5], 'foobar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId5, $userScope]);
-
-		$operation = $this->createMock(IOperation::class);
-		$operation->expects($this->any())
-			->method('isAvailableForScope')
-			->willReturnMap([
-				[IManager::SCOPE_ADMIN, true],
-				[IManager::SCOPE_USER, true],
-			]);
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($operation) {
-				switch ($className) {
-					case 'OCA\WFE\TestOp':
-						return $operation;
-					case 'OCA\WFE\OtherTestOp':
-						throw new QueryException();
-				}
-			});
-
-		$adminOps = $this->manager->getOperations('OCA\WFE\TestOp', $adminScope);
-		$userOps = $this->manager->getOperations('OCA\WFE\TestOp', $userScope);
-
-		$this->assertSame(1, count($adminOps));
-		array_walk($adminOps, function ($op): void {
-			$this->assertTrue($op['class'] === 'OCA\WFE\TestOp');
-		});
-
-		$this->assertSame(2, count($userOps));
-		array_walk($userOps, function ($op): void {
-			$this->assertTrue($op['class'] === 'OCA\WFE\TestOp');
-		});
-	}
-
-	public function testGetAllConfiguredEvents(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$opId5 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\OtherTestOp', 'Test04', [], 'foo', $entity, [NodeCreatedEvent::class]]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId5, $userScope]);
-
-		$allOperations = null;
-
-		$cache = $this->createMock(ICache::class);
-		$cache
-			->method('get')
-			->willReturnCallback(function () use (&$allOperations) {
-				if ($allOperations) {
-					return $allOperations;
-				}
-
-				return null;
-			});
-
-		$this->cacheFactory->method('createDistributed')->willReturn($cache);
-		$allOperations = $this->manager->getAllConfiguredEvents();
-		$this->assertCount(1, $allOperations);
-
-		$allOperationsCached = $this->manager->getAllConfiguredEvents();
-		$this->assertCount(1, $allOperationsCached);
-		$this->assertEquals($allOperationsCached, $allOperations);
-	}
-
-	public function testUpdateOperation(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$cache = $this->createMock(ICache::class);
-		$cache->expects($this->exactly(4))
-			->method('remove')
-			->with('events');
-		$this->cacheFactory->method('createDistributed')
-			->willReturn($cache);
-
-		$expectedCalls = [
-			[IManager::SCOPE_ADMIN],
-			[IManager::SCOPE_USER],
-		];
-		$i = 0;
-		$operationMock = $this->createMock(IOperation::class);
-		$operationMock->expects($this->any())
-			->method('isAvailableForScope')
-			->willReturnCallback(function () use (&$expectedCalls, &$i): bool {
-				$this->assertEquals($expectedCalls[$i], func_get_args());
-				$i++;
-				return true;
-			});
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($class) use ($operationMock) {
-				if (substr($class, -2) === 'Op') {
-					return $operationMock;
-				} elseif ($class === File::class) {
-					return $this->getMockBuilder(File::class)
-						->setConstructorArgs([
-							$this->l,
-							$this->createMock(IURLGenerator::class),
-							$this->createMock(IRootFolder::class),
-							$this->createMock(IUserSession::class),
-							$this->createMock(ISystemTagManager::class),
-							$this->createMock(IUserManager::class),
-							$this->createMock(UserMountCache::class),
-							$this->createMock(IMountManager::class),
-						])
-						->onlyMethods($this->filterClassMethods(File::class, ['getEvents']))
-						->getMock();
-				}
-				return $this->createMock(ICheck::class);
-			});
-
-		$opId1 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			[TestAdminOp::class, 'Test01', [11, 22], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
-
-		$opId2 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			[TestUserOp::class, 'Test02', [33, 22], 'bar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
-
-		$check1 = ['class' => ICheck::class, 'operator' => 'eq', 'value' => 'asdf'];
-		$check2 = ['class' => ICheck::class, 'operator' => 'eq', 'value' => 23456];
-
-		/** @noinspection PhpUnhandledExceptionInspection */
-		$op = $this->manager->updateOperation($opId1, 'Test01a', [$check1, $check2], 'foohur', $adminScope, $entity, ['\OCP\Files::postDelete']);
-		$this->assertSame('Test01a', $op['name']);
-		$this->assertSame('foohur', $op['operation']);
-
-		/** @noinspection PhpUnhandledExceptionInspection */
-		$op = $this->manager->updateOperation($opId2, 'Test02a', [$check1], 'barfoo', $userScope, $entity, ['\OCP\Files::postDelete']);
-		$this->assertSame('Test02a', $op['name']);
-		$this->assertSame('barfoo', $op['operation']);
-
-		foreach ([[$adminScope, $opId2], [$userScope, $opId1]] as $run) {
-			try {
-				/** @noinspection PhpUnhandledExceptionInspection */
-				$this->manager->updateOperation($run[1], 'Evil', [$check2], 'hackx0r', $run[0], $entity, []);
-				$this->assertTrue(false, 'DomainException not thrown');
-			} catch (\DomainException $e) {
-				$this->assertTrue(true);
-			}
-		}
-	}
-
-	public function testDeleteOperation(): void {
-		$adminScope = $this->buildScope();
-		$userScope = $this->buildScope('jackie');
-		$entity = File::class;
-
-		$cache = $this->createMock(ICache::class);
-		$cache->expects($this->exactly(4))
-			->method('remove')
-			->with('events');
-		$this->cacheFactory->method('createDistributed')->willReturn($cache);
-
-		$opId1 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestAdminOp', 'Test01', [11, 22], 'foo', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
-
-		$opId2 = $this->invokePrivate(
-			$this->manager,
-			'insertOperation',
-			['OCA\WFE\TestUserOp', 'Test02', [33, 22], 'bar', $entity, []]
-		);
-		$this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
-
-		foreach ([[$adminScope, $opId2], [$userScope, $opId1]] as $run) {
-			try {
-				/** @noinspection PhpUnhandledExceptionInspection */
-				$this->manager->deleteOperation($run[1], $run[0]);
-				$this->assertTrue(false, 'DomainException not thrown');
-			} catch (\Exception $e) {
-				$this->assertInstanceOf(\DomainException::class, $e);
-			}
-		}
-
-		/** @noinspection PhpUnhandledExceptionInspection */
-		$this->manager->deleteOperation($opId1, $adminScope);
-		/** @noinspection PhpUnhandledExceptionInspection */
-		$this->manager->deleteOperation($opId2, $userScope);
-
-		foreach ([$opId1, $opId2] as $opId) {
-			try {
-				$this->invokePrivate($this->manager, 'getOperation', [$opId]);
-				$this->assertTrue(false, 'UnexpectedValueException not thrown');
-			} catch (\Exception $e) {
-				$this->assertInstanceOf(\UnexpectedValueException::class, $e);
-			}
-		}
-	}
-
-	public function testGetEntitiesListBuildInOnly(): void {
-		$fileEntityMock = $this->createMock(File::class);
-
-		$this->container->expects($this->once())
-			->method('get')
-			->with(File::class)
-			->willReturn($fileEntityMock);
-
-		$entities = $this->manager->getEntitiesList();
-
-		$this->assertCount(1, $entities);
-		$this->assertInstanceOf(IEntity::class, $entities[0]);
-	}
-
-	public function testGetEntitiesList(): void {
-		$fileEntityMock = $this->createMock(File::class);
-
-		$this->container->expects($this->once())
-			->method('get')
-			->with(File::class)
-			->willReturn($fileEntityMock);
-
-		$extraEntity = $this->createMock(IEntity::class);
-
-		$this->dispatcher->expects($this->once())
-			->method('dispatchTyped')
-			->willReturnCallback(function (RegisterEntitiesEvent $e) use ($extraEntity): void {
-				$this->manager->registerEntity($extraEntity);
-			});
-
-		$entities = $this->manager->getEntitiesList();
-
-		$this->assertCount(2, $entities);
-
-		$entityTypeCounts = array_reduce($entities, function (array $carry, IEntity $entity) {
-			if ($entity instanceof File) {
-				$carry[0]++;
-			} elseif ($entity instanceof IEntity) {
-				$carry[1]++;
-			}
-			return $carry;
-		}, [0, 0]);
-
-		$this->assertSame(1, $entityTypeCounts[0]);
-		$this->assertSame(1, $entityTypeCounts[1]);
-	}
-
-	public function testValidateOperationOK(): void {
-		$check = [
-			'class' => ICheck::class,
-			'operator' => 'is',
-			'value' => 'barfoo',
-		];
-
-		$operationMock = $this->createMock(IOperation::class);
-		$entityMock = $this->createMock(IEntity::class);
-		$eventEntityMock = $this->createMock(IEntityEvent::class);
-		$checkMock = $this->createMock(ICheck::class);
-		$scopeMock = $this->createMock(ScopeContext::class);
-
-		$scopeMock->expects($this->any())
-			->method('getScope')
-			->willReturn(IManager::SCOPE_ADMIN);
-
-		$operationMock->expects($this->once())
-			->method('isAvailableForScope')
-			->with(IManager::SCOPE_ADMIN)
-			->willReturn(true);
-
-		$operationMock->expects($this->once())
-			->method('validateOperation')
-			->with('test', [$check], 'operationData');
-
-		$entityMock->expects($this->any())
-			->method('getEvents')
-			->willReturn([$eventEntityMock]);
-
-		$eventEntityMock->expects($this->any())
-			->method('getEventName')
-			->willReturn('MyEvent');
-
-		$checkMock->expects($this->any())
-			->method('supportedEntities')
-			->willReturn([IEntity::class]);
-		$checkMock->expects($this->atLeastOnce())
-			->method('validateCheck');
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
-				switch ($className) {
-					case IOperation::class:
-						return $operationMock;
-					case IEntity::class:
-						return $entityMock;
-					case IEntityEvent::class:
-						return $eventEntityMock;
-					case ICheck::class:
-						return $checkMock;
-					default:
-						return $this->createMock($className);
-				}
-			});
-
-		$this->manager->validateOperation(IOperation::class, 'test', [$check], 'operationData', $scopeMock, IEntity::class, ['MyEvent']);
-	}
-
-	public function testValidateOperationCheckInputLengthError(): void {
-		$check = [
-			'class' => ICheck::class,
-			'operator' => 'is',
-			'value' => str_pad('', IManager::MAX_CHECK_VALUE_BYTES + 1, 'FooBar'),
-		];
-
-		$operationMock = $this->createMock(IOperation::class);
-		$entityMock = $this->createMock(IEntity::class);
-		$eventEntityMock = $this->createMock(IEntityEvent::class);
-		$checkMock = $this->createMock(ICheck::class);
-		$scopeMock = $this->createMock(ScopeContext::class);
-
-		$scopeMock->expects($this->any())
-			->method('getScope')
-			->willReturn(IManager::SCOPE_ADMIN);
-
-		$operationMock->expects($this->once())
-			->method('isAvailableForScope')
-			->with(IManager::SCOPE_ADMIN)
-			->willReturn(true);
-
-		$operationMock->expects($this->once())
-			->method('validateOperation')
-			->with('test', [$check], 'operationData');
-
-		$entityMock->expects($this->any())
-			->method('getEvents')
-			->willReturn([$eventEntityMock]);
-
-		$eventEntityMock->expects($this->any())
-			->method('getEventName')
-			->willReturn('MyEvent');
-
-		$checkMock->expects($this->any())
-			->method('supportedEntities')
-			->willReturn([IEntity::class]);
-		$checkMock->expects($this->never())
-			->method('validateCheck');
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
-				switch ($className) {
-					case IOperation::class:
-						return $operationMock;
-					case IEntity::class:
-						return $entityMock;
-					case IEntityEvent::class:
-						return $eventEntityMock;
-					case ICheck::class:
-						return $checkMock;
-					default:
-						return $this->createMock($className);
-				}
-			});
-
-		try {
-			$this->manager->validateOperation(IOperation::class, 'test', [$check], 'operationData', $scopeMock, IEntity::class, ['MyEvent']);
-		} catch (\UnexpectedValueException $e) {
-			$this->assertSame('The provided check value is too long', $e->getMessage());
-		}
-	}
-
-	public function testValidateOperationDataLengthError(): void {
-		$check = [
-			'class' => ICheck::class,
-			'operator' => 'is',
-			'value' => 'barfoo',
-		];
-		$operationData = str_pad('', IManager::MAX_OPERATION_VALUE_BYTES + 1, 'FooBar');
-
-		$operationMock = $this->createMock(IOperation::class);
-		$entityMock = $this->createMock(IEntity::class);
-		$eventEntityMock = $this->createMock(IEntityEvent::class);
-		$checkMock = $this->createMock(ICheck::class);
-		$scopeMock = $this->createMock(ScopeContext::class);
-
-		$scopeMock->expects($this->any())
-			->method('getScope')
-			->willReturn(IManager::SCOPE_ADMIN);
-
-		$operationMock->expects($this->never())
-			->method('validateOperation');
-
-		$entityMock->expects($this->any())
-			->method('getEvents')
-			->willReturn([$eventEntityMock]);
-
-		$eventEntityMock->expects($this->any())
-			->method('getEventName')
-			->willReturn('MyEvent');
-
-		$checkMock->expects($this->any())
-			->method('supportedEntities')
-			->willReturn([IEntity::class]);
-		$checkMock->expects($this->never())
-			->method('validateCheck');
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
-				switch ($className) {
-					case IOperation::class:
-						return $operationMock;
-					case IEntity::class:
-						return $entityMock;
-					case IEntityEvent::class:
-						return $eventEntityMock;
-					case ICheck::class:
-						return $checkMock;
-					default:
-						return $this->createMock($className);
-				}
-			});
-
-		try {
-			$this->manager->validateOperation(IOperation::class, 'test', [$check], $operationData, $scopeMock, IEntity::class, ['MyEvent']);
-		} catch (\UnexpectedValueException $e) {
-			$this->assertSame('The provided operation data is too long', $e->getMessage());
-		}
-	}
-
-	public function testValidateOperationScopeNotAvailable(): void {
-		$check = [
-			'class' => ICheck::class,
-			'operator' => 'is',
-			'value' => 'barfoo',
-		];
-		$operationData = str_pad('', IManager::MAX_OPERATION_VALUE_BYTES - 1, 'FooBar');
-
-		$operationMock = $this->createMock(IOperation::class);
-		$entityMock = $this->createMock(IEntity::class);
-		$eventEntityMock = $this->createMock(IEntityEvent::class);
-		$checkMock = $this->createMock(ICheck::class);
-		$scopeMock = $this->createMock(ScopeContext::class);
-
-		$scopeMock->expects($this->any())
-			->method('getScope')
-			->willReturn(IManager::SCOPE_ADMIN);
-
-		$operationMock->expects($this->once())
-			->method('isAvailableForScope')
-			->with(IManager::SCOPE_ADMIN)
-			->willReturn(false);
-
-		$operationMock->expects($this->never())
-			->method('validateOperation');
-
-		$entityMock->expects($this->any())
-			->method('getEvents')
-			->willReturn([$eventEntityMock]);
-
-		$eventEntityMock->expects($this->any())
-			->method('getEventName')
-			->willReturn('MyEvent');
-
-		$checkMock->expects($this->any())
-			->method('supportedEntities')
-			->willReturn([IEntity::class]);
-		$checkMock->expects($this->never())
-			->method('validateCheck');
-
-		$this->container->expects($this->any())
-			->method('get')
-			->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
-				switch ($className) {
-					case IOperation::class:
-						return $operationMock;
-					case IEntity::class:
-						return $entityMock;
-					case IEntityEvent::class:
-						return $eventEntityMock;
-					case ICheck::class:
-						return $checkMock;
-					default:
-						return $this->createMock($className);
-				}
-			});
-
-		try {
-			$this->manager->validateOperation(IOperation::class, 'test', [$check], $operationData, $scopeMock, IEntity::class, ['MyEvent']);
-		} catch (\UnexpectedValueException $e) {
-			$this->assertSame('Operation OCP\WorkflowEngine\IOperation is invalid', $e->getMessage());
-		}
-	}
+    protected Manager $manager;
+    protected IDBConnection $db;
+    protected LoggerInterface&MockObject $logger;
+    protected ContainerInterface&MockObject $container;
+    protected IUserSession&MockObject $session;
+    protected IL10N&MockObject $l;
+    protected IEventDispatcher&MockObject $dispatcher;
+    protected IAppConfig&MockObject $config;
+    protected ICacheFactory&MockObject $cacheFactory;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->db = Server::get(IDBConnection::class);
+        $this->container = $this->createMock(ContainerInterface::class);
+        $this->l = $this->createMock(IL10N::class);
+        $this->l->method('t')
+            ->willReturnCallback(function ($text, $parameters = []) {
+                return vsprintf($text, $parameters);
+            });
+
+        $this->logger = $this->createMock(LoggerInterface::class);
+        $this->session = $this->createMock(IUserSession::class);
+        $this->dispatcher = $this->createMock(IEventDispatcher::class);
+        $this->config = $this->createMock(IAppConfig::class);
+        $this->cacheFactory = $this->createMock(ICacheFactory::class);
+
+        $this->manager = new Manager(
+            $this->db,
+            $this->container,
+            $this->l,
+            $this->logger,
+            $this->session,
+            $this->dispatcher,
+            $this->config,
+            $this->cacheFactory
+        );
+        $this->clearTables();
+    }
+
+    protected function tearDown(): void {
+        $this->clearTables();
+        parent::tearDown();
+    }
+
+    protected function buildScope(?string $scopeId = null): MockObject&ScopeContext {
+        $scopeContext = $this->createMock(ScopeContext::class);
+        $scopeContext->expects($this->any())
+            ->method('getScope')
+            ->willReturn($scopeId ? IManager::SCOPE_USER : IManager::SCOPE_ADMIN);
+        $scopeContext->expects($this->any())
+            ->method('getScopeId')
+            ->willReturn($scopeId ?? '');
+        $scopeContext->expects($this->any())
+            ->method('getHash')
+            ->willReturn(md5($scopeId ?? ''));
+
+        return $scopeContext;
+    }
+
+    public function clearTables() {
+        $query = $this->db->getQueryBuilder();
+        foreach (['flow_checks', 'flow_operations', 'flow_operations_scope'] as $table) {
+            $query->delete($table)
+                ->executeStatement();
+        }
+    }
+
+    public function testChecks(): void {
+        $check1 = $this->invokePrivate($this->manager, 'addCheck', ['Test', 'equal', 1]);
+        $check2 = $this->invokePrivate($this->manager, 'addCheck', ['Test', '!equal', 2]);
+
+        $data = $this->manager->getChecks([$check1]);
+        $this->assertArrayHasKey($check1, $data);
+        $this->assertArrayNotHasKey($check2, $data);
+
+        $data = $this->manager->getChecks([$check1, $check2]);
+        $this->assertArrayHasKey($check1, $data);
+        $this->assertArrayHasKey($check2, $data);
+
+        $data = $this->manager->getChecks([$check2, $check1]);
+        $this->assertArrayHasKey($check1, $data);
+        $this->assertArrayHasKey($check2, $data);
+
+        $data = $this->manager->getChecks([$check2]);
+        $this->assertArrayNotHasKey($check1, $data);
+        $this->assertArrayHasKey($check2, $data);
+    }
+
+    public function testScope(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $opId1 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test01', [11, 22], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
+
+        $opId2 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test02', [33, 22], 'bar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
+        $opId3 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test03', [11, 44], 'foobar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
+
+        $this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId1, $adminScope]));
+        $this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId2, $adminScope]));
+        $this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId3, $adminScope]));
+
+        $this->assertFalse($this->invokePrivate($this->manager, 'canModify', [$opId1, $userScope]));
+        $this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId2, $userScope]));
+        $this->assertTrue($this->invokePrivate($this->manager, 'canModify', [$opId3, $userScope]));
+    }
+
+    public function testGetAllOperations(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $adminOperation = $this->createMock(IOperation::class);
+        $adminOperation->expects($this->any())
+            ->method('isAvailableForScope')
+            ->willReturnMap([
+                [IManager::SCOPE_ADMIN, true],
+                [IManager::SCOPE_USER, false],
+            ]);
+        $userOperation = $this->createMock(IOperation::class);
+        $userOperation->expects($this->any())
+            ->method('isAvailableForScope')
+            ->willReturnMap([
+                [IManager::SCOPE_ADMIN, false],
+                [IManager::SCOPE_USER, true],
+            ]);
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($adminOperation, $userOperation) {
+                switch ($className) {
+                    case 'OCA\WFE\TestAdminOp':
+                        return $adminOperation;
+                    case 'OCA\WFE\TestUserOp':
+                        return $userOperation;
+                }
+            });
+
+        $opId1 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestAdminOp', 'Test01', [11, 22], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
+
+        $opId2 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestUserOp', 'Test02', [33, 22], 'bar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
+        $opId3 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestUserOp', 'Test03', [11, 44], 'foobar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
+
+        $opId4 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestAdminOp', 'Test04', [41, 10, 4], 'NoBar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId4, $userScope]);
+
+        $adminOps = $this->manager->getAllOperations($adminScope);
+        $userOps = $this->manager->getAllOperations($userScope);
+
+        $this->assertSame(1, count($adminOps));
+        $this->assertTrue(array_key_exists('OCA\WFE\TestAdminOp', $adminOps));
+        $this->assertFalse(array_key_exists('OCA\WFE\TestUserOp', $adminOps));
+
+        $this->assertSame(1, count($userOps));
+        $this->assertFalse(array_key_exists('OCA\WFE\TestAdminOp', $userOps));
+        $this->assertTrue(array_key_exists('OCA\WFE\TestUserOp', $userOps));
+        $this->assertSame(2, count($userOps['OCA\WFE\TestUserOp']));
+    }
+
+    public function testGetOperations(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $opId1 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test01', [11, 22], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
+        $opId4 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\OtherTestOp', 'Test04', [5], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId4, $adminScope]);
+
+        $opId2 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test02', [33, 22], 'bar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
+        $opId3 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestOp', 'Test03', [11, 44], 'foobar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId3, $userScope]);
+        $opId5 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\OtherTestOp', 'Test05', [5], 'foobar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId5, $userScope]);
+
+        $operation = $this->createMock(IOperation::class);
+        $operation->expects($this->any())
+            ->method('isAvailableForScope')
+            ->willReturnMap([
+                [IManager::SCOPE_ADMIN, true],
+                [IManager::SCOPE_USER, true],
+            ]);
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($operation) {
+                switch ($className) {
+                    case 'OCA\WFE\TestOp':
+                        return $operation;
+                    case 'OCA\WFE\OtherTestOp':
+                        throw new QueryException();
+                }
+            });
+
+        $adminOps = $this->manager->getOperations('OCA\WFE\TestOp', $adminScope);
+        $userOps = $this->manager->getOperations('OCA\WFE\TestOp', $userScope);
+
+        $this->assertSame(1, count($adminOps));
+        array_walk($adminOps, function ($op): void {
+            $this->assertTrue($op['class'] === 'OCA\WFE\TestOp');
+        });
+
+        $this->assertSame(2, count($userOps));
+        array_walk($userOps, function ($op): void {
+            $this->assertTrue($op['class'] === 'OCA\WFE\TestOp');
+        });
+    }
+
+    public function testGetAllConfiguredEvents(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $opId5 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\OtherTestOp', 'Test04', [], 'foo', $entity, [NodeCreatedEvent::class]]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId5, $userScope]);
+
+        $allOperations = null;
+
+        $cache = $this->createMock(ICache::class);
+        $cache
+            ->method('get')
+            ->willReturnCallback(function () use (&$allOperations) {
+                if ($allOperations) {
+                    return $allOperations;
+                }
+
+                return null;
+            });
+
+        $this->cacheFactory->method('createDistributed')->willReturn($cache);
+        $allOperations = $this->manager->getAllConfiguredEvents();
+        $this->assertCount(1, $allOperations);
+
+        $allOperationsCached = $this->manager->getAllConfiguredEvents();
+        $this->assertCount(1, $allOperationsCached);
+        $this->assertEquals($allOperationsCached, $allOperations);
+    }
+
+    public function testUpdateOperation(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $cache = $this->createMock(ICache::class);
+        $cache->expects($this->exactly(4))
+            ->method('remove')
+            ->with('events');
+        $this->cacheFactory->method('createDistributed')
+            ->willReturn($cache);
+
+        $expectedCalls = [
+            [IManager::SCOPE_ADMIN],
+            [IManager::SCOPE_USER],
+        ];
+        $i = 0;
+        $operationMock = $this->createMock(IOperation::class);
+        $operationMock->expects($this->any())
+            ->method('isAvailableForScope')
+            ->willReturnCallback(function () use (&$expectedCalls, &$i): bool {
+                $this->assertEquals($expectedCalls[$i], func_get_args());
+                $i++;
+                return true;
+            });
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($class) use ($operationMock) {
+                if (substr($class, -2) === 'Op') {
+                    return $operationMock;
+                } elseif ($class === File::class) {
+                    return $this->getMockBuilder(File::class)
+                        ->setConstructorArgs([
+                            $this->l,
+                            $this->createMock(IURLGenerator::class),
+                            $this->createMock(IRootFolder::class),
+                            $this->createMock(IUserSession::class),
+                            $this->createMock(ISystemTagManager::class),
+                            $this->createMock(IUserManager::class),
+                            $this->createMock(UserMountCache::class),
+                            $this->createMock(IMountManager::class),
+                        ])
+                        ->onlyMethods($this->filterClassMethods(File::class, ['getEvents']))
+                        ->getMock();
+                }
+                return $this->createMock(ICheck::class);
+            });
+
+        $opId1 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            [TestAdminOp::class, 'Test01', [11, 22], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
+
+        $opId2 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            [TestUserOp::class, 'Test02', [33, 22], 'bar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
+
+        $check1 = ['class' => ICheck::class, 'operator' => 'eq', 'value' => 'asdf'];
+        $check2 = ['class' => ICheck::class, 'operator' => 'eq', 'value' => 23456];
+
+        /** @noinspection PhpUnhandledExceptionInspection */
+        $op = $this->manager->updateOperation($opId1, 'Test01a', [$check1, $check2], 'foohur', $adminScope, $entity, ['\OCP\Files::postDelete']);
+        $this->assertSame('Test01a', $op['name']);
+        $this->assertSame('foohur', $op['operation']);
+
+        /** @noinspection PhpUnhandledExceptionInspection */
+        $op = $this->manager->updateOperation($opId2, 'Test02a', [$check1], 'barfoo', $userScope, $entity, ['\OCP\Files::postDelete']);
+        $this->assertSame('Test02a', $op['name']);
+        $this->assertSame('barfoo', $op['operation']);
+
+        foreach ([[$adminScope, $opId2], [$userScope, $opId1]] as $run) {
+            try {
+                /** @noinspection PhpUnhandledExceptionInspection */
+                $this->manager->updateOperation($run[1], 'Evil', [$check2], 'hackx0r', $run[0], $entity, []);
+                $this->assertTrue(false, 'DomainException not thrown');
+            } catch (\DomainException $e) {
+                $this->assertTrue(true);
+            }
+        }
+    }
+
+    public function testDeleteOperation(): void {
+        $adminScope = $this->buildScope();
+        $userScope = $this->buildScope('jackie');
+        $entity = File::class;
+
+        $cache = $this->createMock(ICache::class);
+        $cache->expects($this->exactly(4))
+            ->method('remove')
+            ->with('events');
+        $this->cacheFactory->method('createDistributed')->willReturn($cache);
+
+        $opId1 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestAdminOp', 'Test01', [11, 22], 'foo', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId1, $adminScope]);
+
+        $opId2 = $this->invokePrivate(
+            $this->manager,
+            'insertOperation',
+            ['OCA\WFE\TestUserOp', 'Test02', [33, 22], 'bar', $entity, []]
+        );
+        $this->invokePrivate($this->manager, 'addScope', [$opId2, $userScope]);
+
+        foreach ([[$adminScope, $opId2], [$userScope, $opId1]] as $run) {
+            try {
+                /** @noinspection PhpUnhandledExceptionInspection */
+                $this->manager->deleteOperation($run[1], $run[0]);
+                $this->assertTrue(false, 'DomainException not thrown');
+            } catch (\Exception $e) {
+                $this->assertInstanceOf(\DomainException::class, $e);
+            }
+        }
+
+        /** @noinspection PhpUnhandledExceptionInspection */
+        $this->manager->deleteOperation($opId1, $adminScope);
+        /** @noinspection PhpUnhandledExceptionInspection */
+        $this->manager->deleteOperation($opId2, $userScope);
+
+        foreach ([$opId1, $opId2] as $opId) {
+            try {
+                $this->invokePrivate($this->manager, 'getOperation', [$opId]);
+                $this->assertTrue(false, 'UnexpectedValueException not thrown');
+            } catch (\Exception $e) {
+                $this->assertInstanceOf(\UnexpectedValueException::class, $e);
+            }
+        }
+    }
+
+    public function testGetEntitiesListBuildInOnly(): void {
+        $fileEntityMock = $this->createMock(File::class);
+
+        $this->container->expects($this->once())
+            ->method('get')
+            ->with(File::class)
+            ->willReturn($fileEntityMock);
+
+        $entities = $this->manager->getEntitiesList();
+
+        $this->assertCount(1, $entities);
+        $this->assertInstanceOf(IEntity::class, $entities[0]);
+    }
+
+    public function testGetEntitiesList(): void {
+        $fileEntityMock = $this->createMock(File::class);
+
+        $this->container->expects($this->once())
+            ->method('get')
+            ->with(File::class)
+            ->willReturn($fileEntityMock);
+
+        $extraEntity = $this->createMock(IEntity::class);
+
+        $this->dispatcher->expects($this->once())
+            ->method('dispatchTyped')
+            ->willReturnCallback(function (RegisterEntitiesEvent $e) use ($extraEntity): void {
+                $this->manager->registerEntity($extraEntity);
+            });
+
+        $entities = $this->manager->getEntitiesList();
+
+        $this->assertCount(2, $entities);
+
+        $entityTypeCounts = array_reduce($entities, function (array $carry, IEntity $entity) {
+            if ($entity instanceof File) {
+                $carry[0]++;
+            } elseif ($entity instanceof IEntity) {
+                $carry[1]++;
+            }
+            return $carry;
+        }, [0, 0]);
+
+        $this->assertSame(1, $entityTypeCounts[0]);
+        $this->assertSame(1, $entityTypeCounts[1]);
+    }
+
+    public function testValidateOperationOK(): void {
+        $check = [
+            'class' => ICheck::class,
+            'operator' => 'is',
+            'value' => 'barfoo',
+        ];
+
+        $operationMock = $this->createMock(IOperation::class);
+        $entityMock = $this->createMock(IEntity::class);
+        $eventEntityMock = $this->createMock(IEntityEvent::class);
+        $checkMock = $this->createMock(ICheck::class);
+        $scopeMock = $this->createMock(ScopeContext::class);
+
+        $scopeMock->expects($this->any())
+            ->method('getScope')
+            ->willReturn(IManager::SCOPE_ADMIN);
+
+        $operationMock->expects($this->once())
+            ->method('isAvailableForScope')
+            ->with(IManager::SCOPE_ADMIN)
+            ->willReturn(true);
+
+        $operationMock->expects($this->once())
+            ->method('validateOperation')
+            ->with('test', [$check], 'operationData');
+
+        $entityMock->expects($this->any())
+            ->method('getEvents')
+            ->willReturn([$eventEntityMock]);
+
+        $eventEntityMock->expects($this->any())
+            ->method('getEventName')
+            ->willReturn('MyEvent');
+
+        $checkMock->expects($this->any())
+            ->method('supportedEntities')
+            ->willReturn([IEntity::class]);
+        $checkMock->expects($this->atLeastOnce())
+            ->method('validateCheck');
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
+                switch ($className) {
+                    case IOperation::class:
+                        return $operationMock;
+                    case IEntity::class:
+                        return $entityMock;
+                    case IEntityEvent::class:
+                        return $eventEntityMock;
+                    case ICheck::class:
+                        return $checkMock;
+                    default:
+                        return $this->createMock($className);
+                }
+            });
+
+        $this->manager->validateOperation(IOperation::class, 'test', [$check], 'operationData', $scopeMock, IEntity::class, ['MyEvent']);
+    }
+
+    public function testValidateOperationCheckInputLengthError(): void {
+        $check = [
+            'class' => ICheck::class,
+            'operator' => 'is',
+            'value' => str_pad('', IManager::MAX_CHECK_VALUE_BYTES + 1, 'FooBar'),
+        ];
+
+        $operationMock = $this->createMock(IOperation::class);
+        $entityMock = $this->createMock(IEntity::class);
+        $eventEntityMock = $this->createMock(IEntityEvent::class);
+        $checkMock = $this->createMock(ICheck::class);
+        $scopeMock = $this->createMock(ScopeContext::class);
+
+        $scopeMock->expects($this->any())
+            ->method('getScope')
+            ->willReturn(IManager::SCOPE_ADMIN);
+
+        $operationMock->expects($this->once())
+            ->method('isAvailableForScope')
+            ->with(IManager::SCOPE_ADMIN)
+            ->willReturn(true);
+
+        $operationMock->expects($this->once())
+            ->method('validateOperation')
+            ->with('test', [$check], 'operationData');
+
+        $entityMock->expects($this->any())
+            ->method('getEvents')
+            ->willReturn([$eventEntityMock]);
+
+        $eventEntityMock->expects($this->any())
+            ->method('getEventName')
+            ->willReturn('MyEvent');
+
+        $checkMock->expects($this->any())
+            ->method('supportedEntities')
+            ->willReturn([IEntity::class]);
+        $checkMock->expects($this->never())
+            ->method('validateCheck');
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
+                switch ($className) {
+                    case IOperation::class:
+                        return $operationMock;
+                    case IEntity::class:
+                        return $entityMock;
+                    case IEntityEvent::class:
+                        return $eventEntityMock;
+                    case ICheck::class:
+                        return $checkMock;
+                    default:
+                        return $this->createMock($className);
+                }
+            });
+
+        try {
+            $this->manager->validateOperation(IOperation::class, 'test', [$check], 'operationData', $scopeMock, IEntity::class, ['MyEvent']);
+        } catch (\UnexpectedValueException $e) {
+            $this->assertSame('The provided check value is too long', $e->getMessage());
+        }
+    }
+
+    public function testValidateOperationDataLengthError(): void {
+        $check = [
+            'class' => ICheck::class,
+            'operator' => 'is',
+            'value' => 'barfoo',
+        ];
+        $operationData = str_pad('', IManager::MAX_OPERATION_VALUE_BYTES + 1, 'FooBar');
+
+        $operationMock = $this->createMock(IOperation::class);
+        $entityMock = $this->createMock(IEntity::class);
+        $eventEntityMock = $this->createMock(IEntityEvent::class);
+        $checkMock = $this->createMock(ICheck::class);
+        $scopeMock = $this->createMock(ScopeContext::class);
+
+        $scopeMock->expects($this->any())
+            ->method('getScope')
+            ->willReturn(IManager::SCOPE_ADMIN);
+
+        $operationMock->expects($this->never())
+            ->method('validateOperation');
+
+        $entityMock->expects($this->any())
+            ->method('getEvents')
+            ->willReturn([$eventEntityMock]);
+
+        $eventEntityMock->expects($this->any())
+            ->method('getEventName')
+            ->willReturn('MyEvent');
+
+        $checkMock->expects($this->any())
+            ->method('supportedEntities')
+            ->willReturn([IEntity::class]);
+        $checkMock->expects($this->never())
+            ->method('validateCheck');
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
+                switch ($className) {
+                    case IOperation::class:
+                        return $operationMock;
+                    case IEntity::class:
+                        return $entityMock;
+                    case IEntityEvent::class:
+                        return $eventEntityMock;
+                    case ICheck::class:
+                        return $checkMock;
+                    default:
+                        return $this->createMock($className);
+                }
+            });
+
+        try {
+            $this->manager->validateOperation(IOperation::class, 'test', [$check], $operationData, $scopeMock, IEntity::class, ['MyEvent']);
+        } catch (\UnexpectedValueException $e) {
+            $this->assertSame('The provided operation data is too long', $e->getMessage());
+        }
+    }
+
+    public function testValidateOperationScopeNotAvailable(): void {
+        $check = [
+            'class' => ICheck::class,
+            'operator' => 'is',
+            'value' => 'barfoo',
+        ];
+        $operationData = str_pad('', IManager::MAX_OPERATION_VALUE_BYTES - 1, 'FooBar');
+
+        $operationMock = $this->createMock(IOperation::class);
+        $entityMock = $this->createMock(IEntity::class);
+        $eventEntityMock = $this->createMock(IEntityEvent::class);
+        $checkMock = $this->createMock(ICheck::class);
+        $scopeMock = $this->createMock(ScopeContext::class);
+
+        $scopeMock->expects($this->any())
+            ->method('getScope')
+            ->willReturn(IManager::SCOPE_ADMIN);
+
+        $operationMock->expects($this->once())
+            ->method('isAvailableForScope')
+            ->with(IManager::SCOPE_ADMIN)
+            ->willReturn(false);
+
+        $operationMock->expects($this->never())
+            ->method('validateOperation');
+
+        $entityMock->expects($this->any())
+            ->method('getEvents')
+            ->willReturn([$eventEntityMock]);
+
+        $eventEntityMock->expects($this->any())
+            ->method('getEventName')
+            ->willReturn('MyEvent');
+
+        $checkMock->expects($this->any())
+            ->method('supportedEntities')
+            ->willReturn([IEntity::class]);
+        $checkMock->expects($this->never())
+            ->method('validateCheck');
+
+        $this->container->expects($this->any())
+            ->method('get')
+            ->willReturnCallback(function ($className) use ($operationMock, $entityMock, $eventEntityMock, $checkMock) {
+                switch ($className) {
+                    case IOperation::class:
+                        return $operationMock;
+                    case IEntity::class:
+                        return $entityMock;
+                    case IEntityEvent::class:
+                        return $eventEntityMock;
+                    case ICheck::class:
+                        return $checkMock;
+                    default:
+                        return $this->createMock($className);
+                }
+            });
+
+        try {
+            $this->manager->validateOperation(IOperation::class, 'test', [$check], $operationData, $scopeMock, IEntity::class, ['MyEvent']);
+        } catch (\UnexpectedValueException $e) {
+            $this->assertSame('Operation OCP\WorkflowEngine\IOperation is invalid', $e->getMessage());
+        }
+    }
 }