ExecutionQueryImpl::orderByProcessDefinitionKey() - Code Metrics - Inspection of "feat: port filter implementations" - bingo-soft/jabe - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — main ( 5af89f...c76fcf )

by Bingo
created 2022-05-20 13:04 UTC
ExecutionQueryImpl::orderByProcessDefinitionKey() A

↳ Parent: ExecutionQueryImpl
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	2
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
nc	1
nop	0
<?php

namespace Jabe\Engine\Impl;

use Jabe\Engine\Impl\Event\EventType;
use Jabe\Engine\Impl\Interceptor\{
    CommandContext,
    CommandExecutorInterface
};
use Jabe\Engine\Impl\Persistence\Entity\SuspensionState;
use Jabe\Engine\Impl\Util\EnsureUtil;
filter:
    dependency_paths: ["lib/*"]
use Jabe\Engine\Runtime\ExecutionQueryInterface;

class ExecutionQueryImpl extends AbstractVariableQueryImpl implements ExecutionQueryInterface
{
    protected $processDefinitionId;
    protected $processDefinitionKey;
    protected $businessKey;
    protected $activityId;
    protected $executionId;
    protected $processInstanceId;
    protected $eventSubscriptions;
    protected $suspensionState;
    protected $incidentType;
    protected $incidentId;
    protected $incidentMessage;
    protected $incidentMessageLike;

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

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

    public function processDefinitionId(string $processDefinitionId): ExecutionQueryImpl
    {
        EnsureUtil::ensureNotNull("Process definition id", "processDefinitionId", $processDefinitionId);
        $this->processDefinitionId = $processDefinitionId;
        return $this;
    }

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

    public function processInstanceId(string $processInstanceId): ExecutionQueryImpl
    {
        EnsureUtil::ensureNotNull("Process instance id", "processInstanceId", $processInstanceId);
        $this->processInstanceId = $processInstanceId;
        return $this;
    }

    public function processInstanceBusinessKey(string $businessKey): ExecutionQueryInterface
    {
        EnsureUtil::ensureNotNull("Business key", "businessKey", $businessKey);
        $this->businessKey = $businessKey;
        return $this;
    }

    public function executionId(string $executionId): ExecutionQueryImpl
    {
        EnsureUtil::ensureNotNull("Execution id", "executionId", $executionId);
        $this->executionId = $executionId;
        return $this;
    }

    public function activityId(string $activityId): ExecutionQueryImpl
    {
        $this->activityId = $activityId;
        return $this;
    }

    public function signalEventSubscription(string $signalName): ExecutionQueryInterface
    {
        return $this->eventSubscription(EventType::signal(), $signalName);
    }

    public function signalEventSubscriptionName(string $signalName): ExecutionQueryInterface
    {
        return $this->eventSubscription(EventType::signal(), $signalName);
    }

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

    public function messageEventSubscription(): ExecutionQueryInterface
    {
        return $this->eventSubscription(EventType::message(), null);
        return $this->eventSubscription(EventType::message(), /** @scrutinizer ignore-type */ null);
    }

    public function eventSubscription(EventType $eventType, string $eventName): ExecutionQueryInterface
    {
        EnsureUtil::ensureNotNull("event type", "eventType", $eventType);
        if (EventType::message() != $eventType) {
            // event name is optional for message events
            EnsureUtil::ensureNotNull("event name", "eventName", $eventName);
        }
        if (empty($this->eventSubscriptions)) {
            $this->eventSubscriptions = [];
        }
        $this->eventSubscriptions[] = new EventSubscriptionQueryValue($eventName, $eventType->name());
        return $this;
    }

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

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

    public function processVariableValueEquals(string $variableName, $variableValue): ExecutionQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::EQUALS, false);
        return $this;
    }

    public function processVariableValueNotEquals(string $variableName, $variableValue): ExecutionQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::NOT_EQUALS, false);
        return $this;
    }

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

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

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

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

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

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

    //ordering ////////////////////////////////////////////////////

    public function orderByProcessInstanceId(): ExecutionQueryImpl
    {
        $this->orderBy(ExecutionQueryProperty::processInstanceId());
        return $this;
    }

    public function orderByProcessDefinitionId(): ExecutionQueryImpl
    {
        $this->orderBy(new QueryOrderingProperty(QueryOrderingProperty::RELATION_PROCESS_DEFINITION, ExecutionQueryProperty::processDefinitionId()));
filter:
    dependency_paths: ["lib/*"]
        return $this;
    }

    public function orderByProcessDefinitionKey(): ExecutionQueryImpl
    {
        $this->orderBy(new QueryOrderingProperty(QueryOrderingProperty::RELATION_PROCESS_DEFINITION, ExecutionQueryProperty::processDefinitionKey()));
        return $this;
    }

    public function orderByTenantId(): ExecutionQueryInterface
    {
        $this->orderBy(ExecutionQueryProperty::tenantId());
        $this->orderBy(ExecutionQueryProperty::/** @scrutinizer ignore-call */ tenantId());
        return $this;
    }

    //results ////////////////////////////////////////////////////
    public function executeCount(CommandContext $commandContext): int
    {
        $this->checkQueryOk();
        $this->ensureVariablesInitialized();
        return $commandContext
        ->getExecutionManager()
        ->findExecutionCountByQueryCriteria($this);
    }

    public function executeList(CommandContext $commandContext, Page $page): array
filter:
    dependency_paths: ["lib/*"]
    {
        $this->checkQueryOk();
        $this->ensureVariablesInitialized();
        return $commandContext
        ->getExecutionManager()
        ->findExecutionsByQueryCriteria($this, $page);
    }

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

    public function getProcessDefinitionKey(): string
    {
        return $this->processDefinitionKey;
    }

    public function getProcessDefinitionId(): string
    {
        return $this->processDefinitionId;
    }

    public function getActivityId(): string
    {
        return $this->activityId;
    }

    public function getProcessInstanceId(): string
    {
        return $this->processInstanceId;
    }

    public function getProcessInstanceIds(): array
    {
        return [];
    }

    public function getBusinessKey(): string
    {
        return $this->businessKey;
    }

    public function getExecutionId(): string
    {
        return $this->executionId;
    }

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

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

    public function getEventSubscriptions(): array
    {
        return $this->eventSubscriptions;
    }

    public function setEventSubscriptions(array $eventSubscriptions): void
    {
        $this->eventSubscriptions = $eventSubscriptions;
    }

    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;
    }
}

bingo-soft / jabe

Push — main ( 5af89f...c76fcf )

ExecutionQueryImpl::orderByProcessDefinitionKey() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
