nextcloud / server

apps/workflowengine/lib/Manager.php

Indentation +647 added lines, -647 removed lines

@@ -60,652 +60,652 @@
 
 class Manager implements IManager {
 
-	/** @var IStorage */
-	protected $storage;
+    /** @var IStorage */
+    protected $storage;
 
-	/** @var string */
-	protected $path;
-
-	/** @var object */
-	protected $entity;
-
-	/** @var array[] */
-	protected $operations = [];
-
-	/** @var array[] */
-	protected $checks = [];
-
-	/** @var IDBConnection */
-	protected $connection;
-
-	/** @var IServerContainer|\OC\Server */
-	protected $container;
-
-	/** @var IL10N */
-	protected $l;
-
-	/** @var LegacyDispatcher */
-	protected $legacyEventDispatcher;
-
-	/** @var IEntity[] */
-	protected $registeredEntities = [];
-
-	/** @var IOperation[] */
-	protected $registeredOperators = [];
-
-	/** @var ICheck[] */
-	protected $registeredChecks = [];
-
-	/** @var ILogger */
-	protected $logger;
-
-	/** @var CappedMemoryCache */
-	protected $operationsByScope = [];
-
-	/** @var IUserSession */
-	protected $session;
-
-	/** @var IEventDispatcher */
-	private $dispatcher;
-
-	public function __construct(
-		IDBConnection $connection,
-		IServerContainer $container,
-		IL10N $l,
-		LegacyDispatcher $eventDispatcher,
-		ILogger $logger,
-		IUserSession $session,
-		IEventDispatcher $dispatcher
-	) {
-		$this->connection = $connection;
-		$this->container = $container;
-		$this->l = $l;
-		$this->legacyEventDispatcher = $eventDispatcher;
-		$this->logger = $logger;
-		$this->operationsByScope = new CappedMemoryCache(64);
-		$this->session = $session;
-		$this->dispatcher = $dispatcher;
-	}
-
-	public function getRuleMatcher(): IRuleMatcher {
-		return new RuleMatcher(
-			$this->session,
-			$this->container,
-			$this->l,
-			$this,
-			$this->container->query(Logger::class)
-		);
-	}
-
-	public function getAllConfiguredEvents() {
-		$query = $this->connection->getQueryBuilder();
-
-		$query->selectDistinct('class')
-			->addSelect('entity', 'events')
-			->from('flow_operations')
-			->where($query->expr()->neq('events', $query->createNamedParameter('[]'), IQueryBuilder::PARAM_STR));
-
-		$result = $query->execute();
-		$operations = [];
-		while($row = $result->fetch()) {
-			$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();
-
-		return $operations;
-	}
-
-	/**
-	 * @param string $operationClass
-	 * @return ScopeContext[]
-	 */
-	public function getAllConfiguredScopesForOperation(string $operationClass): array {
-		static $scopesByOperation = [];
-		if (isset($scopesByOperation[$operationClass])) {
-			return $scopesByOperation[$operationClass];
-		}
-
-		$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->execute();
-
-		$scopesByOperation[$operationClass] = [];
-		while ($row = $result->fetch()) {
-			$scope = new ScopeContext($row['type'], $row['value']);
-			$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->execute();
-
-		$this->operations[$scopeContext->getHash()] = [];
-		while ($row = $result->fetch()) {
-			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->execute();
-		$row = $result->fetch();
-		$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->execute();
-
-		return $query->getLastInsertId();
-	}
-
-	/**
-	 * @param string $class
-	 * @param string $name
-	 * @param array[] $checks
-	 * @param string $operation
-	 * @return array The added operation
-	 * @throws \UnexpectedValueException
-	 * @throws DBALException
-	 */
-	public function addOperation(
-		string $class,
-		string $name,
-		array $checks,
-		string $operation,
-		ScopeContext $scope,
-		string $entity,
-		array $events
-	) {
-		$this->validateOperation($class, $name, $checks, $operation, $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 (DBALException $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->where($qb->expr()->eq('s.value', $qb->createParameter('scopeId')));
-		}
-
-		$qb->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
-		$result = $qb->execute();
-
-		$this->operationsByScope[$scopeContext->getHash()] = [];
-		while($opId = $result->fetchColumn(0)) {
-			$this->operationsByScope[$scopeContext->getHash()][] = (int)$opId;
-		}
-		$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 DBALException
-	 */
-	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, $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->execute();
-			$this->connection->commit();
-		} catch (DBALException $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-		unset($this->operations[$scopeContext->getHash()]);
-
-		return $this->getOperation($id);
-	}
-
-	/**
-	 * @param int $id
-	 * @return bool
-	 * @throws \UnexpectedValueException
-	 * @throws DBALException
-	 * @throws \DomainException
-	 */
-	public function deleteOperation($id, ScopeContext $scopeContext) {
-		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)))
-				->execute();
-			if($result) {
-				$qb = $this->connection->getQueryBuilder();
-				$result &= (bool)$qb->delete('flow_operations_scope')
-					->where($qb->expr()->eq('operation_id', $qb->createNamedParameter($id)))
-					->execute();
-			}
-			$this->connection->commit();
-		} catch (DBALException $e) {
-			$this->connection->rollBack();
-			throw $e;
-		}
-
-		if(isset($this->operations[$scopeContext->getHash()])) {
-			unset($this->operations[$scopeContext->getHash()]);
-		}
-
-		return $result;
-	}
-
-	protected function validateEvents(string $entity, array $events, IOperation $operation) {
-		try {
-			/** @var IEntity $instance */
-			$instance = $this->container->query($entity);
-		} catch (QueryException $e) {
-			throw new \UnexpectedValueException($this->l->t('Entity %s does not exist', [$entity]));
-		}
-
-		if(!$instance instanceof IEntity) {
-			throw new \UnexpectedValueException($this->l->t('Entity %s is invalid', [$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 string $class
-	 * @param string $name
-	 * @param array[] $checks
-	 * @param string $operation
-	 * @throws \UnexpectedValueException
-	 */
-	public function validateOperation($class, $name, array $checks, $operation, string $entity, array $events) {
-		try {
-			/** @var IOperation $instance */
-			$instance = $this->container->query($class);
-		} catch (QueryException $e) {
-			throw new \UnexpectedValueException($this->l->t('Operation %s does not exist', [$class]));
-		}
-
-		if (!($instance instanceof IOperation)) {
-			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'));
-			}
-
-			try {
-				/** @var ICheck $instance */
-				$instance = $this->container->query($check['class']);
-			} catch (QueryException $e) {
-				throw new \UnexpectedValueException($this->l->t('Check %s does not exist', [$class]));
-			}
-
-			if (!($instance instanceof ICheck)) {
-				throw new \UnexpectedValueException($this->l->t('Check %s is invalid', [$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[]
-	 */
-	public function getChecks(array $checkIds) {
-		$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->execute();
-
-		while ($row = $result->fetch()) {
-			$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', $missingCheck));
-		}
-
-		return $checks;
-	}
-
-	/**
-	 * @param string $class
-	 * @param string $operator
-	 * @param string $value
-	 * @return int Check unique ID
-	 */
-	protected function addCheck($class, $operator, $value) {
-		$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->execute();
-
-		if ($row = $result->fetch()) {
-			$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->execute();
-
-		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->execute();
-	}
-
-	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));
-		$this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_ENTITY, new GenericEvent($this));
-
-		return array_values(array_merge($this->getBuildInEntities(), $this->registeredEntities));
-	}
-
-	/**
-	 * @return IOperation[]
-	 */
-	public function getOperatorList(): array {
-		$this->dispatcher->dispatchTyped(new RegisterOperationsEvent($this));
-		$this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_OPERATION, new GenericEvent($this));
-
-		return array_merge($this->getBuildInOperators(), $this->registeredOperators);
-	}
-
-	/**
-	 * @return ICheck[]
-	 */
-	public function getCheckList(): array {
-		$this->dispatcher->dispatchTyped(new RegisterChecksEvent($this));
-		$this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_CHECK, new GenericEvent($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->query(File::class),
-			];
-		} catch (QueryException $e) {
-			$this->logger->logException($e);
-			return [];
-		}
-	}
-
-	/**
-	 * @return IOperation[]
-	 */
-	protected function getBuildInOperators(): array {
-		try {
-			return [
-				// None yet
-			];
-		} catch (QueryException $e) {
-			$this->logger->logException($e);
-			return [];
-		}
-	}
-
-	/**
-	 * @return IEntity[]
-	 */
-	protected function getBuildInChecks(): array {
-		try {
-			return [
-				$this->container->query(FileMimeType::class),
-				$this->container->query(FileName::class),
-				$this->container->query(FileSize::class),
-				$this->container->query(FileSystemTags::class),
-				$this->container->query(RequestRemoteAddress::class),
-				$this->container->query(RequestTime::class),
-				$this->container->query(RequestURL::class),
-				$this->container->query(RequestUserAgent::class),
-				$this->container->query(UserGroupMembership::class),
-			];
-		} catch (QueryException $e) {
-			$this->logger->logException($e);
-			return [];
-		}
-	}
+    /** @var string */
+    protected $path;
+
+    /** @var object */
+    protected $entity;
+
+    /** @var array[] */
+    protected $operations = [];
+
+    /** @var array[] */
+    protected $checks = [];
+
+    /** @var IDBConnection */
+    protected $connection;
+
+    /** @var IServerContainer|\OC\Server */
+    protected $container;
+
+    /** @var IL10N */
+    protected $l;
+
+    /** @var LegacyDispatcher */
+    protected $legacyEventDispatcher;
+
+    /** @var IEntity[] */
+    protected $registeredEntities = [];
+
+    /** @var IOperation[] */
+    protected $registeredOperators = [];
+
+    /** @var ICheck[] */
+    protected $registeredChecks = [];
+
+    /** @var ILogger */
+    protected $logger;
+
+    /** @var CappedMemoryCache */
+    protected $operationsByScope = [];
+
+    /** @var IUserSession */
+    protected $session;
+
+    /** @var IEventDispatcher */
+    private $dispatcher;
+
+    public function __construct(
+        IDBConnection $connection,
+        IServerContainer $container,
+        IL10N $l,
+        LegacyDispatcher $eventDispatcher,
+        ILogger $logger,
+        IUserSession $session,
+        IEventDispatcher $dispatcher
+    ) {
+        $this->connection = $connection;
+        $this->container = $container;
+        $this->l = $l;
+        $this->legacyEventDispatcher = $eventDispatcher;
+        $this->logger = $logger;
+        $this->operationsByScope = new CappedMemoryCache(64);
+        $this->session = $session;
+        $this->dispatcher = $dispatcher;
+    }
+
+    public function getRuleMatcher(): IRuleMatcher {
+        return new RuleMatcher(
+            $this->session,
+            $this->container,
+            $this->l,
+            $this,
+            $this->container->query(Logger::class)
+        );
+    }
+
+    public function getAllConfiguredEvents() {
+        $query = $this->connection->getQueryBuilder();
+
+        $query->selectDistinct('class')
+            ->addSelect('entity', 'events')
+            ->from('flow_operations')
+            ->where($query->expr()->neq('events', $query->createNamedParameter('[]'), IQueryBuilder::PARAM_STR));
+
+        $result = $query->execute();
+        $operations = [];
+        while($row = $result->fetch()) {
+            $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();
+
+        return $operations;
+    }
+
+    /**
+     * @param string $operationClass
+     * @return ScopeContext[]
+     */
+    public function getAllConfiguredScopesForOperation(string $operationClass): array {
+        static $scopesByOperation = [];
+        if (isset($scopesByOperation[$operationClass])) {
+            return $scopesByOperation[$operationClass];
+        }
+
+        $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->execute();
+
+        $scopesByOperation[$operationClass] = [];
+        while ($row = $result->fetch()) {
+            $scope = new ScopeContext($row['type'], $row['value']);
+            $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->execute();
+
+        $this->operations[$scopeContext->getHash()] = [];
+        while ($row = $result->fetch()) {
+            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->execute();
+        $row = $result->fetch();
+        $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->execute();
+
+        return $query->getLastInsertId();
+    }
+
+    /**
+     * @param string $class
+     * @param string $name
+     * @param array[] $checks
+     * @param string $operation
+     * @return array The added operation
+     * @throws \UnexpectedValueException
+     * @throws DBALException
+     */
+    public function addOperation(
+        string $class,
+        string $name,
+        array $checks,
+        string $operation,
+        ScopeContext $scope,
+        string $entity,
+        array $events
+    ) {
+        $this->validateOperation($class, $name, $checks, $operation, $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 (DBALException $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->where($qb->expr()->eq('s.value', $qb->createParameter('scopeId')));
+        }
+
+        $qb->setParameters(['scope' => $scopeContext->getScope(), 'scopeId' => $scopeContext->getScopeId()]);
+        $result = $qb->execute();
+
+        $this->operationsByScope[$scopeContext->getHash()] = [];
+        while($opId = $result->fetchColumn(0)) {
+            $this->operationsByScope[$scopeContext->getHash()][] = (int)$opId;
+        }
+        $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 DBALException
+     */
+    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, $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->execute();
+            $this->connection->commit();
+        } catch (DBALException $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+        unset($this->operations[$scopeContext->getHash()]);
+
+        return $this->getOperation($id);
+    }
+
+    /**
+     * @param int $id
+     * @return bool
+     * @throws \UnexpectedValueException
+     * @throws DBALException
+     * @throws \DomainException
+     */
+    public function deleteOperation($id, ScopeContext $scopeContext) {
+        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)))
+                ->execute();
+            if($result) {
+                $qb = $this->connection->getQueryBuilder();
+                $result &= (bool)$qb->delete('flow_operations_scope')
+                    ->where($qb->expr()->eq('operation_id', $qb->createNamedParameter($id)))
+                    ->execute();
+            }
+            $this->connection->commit();
+        } catch (DBALException $e) {
+            $this->connection->rollBack();
+            throw $e;
+        }
+
+        if(isset($this->operations[$scopeContext->getHash()])) {
+            unset($this->operations[$scopeContext->getHash()]);
+        }
+
+        return $result;
+    }
+
+    protected function validateEvents(string $entity, array $events, IOperation $operation) {
+        try {
+            /** @var IEntity $instance */
+            $instance = $this->container->query($entity);
+        } catch (QueryException $e) {
+            throw new \UnexpectedValueException($this->l->t('Entity %s does not exist', [$entity]));
+        }
+
+        if(!$instance instanceof IEntity) {
+            throw new \UnexpectedValueException($this->l->t('Entity %s is invalid', [$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 string $class
+     * @param string $name
+     * @param array[] $checks
+     * @param string $operation
+     * @throws \UnexpectedValueException
+     */
+    public function validateOperation($class, $name, array $checks, $operation, string $entity, array $events) {
+        try {
+            /** @var IOperation $instance */
+            $instance = $this->container->query($class);
+        } catch (QueryException $e) {
+            throw new \UnexpectedValueException($this->l->t('Operation %s does not exist', [$class]));
+        }
+
+        if (!($instance instanceof IOperation)) {
+            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'));
+            }
+
+            try {
+                /** @var ICheck $instance */
+                $instance = $this->container->query($check['class']);
+            } catch (QueryException $e) {
+                throw new \UnexpectedValueException($this->l->t('Check %s does not exist', [$class]));
+            }
+
+            if (!($instance instanceof ICheck)) {
+                throw new \UnexpectedValueException($this->l->t('Check %s is invalid', [$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[]
+     */
+    public function getChecks(array $checkIds) {
+        $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->execute();
+
+        while ($row = $result->fetch()) {
+            $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', $missingCheck));
+        }
+
+        return $checks;
+    }
+
+    /**
+     * @param string $class
+     * @param string $operator
+     * @param string $value
+     * @return int Check unique ID
+     */
+    protected function addCheck($class, $operator, $value) {
+        $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->execute();
+
+        if ($row = $result->fetch()) {
+            $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->execute();
+
+        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->execute();
+    }
+
+    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));
+        $this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_ENTITY, new GenericEvent($this));
+
+        return array_values(array_merge($this->getBuildInEntities(), $this->registeredEntities));
+    }
+
+    /**
+     * @return IOperation[]
+     */
+    public function getOperatorList(): array {
+        $this->dispatcher->dispatchTyped(new RegisterOperationsEvent($this));
+        $this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_OPERATION, new GenericEvent($this));
+
+        return array_merge($this->getBuildInOperators(), $this->registeredOperators);
+    }
+
+    /**
+     * @return ICheck[]
+     */
+    public function getCheckList(): array {
+        $this->dispatcher->dispatchTyped(new RegisterChecksEvent($this));
+        $this->legacyEventDispatcher->dispatch(IManager::EVENT_NAME_REG_CHECK, new GenericEvent($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->query(File::class),
+            ];
+        } catch (QueryException $e) {
+            $this->logger->logException($e);
+            return [];
+        }
+    }
+
+    /**
+     * @return IOperation[]
+     */
+    protected function getBuildInOperators(): array {
+        try {
+            return [
+                // None yet
+            ];
+        } catch (QueryException $e) {
+            $this->logger->logException($e);
+            return [];
+        }
+    }
+
+    /**
+     * @return IEntity[]
+     */
+    protected function getBuildInChecks(): array {
+        try {
+            return [
+                $this->container->query(FileMimeType::class),
+                $this->container->query(FileName::class),
+                $this->container->query(FileSize::class),
+                $this->container->query(FileSystemTags::class),
+                $this->container->query(RequestRemoteAddress::class),
+                $this->container->query(RequestTime::class),
+                $this->container->query(RequestURL::class),
+                $this->container->query(RequestUserAgent::class),
+                $this->container->query(UserGroupMembership::class),
+            ];
+        } catch (QueryException $e) {
+            $this->logger->logException($e);
+            return [];
+        }
+    }
 }

apps/workflowengine/lib/Service/RuleMatcher.php

Indentation +188 added lines, -188 removed lines

@@ -43,192 +43,192 @@
 
 class RuleMatcher implements IRuleMatcher {
 
-	/** @var IUserSession */
-	protected $session;
-	/** @var IManager */
-	protected $manager;
-	/** @var array */
-	protected $contexts;
-	/** @var IServerContainer */
-	protected $container;
-	/** @var array */
-	protected $fileInfo = [];
-	/** @var IL10N */
-	protected $l;
-	/** @var IOperation */
-	protected $operation;
-	/** @var IEntity */
-	protected $entity;
-	/** @var Logger */
-	protected $logger;
-
-	public function __construct(
-		IUserSession $session,
-		IServerContainer $container,
-		IL10N $l,
-		Manager $manager,
-		Logger $logger
-	) {
-		$this->session = $session;
-		$this->manager = $manager;
-		$this->container = $container;
-		$this->l = $l;
-		$this->logger = $logger;
-	}
-
-	public function setFileInfo(IStorage $storage, string $path, bool $isDir = false): void {
-		$this->fileInfo['storage'] = $storage;
-		$this->fileInfo['path'] = $path;
-		$this->fileInfo['isDir'] = $isDir;
-	}
-
-	public function setEntitySubject(IEntity $entity, $subject): void {
-		$this->contexts[get_class($entity)] = [$entity, $subject];
-	}
-
-	public function setOperation(IOperation $operation): void {
-		if($this->operation !== null) {
-			throw new RuntimeException('This method must not be called more than once');
-		}
-		$this->operation = $operation;
-	}
-
-	public function setEntity(IEntity $entity): void {
-		if($this->entity !== null) {
-			throw new RuntimeException('This method must not be called more than once');
-		}
-		$this->entity = $entity;
-	}
-
-	public function getEntity(): IEntity {
-		if($this->entity === null) {
-			throw new \LogicException('Entity was not set yet');
-		}
-		return $this->entity;
-	}
-
-	public function getFlows(bool $returnFirstMatchingOperationOnly = true): array {
-		if(!$this->operation) {
-			throw new RuntimeException('Operation is not set');
-		}
-		return $this->getMatchingOperations(get_class($this->operation), $returnFirstMatchingOperationOnly);
-	}
-
-	public function getMatchingOperations(string $class, bool $returnFirstMatchingOperationOnly = true): array {
-		$scopes[] = new ScopeContext(IManager::SCOPE_ADMIN);
-		$user = $this->session->getUser();
-		if($user !== null) {
-			$scopes[] = new ScopeContext(IManager::SCOPE_USER, $user->getUID());
-		}
-
-		$ctx = new LogContext();
-		$ctx
-			->setScopes($scopes)
-			->setEntity($this->entity)
-			->setOperation($this->operation);
-		$this->logger->logFlowRequests($ctx);
-
-		$operations = [];
-		foreach ($scopes as $scope) {
-			$operations = array_merge($operations, $this->manager->getOperations($class, $scope));
-		}
-
-		if($this->entity instanceof IEntity) {
-			/** @var ScopeContext[] $additionalScopes */
-			$additionalScopes = $this->manager->getAllConfiguredScopesForOperation($class);
-			foreach ($additionalScopes as $hash => $scopeCandidate) {
-				if ($scopeCandidate->getScope() !== IManager::SCOPE_USER || in_array($scopeCandidate, $scopes)) {
-					continue;
-				}
-				if ($this->entity->isLegitimatedForUserId($scopeCandidate->getScopeId())) {
-					$ctx = new LogContext();
-					$ctx
-						->setScopes([$scopeCandidate])
-						->setEntity($this->entity)
-						->setOperation($this->operation);
-					$this->logger->logScopeExpansion($ctx);
-					$operations = array_merge($operations, $this->manager->getOperations($class, $scopeCandidate));
-				}
-			}
-		}
-
-		$matches = [];
-		foreach ($operations as $operation) {
-			$checkIds = json_decode($operation['checks'], true);
-			$checks = $this->manager->getChecks($checkIds);
-
-			foreach ($checks as $check) {
-				if (!$this->check($check)) {
-					// Check did not match, continue with the next operation
-					continue 2;
-				}
-			}
-
-			$ctx = new LogContext();
-			$ctx
-				->setEntity($this->entity)
-				->setOperation($this->operation)
-				->setConfiguration($operation);
-			$this->logger->logPassedCheck($ctx);
-
-			if ($returnFirstMatchingOperationOnly) {
-				$ctx = new LogContext();
-				$ctx
-					->setEntity($this->entity)
-					->setOperation($this->operation)
-					->setConfiguration($operation);
-				$this->logger->logRunSingle($ctx);
-				return $operation;
-			}
-			$matches[] = $operation;
-		}
-
-		$ctx = new LogContext();
-		$ctx
-			->setEntity($this->entity)
-			->setOperation($this->operation);
-		if(!empty($matches)) {
-			$ctx->setConfiguration($matches);
-			$this->logger->logRunAll($ctx);
-		} else {
-			$this->logger->logRunNone($ctx);
-		}
-
-		return $matches;
-	}
-
-	/**
-	 * @param array $check
-	 * @return bool
-	 */
-	public function check(array $check) {
-		try {
-			$checkInstance = $this->container->query($check['class']);
-		} catch (QueryException $e) {
-			// Check does not exist, assume it matches.
-			return true;
-		}
-
-		if ($checkInstance instanceof IFileCheck) {
-			if (empty($this->fileInfo)) {
-				throw new RuntimeException('Must set file info before running the check');
-			}
-			$checkInstance->setFileInfo($this->fileInfo['storage'], $this->fileInfo['path'], $this->fileInfo['isDir']);
-		} elseif ($checkInstance instanceof IEntityCheck) {
-			foreach($this->contexts as $entityInfo) {
-				list($entity, $subject) = $entityInfo;
-				$checkInstance->setEntitySubject($entity, $subject);
-			}
-		} else if(!$checkInstance instanceof ICheck) {
-			// Check is invalid
-			throw new \UnexpectedValueException($this->l->t('Check %s is invalid or does not exist', $check['class']));
-		}
-		return $checkInstance->executeCheck($check['operator'], $check['value']);
-	}
-
-	protected function logCandidate() {
-		$logContext = new LogContext();
-		$logContext
-			->setOperation();
-	}
+    /** @var IUserSession */
+    protected $session;
+    /** @var IManager */
+    protected $manager;
+    /** @var array */
+    protected $contexts;
+    /** @var IServerContainer */
+    protected $container;
+    /** @var array */
+    protected $fileInfo = [];
+    /** @var IL10N */
+    protected $l;
+    /** @var IOperation */
+    protected $operation;
+    /** @var IEntity */
+    protected $entity;
+    /** @var Logger */
+    protected $logger;
+
+    public function __construct(
+        IUserSession $session,
+        IServerContainer $container,
+        IL10N $l,
+        Manager $manager,
+        Logger $logger
+    ) {
+        $this->session = $session;
+        $this->manager = $manager;
+        $this->container = $container;
+        $this->l = $l;
+        $this->logger = $logger;
+    }
+
+    public function setFileInfo(IStorage $storage, string $path, bool $isDir = false): void {
+        $this->fileInfo['storage'] = $storage;
+        $this->fileInfo['path'] = $path;
+        $this->fileInfo['isDir'] = $isDir;
+    }
+
+    public function setEntitySubject(IEntity $entity, $subject): void {
+        $this->contexts[get_class($entity)] = [$entity, $subject];
+    }
+
+    public function setOperation(IOperation $operation): void {
+        if($this->operation !== null) {
+            throw new RuntimeException('This method must not be called more than once');
+        }
+        $this->operation = $operation;
+    }
+
+    public function setEntity(IEntity $entity): void {
+        if($this->entity !== null) {
+            throw new RuntimeException('This method must not be called more than once');
+        }
+        $this->entity = $entity;
+    }
+
+    public function getEntity(): IEntity {
+        if($this->entity === null) {
+            throw new \LogicException('Entity was not set yet');
+        }
+        return $this->entity;
+    }
+
+    public function getFlows(bool $returnFirstMatchingOperationOnly = true): array {
+        if(!$this->operation) {
+            throw new RuntimeException('Operation is not set');
+        }
+        return $this->getMatchingOperations(get_class($this->operation), $returnFirstMatchingOperationOnly);
+    }
+
+    public function getMatchingOperations(string $class, bool $returnFirstMatchingOperationOnly = true): array {
+        $scopes[] = new ScopeContext(IManager::SCOPE_ADMIN);
+        $user = $this->session->getUser();
+        if($user !== null) {
+            $scopes[] = new ScopeContext(IManager::SCOPE_USER, $user->getUID());
+        }
+
+        $ctx = new LogContext();
+        $ctx
+            ->setScopes($scopes)
+            ->setEntity($this->entity)
+            ->setOperation($this->operation);
+        $this->logger->logFlowRequests($ctx);
+
+        $operations = [];
+        foreach ($scopes as $scope) {
+            $operations = array_merge($operations, $this->manager->getOperations($class, $scope));
+        }
+
+        if($this->entity instanceof IEntity) {
+            /** @var ScopeContext[] $additionalScopes */
+            $additionalScopes = $this->manager->getAllConfiguredScopesForOperation($class);
+            foreach ($additionalScopes as $hash => $scopeCandidate) {
+                if ($scopeCandidate->getScope() !== IManager::SCOPE_USER || in_array($scopeCandidate, $scopes)) {
+                    continue;
+                }
+                if ($this->entity->isLegitimatedForUserId($scopeCandidate->getScopeId())) {
+                    $ctx = new LogContext();
+                    $ctx
+                        ->setScopes([$scopeCandidate])
+                        ->setEntity($this->entity)
+                        ->setOperation($this->operation);
+                    $this->logger->logScopeExpansion($ctx);
+                    $operations = array_merge($operations, $this->manager->getOperations($class, $scopeCandidate));
+                }
+            }
+        }
+
+        $matches = [];
+        foreach ($operations as $operation) {
+            $checkIds = json_decode($operation['checks'], true);
+            $checks = $this->manager->getChecks($checkIds);
+
+            foreach ($checks as $check) {
+                if (!$this->check($check)) {
+                    // Check did not match, continue with the next operation
+                    continue 2;
+                }
+            }
+
+            $ctx = new LogContext();
+            $ctx
+                ->setEntity($this->entity)
+                ->setOperation($this->operation)
+                ->setConfiguration($operation);
+            $this->logger->logPassedCheck($ctx);
+
+            if ($returnFirstMatchingOperationOnly) {
+                $ctx = new LogContext();
+                $ctx
+                    ->setEntity($this->entity)
+                    ->setOperation($this->operation)
+                    ->setConfiguration($operation);
+                $this->logger->logRunSingle($ctx);
+                return $operation;
+            }
+            $matches[] = $operation;
+        }
+
+        $ctx = new LogContext();
+        $ctx
+            ->setEntity($this->entity)
+            ->setOperation($this->operation);
+        if(!empty($matches)) {
+            $ctx->setConfiguration($matches);
+            $this->logger->logRunAll($ctx);
+        } else {
+            $this->logger->logRunNone($ctx);
+        }
+
+        return $matches;
+    }
+
+    /**
+     * @param array $check
+     * @return bool
+     */
+    public function check(array $check) {
+        try {
+            $checkInstance = $this->container->query($check['class']);
+        } catch (QueryException $e) {
+            // Check does not exist, assume it matches.
+            return true;
+        }
+
+        if ($checkInstance instanceof IFileCheck) {
+            if (empty($this->fileInfo)) {
+                throw new RuntimeException('Must set file info before running the check');
+            }
+            $checkInstance->setFileInfo($this->fileInfo['storage'], $this->fileInfo['path'], $this->fileInfo['isDir']);
+        } elseif ($checkInstance instanceof IEntityCheck) {
+            foreach($this->contexts as $entityInfo) {
+                list($entity, $subject) = $entityInfo;
+                $checkInstance->setEntitySubject($entity, $subject);
+            }
+        } else if(!$checkInstance instanceof ICheck) {
+            // Check is invalid
+            throw new \UnexpectedValueException($this->l->t('Check %s is invalid or does not exist', $check['class']));
+        }
+        return $checkInstance->executeCheck($check['operator'], $check['value']);
+    }
+
+    protected function logCandidate() {
+        $logContext = new LogContext();
+        $logContext
+            ->setOperation();
+    }
 }

Spacing +9 added lines, -9 removed lines

@@ -87,28 +87,28 @@ 
 	}
 
 	public function setOperation(IOperation $operation): void {
-		if($this->operation !== null) {
+		if ($this->operation !== null) {
 			throw new RuntimeException('This method must not be called more than once');
 		}
 		$this->operation = $operation;
 	}
 
 	public function setEntity(IEntity $entity): void {
-		if($this->entity !== null) {
+		if ($this->entity !== null) {
 			throw new RuntimeException('This method must not be called more than once');
 		}
 		$this->entity = $entity;
 	}
 
 	public function getEntity(): IEntity {
-		if($this->entity === null) {
+		if ($this->entity === null) {
 			throw new \LogicException('Entity was not set yet');
 		}
 		return $this->entity;
 	}
 
 	public function getFlows(bool $returnFirstMatchingOperationOnly = true): array {
-		if(!$this->operation) {
+		if (!$this->operation) {
 			throw new RuntimeException('Operation is not set');
 		}
 		return $this->getMatchingOperations(get_class($this->operation), $returnFirstMatchingOperationOnly);
@@ -117,7 +117,7 @@ 
 	public function getMatchingOperations(string $class, bool $returnFirstMatchingOperationOnly = true): array {
 		$scopes[] = new ScopeContext(IManager::SCOPE_ADMIN);
 		$user = $this->session->getUser();
-		if($user !== null) {
+		if ($user !== null) {
 			$scopes[] = new ScopeContext(IManager::SCOPE_USER, $user->getUID());
 		}
 
@@ -133,7 +133,7 @@ 
 			$operations = array_merge($operations, $this->manager->getOperations($class, $scope));
 		}
 
-		if($this->entity instanceof IEntity) {
+		if ($this->entity instanceof IEntity) {
 			/** @var ScopeContext[] $additionalScopes */
 			$additionalScopes = $this->manager->getAllConfiguredScopesForOperation($class);
 			foreach ($additionalScopes as $hash => $scopeCandidate) {
@@ -187,7 +187,7 @@ 
 		$ctx
 			->setEntity($this->entity)
 			->setOperation($this->operation);
-		if(!empty($matches)) {
+		if (!empty($matches)) {
 			$ctx->setConfiguration($matches);
 			$this->logger->logRunAll($ctx);
 		} else {
@@ -215,11 +215,11 @@ 
 			}
 			$checkInstance->setFileInfo($this->fileInfo['storage'], $this->fileInfo['path'], $this->fileInfo['isDir']);
 		} elseif ($checkInstance instanceof IEntityCheck) {
-			foreach($this->contexts as $entityInfo) {
+			foreach ($this->contexts as $entityInfo) {
 				list($entity, $subject) = $entityInfo;
 				$checkInstance->setEntitySubject($entity, $subject);
 			}
-		} else if(!$checkInstance instanceof ICheck) {
+		} else if (!$checkInstance instanceof ICheck) {
 			// Check is invalid
 			throw new \UnexpectedValueException($this->l->t('Check %s is invalid or does not exist', $check['class']));
 		}