Jabe\Impl\ProcessDefinitionQueryImpl

Complexity

Total Complexity

92

Size/Duplication

Total Lines	574
Duplicated Lines	0 %

Importance

Changes

0

81 Methods

Rating	Name	Duplication	Size	Complexity
A	orderByDeploymentTime()	0	4	1
A	processDefinitionCategoryLike()	0	5	1
A	deploymentId()	0	5	1
A	getIncidentMessageLike()	0	3	1
A	orderByProcessDefinitionId()	0	3	1
A	suspended()	0	4	1
A	startableByUser()	0	5	1
A	executeList()	0	16	2
A	addProcessDefinitionCreatePermissionCheck()	0	3	1
A	getProcessDefinitionCreatePermissionChecks()	0	3	1
A	processDefinitionResourceNameLike()	0	5	1
A	processDefinitionKey()	0	5	1
A	active()	0	4	1
A	incidentMessageLike()	0	5	1
A	deployedAfter()	0	6	1
A	withoutVersionTag()	0	5	1
A	getIncidentType()	0	3	1
A	getCandidateGroups()	0	18	3
A	versionTag()	0	7	1
A	getKeyLike()	0	3	1
A	processDefinitionVersion()	0	6	1
A	processDefinitionId()	0	4	1
A	startablePermissionCheck()	0	4	1
A	getCategoryLike()	0	3	1
A	processDefinitionResourceName()	0	5	1
A	getNameLike()	0	3	1
A	getVersionTag()	0	3	1
A	isNotStartableInTasklist()	0	3	1
A	orderByDeploymentId()	0	3	1
A	checkQueryOk()	0	6	5
A	orderByTenantId()	0	3	1
A	getResourceName()	0	3	1
A	getName()	0	3	1
A	orderByVersionTag()	0	3	1
A	getSuspensionState()	0	3	1
A	processDefinitionKeysIn()	0	5	1
A	processDefinitionName()	0	5	1
A	withoutTenantId()	0	5	1
A	incidentId()	0	5	1
A	__construct()	0	3	1
A	versionTagLike()	0	5	1
A	processDefinitionCategory()	0	5	1
A	processDefinitionStarter()	0	4	1
A	processDefinitionIdIn()	0	4	1
A	processDefinitionKeyLike()	0	5	1
A	hasExcludingConditions()	0	3	2
A	messageEventSubscription()	0	3	1
A	getDeployedAt()	0	3	1
A	isShouldJoinDeploymentTable()	0	3	1
A	isStartableInTasklist()	0	3	1
A	processDefinitionNameLike()	0	5	1
A	orderByProcessDefinitionCategory()	0	3	1
A	getVersion()	0	3	1
A	getIds()	0	3	1
A	getDeploymentId()	0	3	1
A	addProcessDefinitionToCacheAndRetrieveDocumentation()	0	17	4
A	tenantIdIn()	0	6	1
A	getId()	0	3	1
A	incidentMessage()	0	5	1
A	setSuspensionState()	0	3	1
A	eventSubscription()	0	7	1
A	orderByProcessDefinitionKey()	0	3	1
A	executeCount()	0	8	1
A	messageEventSubscriptionName()	0	3	1
A	isStartablePermissionCheck()	0	3	1
A	notStartableInTasklist()	0	4	1
A	getIncidentMessage()	0	3	1
A	startableInTasklist()	0	4	1
A	latestVersion()	0	4	1
A	isLatest()	0	3	1
A	orderByProcessDefinitionVersion()	0	3	1
A	deployedAt()	0	6	1
A	orderByProcessDefinitionName()	0	3	1
A	getResourceNameLike()	0	3	1
A	incidentType()	0	5	1
A	includeProcessDefinitionsWithoutTenantId()	0	4	1
A	setProcessDefinitionCreatePermissionChecks()	0	3	1
A	getIncidentId()	0	3	1
A	getCategory()	0	3	1
A	getDeployedAfter()	0	3	1
A	getKey()	0	3	1

<?php

namespace Jabe\Impl;

use Jabe\ProcessEngineException;
use Jabe\Identity\GroupInterface;
use Jabe\Impl\Bpmn\Parser\BpmnParse;
use Jabe\Impl\Context\Context;
use Jabe\Impl\Db\{
    CompositePermissionCheck,
    PermissionCheck
};
use Jabe\Impl\Event\EventType;
use Jabe\Impl\Interceptor\{
    CommandContext,
    CommandExecutorInterface
};
use Jabe\Impl\Persistence\Entity\{
    ProcessDefinitionEntity,
    SuspensionState
};
use Jabe\Impl\Util\{
    CompareUtil,
    EnsureUtil
};
use Jabe\Repository\{
    ProcessDefinitionInterface,
    ProcessDefinitionQueryInterface
};
use Bpmn\Instance\DocumentationInterface;

class ProcessDefinitionQueryImpl extends AbstractQuery implements ProcessDefinitionQueryInterface
{
    protected $id;
    protected $ids = [];
    protected $category;
    protected $categoryLike;
    protected $name;
    protected $nameLike;
    protected $deploymentId;
    protected $deployedAfter;
    protected $deployedAt;
    protected $key;
    protected $keys = [];
    protected $keyLike;
    protected $resourceName;
    protected $resourceNameLike;
    protected $version;
    protected $latest = false;
    protected $suspensionState;
    protected $authorizationUserId;
    protected $cachedCandidateGroups = [];
    protected $procDefId;
    protected $incidentType;
    protected $incidentId;
    protected $incidentMessage;
    protected $incidentMessageLike;

    protected $eventSubscriptionName;
    protected $eventSubscriptionType;

    protected $isTenantIdSet = false;
    protected $tenantIds = [];
    protected $includeDefinitionsWithoutTenantId = false;

    protected $isVersionTagSet = false;
    protected $versionTag;
    protected $versionTagLike;

    protected $isStartableInTasklist = false;
    protected $isNotStartableInTasklist = false;
    protected $startablePermissionCheck = false;
    // for internal use
    protected $processDefinitionCreatePermissionChecks = [];
    private $shouldJoinDeploymentTable = false;

    public function __construct(CommandExecutorInterface $commandExecutor = null)
    {
        parent::__construct($commandExecutor);
    }

    public function processDefinitionId(string $processDefinitionId): ProcessDefinitionQueryImpl
    {
        $this->id = $processDefinitionId;
        return $this;
    }

    public function processDefinitionIdIn(array $ids): ProcessDefinitionQueryImpl
    {
        $this->ids = $ids;
        return $this;
    }

    public function processDefinitionCategory(string $category): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("category", "category", $category);
        $this->category = $category;
        return $this;
    }

    public function processDefinitionCategoryLike(string $categoryLike): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("categoryLike", "categoryLike", $categoryLike);
        $this->categoryLike = $categoryLike;
        return $this;
    }

    public function processDefinitionName(string $name): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("name", "name", $name);
        $this->name = $name;
        return $this;
    }

    public function processDefinitionNameLike(string $nameLike): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("nameLike", "nameLike", $nameLike);
        $this->nameLike = $nameLike;
        return $this;
    }

    public function deploymentId(string $deploymentId): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("deploymentId", "deploymentId", $deploymentId);
        $this->deploymentId = $deploymentId;
        return $this;
    }

    public function deployedAfter(string $deployedAfter): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("deployedAfter", "deployedAfter", $deployedAfter);
        $this->shouldJoinDeploymentTable = true;
        $this->deployedAfter = $deployedAfter;
        return $this;
    }

    public function deployedAt(string $deployedAt): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("deployedAt", "deployedAt", $deployedAt);
        $this->shouldJoinDeploymentTable = true;
        $this->deployedAt = $deployedAt;
        return $this;
    }

    public function processDefinitionKey(string $key): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("key", "key", $key);
        $this->key = $key;
        return $this;
    }

    public function processDefinitionKeysIn(array $keys): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("keys", "keys", $keys);
        $this->keys = $keys;
        return $this;
    }

    public function processDefinitionKeyLike(string $keyLike): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("keyLike", "keyLike", $keyLike);
        $this->keyLike = $keyLike;
        return $this;
    }

    public function processDefinitionResourceName(string $resourceName): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("resourceName", "resourceName", $resourceName);
        $this->resourceName = $resourceName;
        return $this;
    }

    public function processDefinitionResourceNameLike(string $resourceNameLike): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("resourceNameLike", "resourceNameLike", $resourceNameLike);
        $this->resourceNameLike = $resourceNameLike;
        return $this;
    }

    public function processDefinitionVersion(int $version): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("version", "version", $version);
        EnsureUtil::ensurePositive("The process definition version must be positive", "version", intval($version));
        $this->version = $version;
        return $this;
    }

    public function latestVersion(): ProcessDefinitionQueryImpl
    {
        $this->latest = true;
        return $this;
    }

    public function active(): ProcessDefinitionQueryInterface
    {
        $this->suspensionState = SuspensionState::active();
        return $this;
    }

    public function suspended(): ProcessDefinitionQueryInterface
    {
        $this->suspensionState = SuspensionState::suspended();
        return $this;
    }

    public function messageEventSubscription(string $messageName): ProcessDefinitionQueryInterface
    {
        return $this->eventSubscription(EventType::message(), $messageName);
    }

    public function messageEventSubscriptionName(string $messageName): ProcessDefinitionQueryInterface
    {
        return $this->eventSubscription(EventType::message(), $messageName);
    }

    public function processDefinitionStarter(string $procDefId): ProcessDefinitionQueryInterface
    {
        $this->procDefId = $procDefId;
        return $this;
    }

    public function eventSubscription(EventType $eventType, string $eventName): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("event type", "eventType", $eventType);
        EnsureUtil::ensureNotNull("event name", "eventName", $eventName);
        $this->eventSubscriptionType = $eventType->name();
        $this->eventSubscriptionName = $eventName;
        return $this;
    }

    public function incidentType(string $incidentType): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("incident type", "incidentType", $incidentType);
        $this->incidentType = $incidentType;
        return $this;
    }

    public function incidentId(string $incidentId): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("incident id", "incidentId", $incidentId);
        $this->incidentId = $incidentId;
        return $this;
    }

    public function incidentMessage(string $incidentMessage): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("incident message", "incidentMessage", $incidentMessage);
        $this->incidentMessage = $incidentMessage;
        return $this;
    }

    public function incidentMessageLike(string $incidentMessageLike): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("incident messageLike", "incidentMessageLike", $incidentMessageLike);
        $this->incidentMessageLike = $incidentMessageLike;
        return $this;
    }

    protected function hasExcludingConditions(): bool
    {
        return parent::hasExcludingConditions() || CompareUtil::elementIsNotContainedInArray($this->id, $this->ids);

$this->ids of type array is incompatible with the type Jabe\Impl\Util\to expected by parameter $values of Jabe\Impl\Util\CompareUtil::elementIsNotContainedInArray().

    }

    public function tenantIdIn(array $tenantIds): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("tenantIds", "tenantIds", $tenantIds);
        $this->tenantIds = $tenantIds;
        $this->isTenantIdSet = true;
        return $this;
    }

    public function withoutTenantId(): ProcessDefinitionQueryInterface
    {
        $this->isTenantIdSet = true;
        $this->tenantIds = null;
        return $this;
    }

    public function includeProcessDefinitionsWithoutTenantId(): ProcessDefinitionQueryInterface
    {
        $this->includeDefinitionsWithoutTenantId  = true;
        return $this;
    }

    public function versionTag(string $versionTag): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("versionTag", "versionTag", $versionTag);
        $this->versionTag = $versionTag;
        $this->isVersionTagSet = true;

        return $this;
    }

    public function versionTagLike(string $versionTagLike): ProcessDefinitionQueryInterface
    {
        EnsureUtil::ensureNotNull("versionTagLike", "versionTagLike", $versionTagLike);
        $this->versionTagLike = $versionTagLike;
        return $this;
    }

    public function withoutVersionTag(): ProcessDefinitionQueryInterface
    {
        $this->isVersionTagSet = true;
        $this->versionTag = null;
        return $this;
    }

    public function startableInTasklist(): ProcessDefinitionQueryInterface
    {
        $this->isStartableInTasklist = true;
        return $this;
    }

    public function notStartableInTasklist(): ProcessDefinitionQueryInterface
    {
        $this->isNotStartableInTasklist = true;
        return $this;
    }

    public function startablePermissionCheck(): ProcessDefinitionQueryInterface
    {
        $this->startablePermissionCheck = true;
        return $this;
    }

    //sorting ////////////////////////////////////////////

    public function orderByDeploymentId(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::deploymentId());
    }

    public function orderByDeploymentTime(): ProcessDefinitionQueryInterface
    {
        $this->shouldJoinDeploymentTable = true;
        return $this->orderBy(new QueryOrderingProperty(QueryOrderingProperty::relationDeployment(), ProcessDefinitionQueryProperty::deployTime()));

The method relationDeployment() does not exist on Jabe\Impl\QueryOrderingProperty.

    }

    public function orderByProcessDefinitionKey(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::processDefinitionKey());
    }

    public function orderByProcessDefinitionCategory(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::processDefinitionCategory());
    }

    public function orderByProcessDefinitionId(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::processDefinitionId());
    }

    public function orderByProcessDefinitionVersion(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::processDefinitionVersion());
    }

    public function orderByProcessDefinitionName(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::processDefinitionName());
    }

    public function orderByTenantId(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::tenantId());
    }

    public function orderByVersionTag(): ProcessDefinitionQueryInterface
    {
        return $this->orderBy(ProcessDefinitionQueryProperty::versionTag());
    }

    //results ////////////////////////////////////////////

    public function executeCount(CommandContext $commandContext): int
    {
        $this->checkQueryOk();
        // fetch candidate groups
        $this->getCandidateGroups();
        return $commandContext
        ->getProcessDefinitionManager()
        ->findProcessDefinitionCountByQueryCriteria($this);
    }

    public function executeList(CommandContext $commandContext, Page $page): array
    {
        $this->checkQueryOk();
        // fetch candidate groups
        $this->getCandidateGroups();
        $list = $commandContext
        ->getProcessDefinitionManager()
        ->findProcessDefinitionsByQueryCriteria($this, $page);

        $shouldQueryAddBpmnModelInstancesToCache =

The assignment to $shouldQueryAddBpmnModelInstancesToCache is dead and can be removed.

            $commandContext->getProcessEngineConfiguration()->getEnableFetchProcessDefinitionDescription();

The method getEnableFetchProcessDefinitionDescription() does not exist on Jabe\Impl\Cfg\ProcessEngineConfigurationImpl.

        if ($this->shouldQueryAddBpmnModelInstancesToCache) {

The property shouldQueryAddBpmnModelInstancesToCache does not exist on Jabe\Impl\ProcessDefinitionQueryImpl. Did you maybe forget to declare it?

            $this->addProcessDefinitionToCacheAndRetrieveDocumentation($list);
        }

        return $list;
    }

    protected function addProcessDefinitionToCacheAndRetrieveDocumentation(array $list): void

The parameter $list is not used and could be removed.

    {
        foreach ($this->list as $processDefinition) {

The property list does not exist on Jabe\Impl\ProcessDefinitionQueryImpl. Did you maybe forget to declare it?

            $bpmnModelInstance = Context::getProcessEngineConfiguration()
                ->getDeploymentCache()

The method getDeploymentCache() does not exist on Jabe\Impl\Cfg\ProcessEngineConfigurationImpl.

                ->findBpmnModelInstanceForProcessDefinition($processDefinition);

            $processElement = $bpmnModelInstance->getModelElementById($processDefinition->getKey());
            if ($processElement !== null) {
                $documentations = $processElement->getChildElementsByType(DocumentationInterface::class);
                $docStrings = [];
                foreach ($documentations as $documentation) {
                    $docStrings[] = $documentation->getTextContent();
                }

                $processDefinitionEntity = $processDefinition;
                $processDefinitionEntity->setProperty(BpmnParse::PROPERTYNAME_DOCUMENTATION, BpmnParse::parseDocumentation($docStrings));
            }
        }
    }

    public function checkQueryOk(): void
    {
        parent::checkQueryOk();

        if ($this->latest && ( ($this->id !== null) || ($this->version !== null) || ($this->deploymentId !== null))) {
            throw new ProcessEngineException("Calling latest() can only be used in combination with key(String) and keyLike(String) or name(String) and nameLike(String)");
        }
    }

    //getters ////////////////////////////////////////////

    public function getDeploymentId(): string
    {
        return $this->deploymentId;
    }

    public function getDeployedAfter(): string
    {
        return $this->deployedAfter;
    }

    public function getDeployedAt(): string
    {
        return $this->deployedAt;
    }

    public function getId(): string
    {
        return $this->id;
    }

    public function getIds(): array
    {
        return $this->ids;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getNameLike(): string
    {
        return $this->nameLike;
    }

    public function getKey(): string
    {
        return $this->key;
    }

    public function getKeyLike(): string
    {
        return $this->keyLike;
    }

    public function getVersion(): int
    {
        return $this->version;
    }

    public function isLatest(): bool
    {
        return $this->latest;
    }

    public function getCategory(): string
    {
        return $this->category;
    }

    public function getCategoryLike(): string
    {
        return $this->categoryLike;
    }

    public function getResourceName(): string
    {
        return $this->resourceName;
    }

    public function getResourceNameLike(): string
    {
        return $this->resourceNameLike;
    }

    public function getSuspensionState(): SuspensionState
    {
        return $this->suspensionState;
    }

    public function setSuspensionState(SuspensionState $suspensionState): void
    {
        $this->suspensionState = $suspensionState;
    }

    public function getIncidentId(): string
    {
        return $this->incidentId;
    }

    public function getIncidentType(): string
    {
        return $this->incidentType;
    }

    public function getIncidentMessage(): string
    {
        return $this->incidentMessage;
    }

    public function getIncidentMessageLike(): string
    {
        return $this->incidentMessageLike;
    }

    public function getVersionTag(): string
    {
        return $this->versionTag;
    }

    public function isStartableInTasklist(): bool
    {
        return $this->isStartableInTasklist;
    }

    public function isNotStartableInTasklist(): bool
    {
        return $this->isNotStartableInTasklist;
    }

    public function isStartablePermissionCheck(): bool
    {
        return $this->startablePermissionCheck;
    }

    public function setProcessDefinitionCreatePermissionChecks(array $processDefinitionCreatePermissionChecks): void
    {
        $this->processDefinitionCreatePermissionChecks = $processDefinitionCreatePermissionChecks;
    }

    public function getProcessDefinitionCreatePermissionChecks(): array
    {
        return $this->processDefinitionCreatePermissionChecks;
    }

    public function isShouldJoinDeploymentTable(): bool
    {
        return $this->shouldJoinDeploymentTable;
    }

    public function addProcessDefinitionCreatePermissionCheck(CompositePermissionCheck $processDefinitionCreatePermissionCheck): void
    {
        $this->processDefinitionCreatePermissionChecks = array_merge($this->processDefinitionCreatePermissionChecks, $processDefinitionCreatePermissionCheck->getAllPermissionChecks());
    }

    public function getCandidateGroups(): array
    {
        if (!empty($this->cachedCandidateGroups)) {
            return $this->cachedCandidateGroups;
        }

        if ($this->authorizationUserId !== null) {
            $groups = Context::getCommandContext()
                ->getReadOnlyIdentityProvider()
                ->createGroupQuery()
                ->groupMember($this->authorizationUserId)
                ->list();
            $this->cachedCandidateGroups = array_map(function ($group) {
                return $group->getId();
            }, $groups);
        }

        return $this->cachedCandidateGroups;
    }

    public function startableByUser(string $userId): ProcessDefinitionQueryImpl
    {
        EnsureUtil::ensureNotNull("userId", "userId", $userId);
        $this->authorizationUserId = $userId;
        return $this;
    }
}