Jabe\Engine\Impl\HistoricTaskInstanceQueryImpl

Complexity

Total Complexity

204

Size/Duplication

Total Lines	1122
Duplicated Lines	0 %

Importance

Changes

0

142 Methods

Rating	Name	Duplication	Size	Complexity
A	getTaskDescription()	0	3	1
A	finishedBefore()	0	4	1
A	addOrQuery()	0	4	1
A	taskHadCandidateGroup()	0	4	1
A	taskPriority()	0	4	1
A	getDueDate()	0	3	1
A	taskDueBefore()	0	12	3
A	processInstanceBusinessKeyIn()	0	5	1
A	orderByExecutionId()	0	8	2
A	getDueAfter()	0	3	1
A	processInstanceId()	0	4	1
A	isWithCandidateGroups()	0	3	1
A	ensureVariablesInitialized()	0	13	5
A	processDefinitionId()	0	4	1
A	taskDueDate()	0	12	3
A	taskFollowUpBefore()	0	4	1
A	getVariableNamesIgnoreCase()	0	3	1
A	taskFollowUpDate()	0	4	1
A	isBoolean()	0	6	4
A	taskVariableValueEquals()	0	4	1
A	processVariableValueLessThanOrEquals()	0	4	1
A	orderByHistoricTaskInstanceDuration()	0	8	2
A	isFinished()	0	3	1
A	executeList()	0	7	1
A	isWithoutTaskDueDate()	0	3	1
A	orderByTaskPriority()	0	8	2
A	getTaskInvolvedGroup()	0	3	1
A	processVariableValueLike()	0	4	1
A	taskDefinitionKey()	0	3	1
C	addVariable()	0	29	12
A	taskAssigneeLike()	0	4	1
A	isOrQueryActive()	0	3	1
A	processDefinitionName()	0	4	1
A	orderByTenantId()	0	6	2
A	isTenantIdSet()	0	3	1
A	taskFollowUpAfter()	0	4	1
A	getProcessDefinitionKey()	0	3	1
A	getFollowUpDate()	0	3	1
A	isUnfinished()	0	3	1
A	processVariableValueGreaterThan()	0	4	1
A	getDueBefore()	0	3	1
A	isProcessFinished()	0	3	1
A	finished()	0	4	1
A	getTaskDefinitionKeys()	0	3	1
A	matchVariableValuesIgnoreCase()	0	7	2
A	orderByTaskDescription()	0	8	2
A	processVariableValueNotLike()	0	4	1
A	taskDescriptionLike()	0	4	1
A	orderByHistoricTaskInstanceEndTime()	0	8	2
A	getProcessInstanceBusinessKeys()	0	3	1
A	tenantIdIn()	0	6	1
A	getTaskParentTaskId()	0	3	1
A	getTaskHadCandidateGroup()	0	3	1
A	unfinished()	0	4	1
A	orderByHistoricActivityInstanceId()	0	8	2
A	orderByTaskAssignee()	0	8	2
A	getTaskAssignee()	0	3	1
A	getProcessDefinitionName()	0	3	1
A	orderByTaskDefinitionKey()	0	8	2
A	getVariables()	0	3	1
B	hasExcludingConditions()	0	10	10
A	processVariableValueEquals()	0	4	1
A	finishedAfter()	0	4	1
A	taskId()	0	4	1
A	getTaskDeleteReason()	0	3	1
A	getTaskInvolvedUser()	0	3	1
A	getFollowUpBefore()	0	3	1
A	isWithoutCandidateGroups()	0	3	1
A	getQueries()	0	3	1
A	getProcessInstanceBusinessKey()	0	3	1
A	executeCount()	0	7	1
A	withoutTaskDueDate()	0	12	5
A	taskInvolvedGroup()	0	4	1
A	withCandidateGroups()	0	8	2
A	getProcessInstanceBusinessKeyLike()	0	3	1
A	taskDeleteReason()	0	4	1
A	processVariableValueNotEquals()	0	4	1
A	taskName()	0	4	1
A	orderByTaskDueDate()	0	8	2
A	taskAssignee()	0	4	1
A	endOr()	0	6	3
A	startedAfter()	0	4	1
A	getTaskOwnerLike()	0	3	1
A	getStartedAfter()	0	3	1
A	processDefinitionKey()	0	4	1
A	isProcessUnfinished()	0	3	1
A	processUnfinished()	0	4	1
A	getFinishedAfter()	0	3	1
A	processFinished()	0	4	1
A	orderByTaskId()	0	8	2
A	orderByTaskOwner()	0	8	2
A	taskDueAfter()	0	12	3
A	withoutTenantId()	0	5	1
A	processInstanceBusinessKeyLike()	0	4	1
A	matchVariableNamesIgnoreCase()	0	7	2
A	isUnassigned()	0	3	1
A	taskAssigned()	0	4	1
A	withoutCandidateGroups()	0	8	2
A	getActivityInstanceIds()	0	3	1
A	taskOwnerLike()	0	4	1
A	taskDescription()	0	4	1
A	orderByTaskName()	0	8	2
A	getProcessInstanceId()	0	3	1
A	isAssigned()	0	3	1
A	getTaskName()	0	3	1
A	taskUnassigned()	0	4	1
A	processInstanceBusinessKey()	0	4	1
A	getFinishedBefore()	0	3	1
A	startedBefore()	0	4	1
A	taskDeleteReasonLike()	0	4	1
A	getTaskId()	0	3	1
A	getTaskHadCandidateUser()	0	3	1
A	getTaskPriority()	0	3	1
A	or()	0	12	2
A	processVariableValueGreaterThanOrEquals()	0	4	1
A	orderByProcessInstanceId()	0	8	2
A	getProcessDefinitionId()	0	3	1
A	taskDefinitionKeyIn()	0	5	1
A	orderByTaskFollowUpDate()	0	8	2
A	orderByDeleteReason()	0	8	2
A	processVariableValueLessThan()	0	4	1
A	getTenantIds()	0	3	1
A	taskHadCandidateUser()	0	4	1
A	getTaskAssigneeLike()	0	3	1
A	activityInstanceIdIn()	0	5	1
A	orderByProcessDefinitionId()	0	8	2
A	taskOwner()	0	4	1
A	setOrQueryActive()	0	3	1
A	taskNameLike()	0	4	1
A	getTaskDeleteReasonLike()	0	3	1
A	getTaskDescriptionLike()	0	3	1
A	getTaskNameLike()	0	3	1
A	orderByHistoricActivityInstanceStartTime()	0	8	2
A	getFollowUpAfter()	0	3	1
A	getExecutionId()	0	3	1
A	getTaskOwner()	0	3	1
A	__construct()	0	4	1
A	getStartedBefore()	0	3	1
A	executionId()	0	4	1
A	taskInvolvedUser()	0	4	1
A	getVariableValuesIgnoreCase()	0	3	1
A	taskParentTaskId()	0	4	1

<?php

namespace Jabe\Engine\Impl;

use Jabe\Engine\ProcessEngineException;
use Jabe\Engine\Exception\NotValidException;
use Jabe\Engine\History\{
    HistoricTaskInstanceInterface,
    HistoricTaskInstanceQueryInterface
};
use Jabe\Engine\Impl\Cfg\ProcessEngineConfigurationImpl;
use Jabe\Engine\Impl\Context\Context;
use Jabe\Engine\Impl\Interceptor\{
    CommandContext,
    CommandExecutorInterface
};
use Jabe\Engine\Impl\Util\{
    CompareUtil,
    EnsureUtil
};
use Jabe\Engine\Impl\Variable\Serializer\VariableSerializersInterface;

class HistoricTaskInstanceQueryImpl extends AbstractQuery implements HistoricTaskInstanceQueryInterface
{
    protected $processDefinitionId;
    protected $processDefinitionKey;
    protected $processDefinitionName;
    protected $processInstanceId;
    protected $processInstanceBusinessKey;
    protected $processInstanceBusinessKeys = [];
    protected $processInstanceBusinessKeyLike;
    protected $executionId;
    protected $activityInstanceIds = [];
    protected $taskId;
    protected $taskName;
    protected $taskNameLike;
    protected $taskParentTaskId;
    protected $taskDescription;
    protected $taskDescriptionLike;
    protected $taskDeleteReason;
    protected $taskDeleteReasonLike;
    protected $taskOwner;
    protected $taskOwnerLike;
    protected $assigned;
    protected $unassigned;
    protected $taskAssignee;
    protected $taskAssigneeLike;
    protected $taskDefinitionKeys = [];
    protected $taskInvolvedUser;
    protected $taskInvolvedGroup;
    protected $taskHadCandidateUser;
    protected $taskHadCandidateGroup;
    protected $withCandidateGroups;
    protected $withoutCandidateGroups;
    protected $taskPriority;
    protected $finished;
    protected $unfinished;
    protected $processFinished;
    protected $processUnfinished;
    protected $variables = [];
    protected $variableNamesIgnoreCase;
    protected $variableValuesIgnoreCase;

    protected $dueDate;
    protected $dueAfter;
    protected $dueBefore;
    protected $isWithoutTaskDueDate;

    protected $followUpDate;
    protected $followUpBefore;
    protected $followUpAfter;

    protected $tenantIds = [];
    protected $isTenantIdSet;

    protected $caseDefinitionId;
    protected $caseDefinitionKey;
    protected $caseDefinitionName;
    protected $caseInstanceId;
    protected $caseExecutionId;

    protected $finishedAfter;
    protected $finishedBefore;
    protected $startedAfter;
    protected $startedBefore;

    protected $queries = [];
    protected $isOrQueryActive = false;

    public function __construct(CommandExecutorInterface $commandExecutor)
    {
        parent::__construct($commandExecutor);
        $this->queries[] = $this;
    }

    public function executeCount(CommandContext $commandContext): int
    {
        $this->ensureVariablesInitialized();
        $this->checkQueryOk();
        return $commandContext
            ->getHistoricTaskInstanceManager()
            ->findHistoricTaskInstanceCountByQueryCriteria($this);
    }

    public function executeList(CommandContext $commandContext, Page $page): array
    {
        $this->ensureVariablesInitialized();
        $this->checkQueryOk();
        return $commandContext
            ->getHistoricTaskInstanceManager()
            ->findHistoricTaskInstancesByQueryCriteria($this, $page);
    }

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

    public function processInstanceBusinessKey(string $processInstanceBusinessKey): HistoricTaskInstanceQueryInterface
    {
        $this->processInstanceBusinessKey = $processInstanceBusinessKey;
        return $this;
    }

    public function processInstanceBusinessKeyIn(array $processInstanceBusinessKeys): HistoricTaskInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull("processInstanceBusinessKeys", "processInstanceBusinessKeys", $processInstanceBusinessKeys);
        $this->processInstanceBusinessKeys = $processInstanceBusinessKeys;
        return $this;
    }

    public function processInstanceBusinessKeyLike(string $processInstanceBusinessKey): HistoricTaskInstanceQueryInterface
    {
        $this->processInstanceBusinessKeyLike = $processInstanceBusinessKey;
        return $this;
    }

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

    public function activityInstanceIdIn(array $activityInstanceIds): HistoricTaskInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull("activityInstanceIds", "activityInstanceIds", $activityInstanceIds);
        $this->activityInstanceIds = $activityInstanceIds;
        return $this;
    }

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

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

    public function processDefinitionName(string $processDefinitionName): HistoricTaskInstanceQueryInterface
    {
        $this->processDefinitionName = $processDefinitionName;
        return $this;
    }

    public function taskId(string $taskId): HistoricTaskInstanceQueryInterface
    {
        $this->taskId = $taskId;
        return $this;
    }

    public function taskName(string $taskName): HistoricTaskInstanceQueryImpl
    {
        $this->taskName = $taskName;
        return $this;
    }

    public function taskNameLike(string $taskNameLike): HistoricTaskInstanceQueryImpl
    {
        $this->taskNameLike = $taskNameLike;
        return $this;
    }

    public function taskParentTaskId(string $parentTaskId): HistoricTaskInstanceQueryInterface
    {
        $this->taskParentTaskId = $parentTaskId;
        return $this;
    }

    public function taskDescription(string $taskDescription): HistoricTaskInstanceQueryImpl
    {
        $this->taskDescription = $taskDescription;
        return $this;
    }

    public function taskDescriptionLike(string $taskDescriptionLike): HistoricTaskInstanceQueryImpl
    {
        $this->taskDescriptionLike = $taskDescriptionLike;
        return $this;
    }

    public function taskDeleteReason(string $taskDeleteReason): HistoricTaskInstanceQueryImpl
    {
        $this->taskDeleteReason = $taskDeleteReason;
        return $this;
    }

    public function taskDeleteReasonLike(string $taskDeleteReasonLike): HistoricTaskInstanceQueryImpl
    {
        $this->taskDeleteReasonLike = $taskDeleteReasonLike;
        return $this;
    }

    public function taskAssigned(): HistoricTaskInstanceQueryImpl
    {
        $this->assigned = true;
        return $this;
    }

    public function taskUnassigned(): HistoricTaskInstanceQueryImpl
    {
        $this->unassigned = true;
        return $this;
    }

    public function taskAssignee(string $taskAssignee): HistoricTaskInstanceQueryImpl
    {
        $this->taskAssignee = $taskAssignee;
        return $this;
    }

    public function taskAssigneeLike(string $taskAssigneeLike): HistoricTaskInstanceQueryImpl
    {
        $this->taskAssigneeLike = $taskAssigneeLike;
        return $this;
    }

    public function taskOwner(string $taskOwner): HistoricTaskInstanceQueryImpl
    {
        $this->taskOwner = $taskOwner;
        return $this;
    }

    public function taskOwnerLike(string $taskOwnerLike): HistoricTaskInstanceQueryImpl
    {
        $this->taskOwnerLike = $taskOwnerLike;
        return $this;
    }

    /*public HistoricTaskInstanceQueryInterface caseDefinitionId(string $caseDefinitionId) {
        $this->caseDefinitionId = caseDefinitionId;
        return $this;
    }

    public HistoricTaskInstanceQueryInterface caseDefinitionKey(string $caseDefinitionKey) {
        $this->caseDefinitionKey = caseDefinitionKey;
        return $this;
    }

    public HistoricTaskInstanceQueryInterface caseDefinitionName(string $caseDefinitionName) {
        $this->caseDefinitionName = caseDefinitionName;
        return $this;
    }

    public HistoricTaskInstanceQueryInterface caseInstanceId(string $caseInstanceId) {
        $this->caseInstanceId = caseInstanceId;
        return $this;
    }

    public HistoricTaskInstanceQueryInterface caseExecutionId(string $caseExecutionId) {
        $this->caseExecutionId = caseExecutionId;
        return $this;
    }*/

    public function finished(): HistoricTaskInstanceQueryImpl
    {
        $this->finished = true;
        return $this;
    }

    public function unfinished(): HistoricTaskInstanceQueryImpl
    {
        $this->unfinished = true;
        return $this;
    }

    public function matchVariableNamesIgnoreCase(): HistoricTaskInstanceQueryInterface
    {
        $this->variableNamesIgnoreCase = true;
        foreach ($this->variables as $variable) {
            $variable->setVariableNameIgnoreCase(true);
        }
        return $this;
    }

    public function matchVariableValuesIgnoreCase(): HistoricTaskInstanceQueryInterface
    {
        $this->variableValuesIgnoreCase = true;
        foreach ($this->variables as $variable) {
            $variable->setVariableValueIgnoreCase(true);
        }
        return $this;
    }

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

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

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

    public function processVariableValueLike(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::LIKE, false, true);
        return $this;
    }

    public function processVariableValueNotLike(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::NOT_LIKE, false, true);
        return $this;
    }

    public function processVariableValueGreaterThan(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::GREATER_THAN, false, true);
        return $this;
    }

    public function processVariableValueGreaterThanOrEquals(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::GREATER_THAN_OR_EQUAL, false, true);
        return $this;
    }

    public function processVariableValueLessThan(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::LESS_THAN, false, true);
        return $this;
    }

    public function processVariableValueLessThanOrEquals(string $variableName, $variableValue): HistoricTaskInstanceQueryInterface
    {
        $this->addVariable($variableName, $variableValue, QueryOperator::LESS_THAN_OR_EQUAL, false, true);
        return $this;
    }

    public function taskDefinitionKey(string $taskDefinitionKey): HistoricTaskInstanceQueryInterface
    {
        return $this->taskDefinitionKeyIn($taskDefinitionKey);

$taskDefinitionKey of type string is incompatible with the type array expected by parameter $taskDefinitionKeys of Jabe\Engine\Impl\HistoricTaskInstanceQueryImpl::taskDefinitionKeyIn().

    }

    public function taskDefinitionKeyIn(array $taskDefinitionKeys): HistoricTaskInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull(NotValidException::class, "taskDefinitionKeys", $taskDefinitionKeys);
        $this->taskDefinitionKeys = $taskDefinitionKeys;
        return $this;
    }

    public function taskPriority(int $taskPriority): HistoricTaskInstanceQueryInterface
    {
        $this->taskPriority = $taskPriority;
        return $this;
    }

    public function processFinished(): HistoricTaskInstanceQueryInterface
    {
        $this->processFinished = true;
        return $this;
    }

    public function taskInvolvedUser(string $userId): HistoricTaskInstanceQueryInterface
    {
        $this->taskInvolvedUser = $userId;
        return $this;
    }

    public function taskInvolvedGroup(string $groupId): HistoricTaskInstanceQueryInterface
    {
        $this->taskInvolvedGroup = $groupId;
        return $this;
    }

    public function taskHadCandidateUser(string $userId): HistoricTaskInstanceQueryInterface
    {
        $this->taskHadCandidateUser = $userId;
        return $this;
    }

    public function taskHadCandidateGroup(string $groupId): HistoricTaskInstanceQueryInterface
    {
        $this->taskHadCandidateGroup = $groupId;
        return $this;
    }

    public function withCandidateGroups(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set withCandidateGroups() within 'or' query");
        }

        $this->withCandidateGroups = true;
        return $this;
    }

    public function withoutCandidateGroups(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set withoutCandidateGroups() within 'or' query");
        }

        $this->withoutCandidateGroups = true;
        return $this;
    }

    public function processUnfinished(): HistoricTaskInstanceQueryInterface
    {
        $this->processUnfinished = true;
        return $this;
    }

    protected function ensureVariablesInitialized(): void
    {
        $processEngineConfiguration = Context::getProcessEngineConfiguration();
        $variableSerializers = $processEngineConfiguration->getVariableSerializers();

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

        $dbType = $processEngineConfiguration->getDatabaseType();
        foreach ($this->variables as $var) {
            $var->initialize($variableSerializers, $dbType);
        }

        if (!empty($this->queries)) {
            foreach ($this->queries as $orQuery) {
                foreach ($orQuery->variables as $var) {
                    $var->initialize($variableSerializers, $dbType);
                }
            }
        }
    }

    public function addVariable($nameOrValue, $value = null, string $operator = null, bool $isTaskVariable = null, bool $isProcessInstanceVariable = null): void
    {
        if ($nameOrValue instanceof TaskQueryVariableValue) {
            $this->variables[] = $taskQueryVariableValue;

The variable $taskQueryVariableValue seems to be never defined.

        } else {
            EnsureUtil::ensureNotNull("name", "name", $name);

The variable $name seems to be never defined.

            if ($value == null || $this->isBoolean($value)) {
                // Null-values and booleans can only be used in EQUALS and NOT_EQUALS
                switch ($operator) {
                    case QueryOperator::GREATER_THAN:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'greater than' condition");
                    case QueryOperator::LESS_THAN:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'less than' condition");
                    case QueryOperator::GREATER_THAN_OR_EQUAL:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'greater than or equal' condition");
                    case QueryOperator::LESS_THAN_OR_EQUAL:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'less than or equal' condition");
                    case QueryOperator::LIKE:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'like' condition");
                    case QueryOperator::NOT_LIKE:
                        throw new ProcessEngineException("Booleans and null cannot be used in 'not like' condition");
                    default:
                        break;
                }
            }
            $shouldMatchVariableValuesIgnoreCase = $variableValuesIgnoreCase && $value != null && is_string($value);

The variable $variableValuesIgnoreCase seems to be never defined.

            $shouldMatchVariableNamesIgnoreCase = $variableNamesIgnoreCase;

The variable $variableNamesIgnoreCase seems to be never defined.

            $this->addVariable(
                new TaskQueryVariableValue($name, $value, $operator, $isTaskVariable, $isProcessInstanceVariable, $shouldMatchVariableNamesIgnoreCase, $shouldMatchVariableValuesIgnoreCase)
            );
        }
    }

    private function isBoolean($value): bool
    {
        if ($value == null) {
            return false;
        }
        return is_bool($value) || strtolower($value) === "true" || strtolower($value) === "false";
    }

    public function taskDueDate(string $dueDate): HistoricTaskInstanceQueryInterface
    {
        // The taskDueDate filter can't be used in an AND query with
        // the withoutTaskDueDate filter. They can be combined in an OR query
        if (!$this->isOrQueryActive) {
            if ($this->isWithoutTaskDueDate) {
                throw new ProcessEngineException("Invalid query usage: cannot set both taskDueDate and withoutTaskDueDate filters.");
            }
        }

        $this->dueDate = $dueDate;
        return $this;
    }

    public function taskDueAfter(string $dueAfter): HistoricTaskInstanceQueryInterface
    {
        // The taskDueAfter filter can't be used in an AND query with
        // the withoutTaskDueDate filter. They can be combined in an OR query
        if (!$this->isOrQueryActive) {
            if ($this->isWithoutTaskDueDate) {
                throw new ProcessEngineException("Invalid query usage: cannot set both taskDueAfter and withoutTaskDueDate filters.");
            }
        }

        $this->dueAfter = $dueAfter;
        return $this;
    }

    public function taskDueBefore(string $dueBefore): HistoricTaskInstanceQueryInterface
    {
        // The taskDueBefore filter can't be used in an AND query with
        // the withoutTaskDueDate filter. They can be combined in an OR query
        if (!$this->isOrQueryActive) {
            if ($this->isWithoutTaskDueDate) {
                throw new ProcessEngineException("Invalid query usage: cannot set both taskDueBefore and withoutTaskDueDate filters.");
            }
        }

        $this->dueBefore = $dueBefore;
        return $this;
    }

    public function withoutTaskDueDate(): HistoricTaskInstanceQueryInterface
    {
        // The due date filters can't be used in an AND query with
        // the withoutTaskDueDate filter. They can be combined in an OR query
        if (!$this->isOrQueryActive) {
            if ($this->dueAfter != null || $this->dueBefore != null || $this->dueDate != null) {
                throw new ProcessEngineException("Invalid query usage: cannot set both task due date (equal to, before, or after) and withoutTaskDueDate filters.");
            }
        }

        $this->isWithoutTaskDueDate = true;
        return $this;
    }

    public function taskFollowUpDate(string $followUpDate): HistoricTaskInstanceQueryInterface
    {
        $this->followUpDate = $followUpDate;
        return $this;
    }

    public function taskFollowUpBefore(string $followUpBefore): HistoricTaskInstanceQueryInterface
    {
        $this->followUpBefore = $followUpBefore;
        return $this;
    }

    public function taskFollowUpAfter(string $followUpAfter): HistoricTaskInstanceQueryInterface
    {
        $this->followUpAfter = $followUpAfter;
        return $this;
    }

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

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

    public function finishedAfter(string $date): HistoricTaskInstanceQueryInterface
    {
        $this->finishedAfter = $date;
        return $this;
    }

    public function finishedBefore(string $date): HistoricTaskInstanceQueryInterface
    {
        $this->finishedBefore = $date;
        return $this;
    }

    public function startedAfter(string $date): HistoricTaskInstanceQueryInterface
    {
        $this->startedAfter = $date;
        return $this;
    }

    public function startedBefore(string $date): HistoricTaskInstanceQueryInterface
    {
        $this->startedBefore = $date;
        return $this;
    }

    protected function hasExcludingConditions(): bool
    {
        return parent::hasExcludingConditions()
            || ($this->finished && $this->unfinished)
            || ($this->processFinished && $this->processUnfinished)
            || CompareUtil::areNotInAscendingOrder($this->startedAfter, $this->startedBefore)
            || CompareUtil::areNotInAscendingOrder($this->finishedAfter, $this->finishedBefore)
            || CompareUtil::areNotInAscendingOrder($this->dueAfter, $this->dueDate, $this->dueBefore)
            || CompareUtil::areNotInAscendingOrder($this->followUpAfter, $this->followUpDate, $this->followUpBefore)
            || CompareUtil::elementIsNotContainedInArray($this->processInstanceBusinessKey, $this->processInstanceBusinessKeys);
    }

    public function orderByTaskId(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::historicTaskInstanceId());
        return $this;
    }

    public function orderByHistoricActivityInstanceId(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByHistoricActivityInstanceId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::activityInstanceId());
        return $this;
    }

    public function orderByProcessDefinitionId(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessDefinitionId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::processDefinitionId());
        return $this;
    }

    public function orderByProcessInstanceId(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessInstanceId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::processInstanceId());
        return $this;
    }

    public function orderByExecutionId(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByExecutionId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::executionId());
        return $this;
    }

    public function orderByHistoricTaskInstanceDuration(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByHistoricTaskInstanceDuration() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::duration());
        return $this;
    }

    public function orderByHistoricTaskInstanceEndTime(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByHistoricTaskInstanceEndTime() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::end());
        return $this;
    }

    public function orderByHistoricActivityInstanceStartTime(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByHistoricActivityInstanceStartTime() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::start());
        return $this;
    }

    public function orderByTaskName(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskName() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskName());
        return $this;
    }

    public function orderByTaskDescription(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskDescription() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskDescription());
        return $this;
    }

    public function orderByTaskAssignee(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskAssignee() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskAssignee());
        return $this;
    }

    public function orderByTaskOwner(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskOwner() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskOwner());
        return $this;
    }

    public function orderByTaskDueDate(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskDueDate() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskDueDate());
        return $this;
    }

    public function orderByTaskFollowUpDate(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskFollowUpDate() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskFollowUpDate());
        return $this;
    }

    public function orderByDeleteReason(): HistoricTaskInstanceQueryImpl
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByDeleteReason() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::deleteReason());
        return $this;
    }

    public function orderByTaskDefinitionKey(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskDefinitionKey() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty::taskDefinitionKey());
        return $this;
    }

    public function orderByTaskPriority(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTaskPriority() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty:: taskPriority());
        return $this;
    }

    /*public HistoricTaskInstanceQueryInterface orderByCaseDefinitionId() {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByCaseDefinitionId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty.CASE_DEFINITION_ID);
        return $this;
    }

    public HistoricTaskInstanceQueryInterface orderByCaseInstanceId() {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByCaseInstanceId() within 'or' query");
        }

        $this->orderBy(HistoricTaskInstanceQueryProperty.CASE_INSTANCE_ID);
        return $this;
    }

    public function orderByCaseExecutionId(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByCaseExecutionId() within 'or' query");
        }
        $this->orderBy(HistoricTaskInstanceQueryProperty.CASE_EXECUTION_ID);
        return $this;
    }*/

    public function orderByTenantId(): HistoricTaskInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByTenantId() within 'or' query");
        }
        return $this->orderBy(HistoricTaskInstanceQueryProperty::tenantId());
    }

    // getters and setters //////////////////////////////////////////////////////

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

    public function getProcessInstanceBusinessKey(): string
    {
        return $this->processInstanceBusinessKey;
    }

    public function getProcessInstanceBusinessKeys(): array
    {
        return $this->processInstanceBusinessKeys;
    }

    public function getProcessInstanceBusinessKeyLike(): string
    {
        return $this->processInstanceBusinessKeyLike;
    }

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

    public function getProcessDefinitionName(): string
    {
        return $this->processDefinitionName;
    }

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

    public function getActivityInstanceIds(): array
    {
        return $this->activityInstanceIds;
    }

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

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

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

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

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

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

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

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

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

    public function getDueDate(): string
    {
        return $this->dueDate;
    }

    public function getDueBefore(): string
    {
        return $this->dueBefore;
    }

    public function getDueAfter(): string
    {
        return $this->dueAfter;
    }

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

    public function getFollowUpDate(): string
    {
        return $this->followUpDate;
    }

    public function getFollowUpBefore(): string
    {
        return $this->followUpBefore;
    }

    public function getFollowUpAfter(): string
    {
        return $this->followUpAfter;
    }

    public function getTaskName(): string
    {
        return $this->taskName;
    }

    public function getTaskNameLike(): string
    {
        return $this->taskNameLike;
    }

    public function getTaskDescription(): string
    {
        return $this->taskDescription;
    }

    public function getTaskDescriptionLike(): string
    {
        return $this->taskDescriptionLike;
    }

    public function getTaskDeleteReason(): string
    {
        return $this->taskDeleteReason;
    }

    public function getTaskDeleteReasonLike(): string
    {
        return $this->taskDeleteReasonLike;
    }

    public function getTaskAssignee(): string
    {
        return $this->taskAssignee;
    }

    public function getTaskAssigneeLike(): string
    {
        return $this->taskAssigneeLike;
    }

    public function getTaskId(): string
    {
        return $this->taskId;
    }

    public function getTaskInvolvedGroup(): string
    {
        return $this->taskInvolvedGroup;
    }

    public function getTaskInvolvedUser(): string
    {
        return $this->taskInvolvedUser;
    }

    public function getTaskHadCandidateGroup(): string
    {
        return $this->taskHadCandidateGroup;
    }

    public function getTaskHadCandidateUser(): string
    {
        return $this->taskHadCandidateUser;
    }

    public function getTaskDefinitionKeys(): array
    {
        return $this->taskDefinitionKeys;
    }

    public function getVariables(): array
    {
        return $this->variables;
    }

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

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

    public function getTaskOwnerLike(): string
    {
        return $this->taskOwnerLike;
    }

    public function getTaskOwner(): string
    {
        return $this->taskOwner;
    }

    public function getTaskPriority(): int
    {
        return $this->taskPriority;
    }

    public function getTaskParentTaskId(): string
    {
        return $this->taskParentTaskId;
    }

    public function getTenantIds(): array
    {
        return $this->tenantIds;
    }

    /*public String getCaseDefinitionId() {
        return caseDefinitionId;
    }

    public String getCaseDefinitionKey() {
        return caseDefinitionKey;
    }

    public String getCaseDefinitionName() {
        return caseDefinitionName;
    }

    public String getCaseInstanceId() {
        return caseInstanceId;
    }

    public function getCaseExecutionId(): string
    {
        return caseExecutionId;
    }*/

    public function getFinishedAfter(): string
    {
        return $this->finishedAfter;
    }

    public function getFinishedBefore(): string
    {
        return $this->finishedBefore;
    }

    public function getStartedAfter(): string
    {
        return $this->startedAfter;
    }

    public function getStartedBefore(): string
    {
        return $this->startedBefore;
    }

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

    public function getQueries(): array
    {
        return $this->queries;
    }

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

    public function addOrQuery(HistoricTaskInstanceQueryImpl $orQuery): void
    {
        $orQuery->isOrQueryActive = true;
        $this->queries[] = $orQuery;
    }

    public function setOrQueryActive(): void
    {
        $this->isOrQueryActive = true;
    }

    public function or(): HistoricTaskInstanceQueryInterface
    {
        if ($this != $this->queries[0]) {
            throw new ProcessEngineException("Invalid query usage: cannot set or() within 'or' query");
        }

        $orQuery = new HistoricTaskInstanceQueryImpl();

The call to Jabe\Engine\Impl\HistoricTaskInstanceQueryImpl::__construct() has too few arguments starting with commandExecutor.

        $orQuery->isOrQueryActive = true;
        //@CHECK IT OUT
        $orQuery->queries = $this->queries;
        $this->queries[] = $orQuery;
        return $orQuery;
    }

    public function endOr(): HistoricTaskInstanceQueryInterface
    {
        if (!empty($this->queries) && $this != $this->queries[count($this->queries) - 1]) {
            throw new ProcessEngineException("Invalid query usage: cannot set endOr() before or()");
        }
        return $this->queries[0];
    }
}