Jabe\Impl\TaskQueryImpl::extend()

Complexity

Conditions	127
Paths	0

Size

Total Lines	430
Code Lines	234

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function extend(TaskQueryInterface $extending): TaskQueryInterface
    {
        $extendingQuery = $extending;
        $extendedQuery = new TaskQueryImpl();

        // only add the base query's validators to the new query;
        // this is because the extending query's validators may not be applicable to the base
        // query and should therefore be executed before extending the query
        $extendedQuery->validators = $this->validators;

        if ($extendingQuery->getName() !== null) {

The method getName() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskName($extendingQuery->getName());
        } elseif ($this->getName() !== null) {

The condition $this->getName() !== null is always true.

            $extendedQuery->taskName($this->getName());
        }

        if ($extendingQuery->getNameLike() !== null) {

The method getNameLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskNameLike($extendingQuery->getNameLike());
        } elseif ($this->getNameLike() !== null) {

The condition $this->getNameLike() !== null is always true.

            $extendedQuery->taskNameLike($this->getNameLike());
        }

        if ($extendingQuery->getNameNotEqual() !== null) {

The method getNameNotEqual() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskNameNotEqual($extendingQuery->getNameNotEqual());
        } elseif ($this->getNameNotEqual() !== null) {

The condition $this->getNameNotEqual() !== null is always true.

            $extendedQuery->taskNameNotEqual($this->getNameNotEqual());
        }

        if ($extendingQuery->getNameNotLike() !== null) {

The method getNameNotLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskNameNotLike($extendingQuery->getNameNotLike());
        } elseif ($this->getNameNotLike() !== null) {

The condition $this->getNameNotLike() !== null is always true.

            $extendedQuery->taskNameNotLike($this->getNameNotLike());
        }

        if ($extendingQuery->getAssignee() !== null) {

The method getAssignee() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskAssignee($extendingQuery->getAssignee());
        } elseif ($this->getAssignee() !== null) {

The condition $this->getAssignee() !== null is always true.

            $extendedQuery->taskAssignee($this->getAssignee());
        }

        if ($extendingQuery->getAssigneeLike() !== null) {

The method getAssigneeLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskAssigneeLike($extendingQuery->getAssigneeLike());
        } elseif ($this->getAssigneeLike() !== null) {

The condition $this->getAssigneeLike() !== null is always true.

            $extendedQuery->taskAssigneeLike($this->getAssigneeLike());
        }

        if ($extendingQuery->getAssigneeIn() !== null) {

The method getAssigneeIn() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskAssigneeIn($extendingQuery->getAssigneeIn());
        } elseif ($this->getAssigneeIn() !== null) {

The condition $this->getAssigneeIn() !== null is always true.

            $extendedQuery->taskAssigneeIn($this->getAssigneeIn());
        }
        if ($extendingQuery->getAssigneeNotIn() !== null) {

The method getAssigneeNotIn() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskAssigneeNotIn($extendingQuery->getAssigneeNotIn());
        } elseif ($this->getAssigneeNotIn() !== null) {

The condition $this->getAssigneeNotIn() !== null is always true.

            $extendedQuery->taskAssigneeNotIn($this->getAssigneeNotIn());
        }

        if ($extendingQuery->getInvolvedUser() !== null) {

The method getInvolvedUser() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskInvolvedUser($extendingQuery->getInvolvedUser());
        } elseif ($this->getInvolvedUser() !== null) {

The condition $this->getInvolvedUser() !== null is always true.

            $extendedQuery->taskInvolvedUser($this->getInvolvedUser());
        }

        if ($extendingQuery->getOwner() !== null) {

The method getOwner() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskOwner($extendingQuery->getOwner());
        } elseif ($this->getOwner() !== null) {

The condition $this->getOwner() !== null is always true.

            $extendedQuery->taskOwner($this->getOwner());
        }

        if ($extendingQuery->isAssigned() || $this->isAssigned()) {

The method isAssigned() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskAssigned();
        }

        if ($extendingQuery->isUnassigned() || $this->isUnassigned()) {

The method isUnassigned() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskUnassigned();
        }

        if ($extendingQuery->getDelegationState() !== null) {

The method getDelegationState() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDelegationState($extendingQuery->getDelegationState());
        } elseif ($this->getDelegationState() !== null) {

The condition $this->getDelegationState() !== null is always true.

            $extendedQuery->taskDelegationState($this->getDelegationState());
        }

        if ($extendingQuery->getCandidateUser() !== null) {

The method getCandidateUser() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCandidateUser($extendingQuery->getCandidateUser());
        } elseif ($this->getCandidateUser() !== null) {

The condition $this->getCandidateUser() !== null is always true.

            $extendedQuery->taskCandidateUser($this->getCandidateUser());
        }

        if ($extendingQuery->getCandidateGroup() !== null) {

The method getCandidateGroup() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCandidateGroup($extendingQuery->getCandidateGroup());
        } elseif ($this->getCandidateGroup() !== null) {

The condition $this->getCandidateGroup() !== null is always true.

            $extendedQuery->taskCandidateGroup($this->getCandidateGroup());
        }

        if ($extendingQuery->isWithCandidateGroups() || $this->isWithCandidateGroups()) {

The method isWithCandidateGroups() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->withCandidateGroups();
        }

        if ($extendingQuery->isWithCandidateUsers() || $this->isWithCandidateUsers()) {

The method isWithCandidateUsers() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->withCandidateUsers();
        }

        if ($extendingQuery->isWithoutCandidateGroups() || $this->isWithoutCandidateGroups()) {

The method isWithoutCandidateGroups() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->withoutCandidateGroups();
        }

        if ($extendingQuery->isWithoutCandidateUsers() || $this->isWithoutCandidateUsers()) {

The method isWithoutCandidateUsers() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->withoutCandidateUsers();
        }

        if ($extendingQuery->getCandidateGroupsInternal() !== null) {

The method getCandidateGroupsInternal() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCandidateGroupIn($extendingQuery->getCandidateGroupsInternal());
        } elseif ($this->getCandidateGroupsInternal() !== null) {

The condition $this->getCandidateGroupsInternal() !== null is always true.

            $extendedQuery->taskCandidateGroupIn($this->getCandidateGroupsInternal());
        }

        if ($extendingQuery->getProcessInstanceId() !== null) {

The method getProcessInstanceId() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processInstanceId($extendingQuery->getProcessInstanceId());
        } elseif ($this->getProcessInstanceId() !== null) {

The condition $this->getProcessInstanceId() !== null is always true.

            $extendedQuery->processInstanceId($this->getProcessInstanceId());
        }

        if ($extendingQuery->getProcessInstanceIdIn() !== null) {

The method getProcessInstanceIdIn() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processInstanceIdIn($extendingQuery->getProcessInstanceIdIn());
        } elseif ($this->processInstanceIdIn() !== null) {

The call to Jabe\Impl\TaskQueryImpl::processInstanceIdIn() has too few arguments starting with processInstanceIds.

            $extendedQuery->processInstanceIdIn($this->getProcessInstanceIdIn());
        }

        if ($extendingQuery->getExecutionId() !== null) {

The method getExecutionId() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->executionId($extendingQuery->getExecutionId());
        } elseif ($this->getExecutionId() !== null) {

The condition $this->getExecutionId() !== null is always true.

            $extendedQuery->executionId($this->getExecutionId());
        }

        if ($extendingQuery->getActivityInstanceIdIn() !== null) {

The method getActivityInstanceIdIn() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->activityInstanceIdIn($extendingQuery->getActivityInstanceIdIn());
        } elseif ($this->getActivityInstanceIdIn() !== null) {

The condition $this->getActivityInstanceIdIn() !== null is always true.

            $extendedQuery->activityInstanceIdIn($this->getActivityInstanceIdIn());
        }

        if ($extendingQuery->getTaskId() !== null) {

The method getTaskId() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskId($extendingQuery->getTaskId());
        } elseif ($this->getTaskId() !== null) {

The condition $this->getTaskId() !== null is always true.

            $extendedQuery->taskId($this->getTaskId());
        }

        if ($extendingQuery->getTaskIdIn() !== null) {

The method getTaskIdIn() does not exist on Jabe\Task\TaskQueryInterface. Did you maybe mean taskIdIn()?

            $extendedQuery->taskIdIn($extendingQuery->getTaskIdIn());
        } elseif ($this->getTaskIdIn() !== null) {

The condition $this->getTaskIdIn() !== null is always true.

            $extendedQuery->taskIdIn($this->getTaskIdIn());
        }

        if ($extendingQuery->getDescription() !== null) {

The method getDescription() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDescription($extendingQuery->getDescription());
        } elseif ($this->getDescription() !== null) {

The condition $this->getDescription() !== null is always true.

            $extendedQuery->taskDescription($this->getDescription());
        }

        if ($extendingQuery->getDescriptionLike() !== null) {

The method getDescriptionLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDescriptionLike($extendingQuery->getDescriptionLike());
        } elseif ($this->getDescriptionLike() !== null) {

The condition $this->getDescriptionLike() !== null is always true.

            $extendedQuery->taskDescriptionLike($this->getDescriptionLike());
        }

        if ($extendingQuery->getPriority() !== null) {

The method getPriority() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskPriority($extendingQuery->getPriority());
        } elseif ($this->getPriority() !== null) {

The condition $this->getPriority() !== null is always true.

            $extendedQuery->taskPriority($this->getPriority());
        }

        if ($extendingQuery->getMinPriority() !== null) {

The method getMinPriority() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskMinPriority($extendingQuery->getMinPriority());
        } elseif ($this->getMinPriority() !== null) {

The condition $this->getMinPriority() !== null is always true.

            $extendedQuery->taskMinPriority($this->getMinPriority());
        }

        if ($extendingQuery->getMaxPriority() !== null) {

The method getMaxPriority() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskMaxPriority($extendingQuery->getMaxPriority());
        } elseif ($this->getMaxPriority() !== null) {

The condition $this->getMaxPriority() !== null is always true.

            $extendedQuery->taskMaxPriority($this->getMaxPriority());
        }

        if ($extendingQuery->getCreateTime() !== null) {

The method getCreateTime() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCreatedOn($extendingQuery->getCreateTime());
        } elseif ($this->getCreateTime() !== null) {

The condition $this->getCreateTime() !== null is always true.

            $extendedQuery->taskCreatedOn($this->getCreateTime());
        }

        if ($extendingQuery->getCreateTimeBefore() !== null) {

The method getCreateTimeBefore() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCreatedBefore($extendingQuery->getCreateTimeBefore());
        } elseif ($this->getCreateTimeBefore() !== null) {

The condition $this->getCreateTimeBefore() !== null is always true.

            $extendedQuery->taskCreatedBefore($this->getCreateTimeBefore());
        }

        if ($extendingQuery->getCreateTimeAfter() !== null) {

The method getCreateTimeAfter() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskCreatedAfter($extendingQuery->getCreateTimeAfter());
        } elseif ($this->getCreateTimeAfter() !== null) {

The condition $this->getCreateTimeAfter() !== null is always true.

            $extendedQuery->taskCreatedAfter($this->getCreateTimeAfter());
        }

        if ($extendingQuery->getKey() !== null) {

The method getKey() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDefinitionKey($extendingQuery->getKey());
        } elseif ($this->getKey() !== null) {

The condition $this->getKey() !== null is always true.

            $extendedQuery->taskDefinitionKey($this->getKey());
        }

        if ($extendingQuery->getKeyLike() !== null) {

The method getKeyLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDefinitionKeyLike($extendingQuery->getKeyLike());
        } elseif ($this->getKeyLike() !== null) {

The condition $this->getKeyLike() !== null is always true.

            $extendedQuery->taskDefinitionKeyLike($this->getKeyLike());
        }

        if ($extendingQuery->getKeys() !== null) {

The method getKeys() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskDefinitionKeyIn($extendingQuery->getKeys());
        } elseif ($this->getKeys() !== null) {

The condition $this->getKeys() !== null is always true.

            $extendedQuery->taskDefinitionKeyIn($this->getKeys());
        }

        if ($extendingQuery->getParentTaskId() !== null) {

The method getParentTaskId() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskParentTaskId($extendingQuery->getParentTaskId());
        } elseif ($this->getParentTaskId() !== null) {

The condition $this->getParentTaskId() !== null is always true.

            $extendedQuery->taskParentTaskId($this->getParentTaskId());
        }

        if ($extendingQuery->getProcessDefinitionKey() !== null) {

The method getProcessDefinitionKey() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processDefinitionKey($extendingQuery->getProcessDefinitionKey());
        } elseif ($this->getProcessDefinitionKey() !== null) {

The condition $this->getProcessDefinitionKey() !== null is always true.

            $extendedQuery->processDefinitionKey($this->getProcessDefinitionKey());
        }

        if ($extendingQuery->getProcessDefinitionKeys() !== null) {

The method getProcessDefinitionKeys() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processDefinitionKeyIn($extendingQuery->getProcessDefinitionKeys());
        } elseif ($this->getProcessDefinitionKeys() !== null) {

The condition $this->getProcessDefinitionKeys() !== null is always true.

            $extendedQuery->processDefinitionKeyIn($this->getProcessDefinitionKeys());
        }

        if ($extendingQuery->getProcessDefinitionId() !== null) {

The method getProcessDefinitionId() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processDefinitionId($extendingQuery->getProcessDefinitionId());
        } elseif ($this->getProcessDefinitionId() !== null) {

The condition $this->getProcessDefinitionId() !== null is always true.

            $extendedQuery->processDefinitionId($this->getProcessDefinitionId());
        }

        if ($extendingQuery->getProcessDefinitionName() !== null) {

The method getProcessDefinitionName() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processDefinitionName($extendingQuery->getProcessDefinitionName());
        } elseif ($this->getProcessDefinitionName() !== null) {

The condition $this->getProcessDefinitionName() !== null is always true.

            $extendedQuery->processDefinitionName($this->getProcessDefinitionName());
        }

        if ($extendingQuery->getProcessDefinitionNameLike() !== null) {

The method getProcessDefinitionNameLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processDefinitionNameLike($extendingQuery->getProcessDefinitionNameLike());
        } elseif ($this->getProcessDefinitionNameLike() !== null) {

The condition $this->getProcessDefinitionNameLike() !== null is always true.

            $extendedQuery->processDefinitionNameLike($this->getProcessDefinitionNameLike());
        }

        if ($extendingQuery->getProcessInstanceBusinessKey() !== null) {

The method getProcessInstanceBusinessKey() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processInstanceBusinessKey($extendingQuery->getProcessInstanceBusinessKey());
        } elseif ($this->getProcessInstanceBusinessKey() !== null) {

The condition $this->getProcessInstanceBusinessKey() !== null is always true.

            $extendedQuery->processInstanceBusinessKey($this->getProcessInstanceBusinessKey());
        }

        if ($extendingQuery->getProcessInstanceBusinessKeyLike() !== null) {

The method getProcessInstanceBusinessKeyLike() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->processInstanceBusinessKeyLike($extendingQuery->getProcessInstanceBusinessKeyLike());
        } elseif ($this->getProcessInstanceBusinessKeyLike() !== null) {

The condition $this->getProcessInstanceBusinessKeyLike() !== null is always true.

            $extendedQuery->processInstanceBusinessKeyLike($this->getProcessInstanceBusinessKeyLike());
        }

        if ($extendingQuery->getDueDate() !== null) {

The method getDueDate() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->dueDate($extendingQuery->getDueDate());
        } elseif ($this->getDueDate() !== null) {

The condition $this->getDueDate() !== null is always true.

            $extendedQuery->dueDate($this->getDueDate());
        }

        if ($extendingQuery->getDueBefore() !== null) {

The method getDueBefore() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->dueBefore($extendingQuery->getDueBefore());
        } elseif ($this->getDueBefore() !== null) {

The condition $this->getDueBefore() !== null is always true.

            $extendedQuery->dueBefore($this->getDueBefore());
        }

        if ($extendingQuery->getDueAfter() !== null) {

The method getDueAfter() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->dueAfter($extendingQuery->getDueAfter());
        } elseif ($this->getDueAfter() !== null) {

The condition $this->getDueAfter() !== null is always true.

            $extendedQuery->dueAfter($this->getDueAfter());
        }

        if ($extendingQuery->isWithoutDueDate() || $this->isWithoutDueDate()) {

The method isWithoutDueDate() does not exist on Jabe\Task\TaskQueryInterface. Did you maybe mean withoutDueDate()?

            $extendedQuery->withoutDueDate();
        }

        if ($extendingQuery->getFollowUpDate() !== null) {

The method getFollowUpDate() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->followUpDate($extendingQuery->getFollowUpDate());
        } elseif ($this->getFollowUpDate() !== null) {

The condition $this->getFollowUpDate() !== null is always true.

            $extendedQuery->followUpDate($this->getFollowUpDate());
        }

        if ($extendingQuery->getFollowUpBefore() !== null) {

The method getFollowUpBefore() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->followUpBefore($extendingQuery->getFollowUpBefore());
        } elseif ($this->getFollowUpBefore() !== null) {

The condition $this->getFollowUpBefore() !== null is always true.

            $extendedQuery->followUpBefore($this->getFollowUpBefore());
        }

        if ($extendingQuery->getFollowUpAfter() !== null) {

The method getFollowUpAfter() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->followUpAfter($extendingQuery->getFollowUpAfter());
        } elseif ($this->getFollowUpAfter() !== null) {

The condition $this->getFollowUpAfter() !== null is always true.

            $extendedQuery->followUpAfter($this->getFollowUpAfter());
        }

        if ($extendingQuery->isFollowUpNullAccepted() || $this->isFollowUpNullAccepted()) {

The method isFollowUpNullAccepted() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->setFollowUpNullAccepted(true);
        }

        if ($extendingQuery->isExcludeSubtasks() || $this->isExcludeSubtasks()) {

The method isExcludeSubtasks() does not exist on Jabe\Task\TaskQueryInterface. Did you maybe mean excludeSubtasks()?

            $extendedQuery->excludeSubtasks();
        }

        if ($extendingQuery->getSuspensionState() !== null) {

The method getSuspensionState() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            if ($extendingQuery->getSuspensionState() == SuspensionState::active()) {
                $extendedQuery->active();
            } elseif ($extendingQuery->getSuspensionState() == SuspensionState::suspended()) {
                $extendedQuery->suspended();
            }
        } elseif ($this->getSuspensionState() !== null) {

The condition $this->getSuspensionState() !== null is always true.

            if ($this->getSuspensionState() == SuspensionState::active()) {

The condition $this->getSuspensionState() == Jabe\Impl\Persistence\Entity\SuspensionState::active() is always false.

                $extendedQuery->active();
            } elseif ($this->getSuspensionState() == SuspensionState::suspended()) {

The condition $this->getSuspensionState() == Jabe\Impl\Persistence\Entity\SuspensionState::suspended() is always false.

                $extendedQuery->suspended();
            }
        }

        /*if ($extendingQuery->getCaseInstanceId() !== null) {
          $extendedQuery.caseInstanceId($extendingQuery->getCaseInstanceId());
        }
        elseif ($this->getCaseInstanceId() !== null) {
          $extendedQuery.caseInstanceId($this->getCaseInstanceId());
        }

        if ($extendingQuery->getCaseInstanceBusinessKey() !== null) {
          $extendedQuery.caseInstanceBusinessKey($extendingQuery->getCaseInstanceBusinessKey());
        }
        elseif ($this->getCaseInstanceBusinessKey() !== null) {
          $extendedQuery.caseInstanceBusinessKey($this->getCaseInstanceBusinessKey());
        }

        if (extendingQuery->getCaseInstanceBusinessKeyLike() !== null) {
          extendedQuery.caseInstanceBusinessKeyLike(extendingQuery->getCaseInstanceBusinessKeyLike());
        }
        elseif ($this->getCaseInstanceBusinessKeyLike() !== null) {
          extendedQuery.caseInstanceBusinessKeyLike($this->getCaseInstanceBusinessKeyLike());
        }

        if (extendingQuery->getCaseExecutionId() !== null) {
          extendedQuery.caseExecutionId(extendingQuery->getCaseExecutionId());
        }
        elseif ($this->getCaseExecutionId() !== null) {
          extendedQuery.caseExecutionId($this->getCaseExecutionId());
        }

        if (extendingQuery->getCaseDefinitionId() !== null) {
          extendedQuery.caseDefinitionId(extendingQuery->getCaseDefinitionId());
        }
        elseif ($this->getCaseDefinitionId() !== null) {
          extendedQuery.caseDefinitionId($this->getCaseDefinitionId());
        }

        if (extendingQuery->getCaseDefinitionKey() !== null) {
          extendedQuery.caseDefinitionKey(extendingQuery->getCaseDefinitionKey());
        }
        elseif ($this->getCaseDefinitionKey() !== null) {
          extendedQuery.caseDefinitionKey($this->getCaseDefinitionKey());
        }

        if (extendingQuery->getCaseDefinitionName() !== null) {
          extendedQuery.caseDefinitionName(extendingQuery->getCaseDefinitionName());
        }
        elseif ($this->getCaseDefinitionName() !== null) {
          extendedQuery.caseDefinitionName($this->getCaseDefinitionName());
        }

        if (extendingQuery->getCaseDefinitionNameLike() !== null) {
          extendedQuery.caseDefinitionNameLike(extendingQuery->getCaseDefinitionNameLike());
        }
        elseif ($this->getCaseDefinitionNameLike() !== null) {
          extendedQuery.caseDefinitionNameLike($this->getCaseDefinitionNameLike());
        }*/

        if ($extendingQuery->isInitializeFormKeys() || $this->isInitializeFormKeys()) {

The method isInitializeFormKeys() does not exist on Jabe\Task\TaskQueryInterface. Did you maybe mean initializeFormKeys()?

            $extendedQuery->initializeFormKeys();
        }

        if ($extendingQuery->isTaskNameCaseInsensitive() || $this->isTaskNameCaseInsensitive()) {

The method isTaskNameCaseInsensitive() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->taskNameCaseInsensitive();
        }

        if ($extendingQuery->getTenantIds() !== null) {

The method getTenantIds() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->tenantIdIn($extendingQuery->getTenantIds());
        } elseif ($this->getTenantIds() !== null) {

The condition $this->getTenantIds() !== null is always true.

            $extendedQuery->tenantIdIn($this->getTenantIds());
        }

        if ($extendingQuery->isWithoutTenantId() || $this->isWithoutTenantId()) {

The method isWithoutTenantId() does not exist on Jabe\Task\TaskQueryInterface. Did you maybe mean withoutTenantId()?

            $extendedQuery->withoutTenantId();
        }

        // merge variables
        $this->mergeVariables($extendedQuery, $extendingQuery);

        // merge expressions
        $this->mergeExpressions($extendedQuery, $extendingQuery);

        // include taskAssigned tasks has to be set after expression as it asserts on already set
        // candidate properties which could be expressions
        if ($extendingQuery->isIncludeAssignedTasks() || $this->isIncludeAssignedTasks()) {

The method isIncludeAssignedTasks() does not exist on Jabe\Task\TaskQueryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Task\TaskQueryInterface.

            $extendedQuery->includeAssignedTasks();
        }

        $this->mergeOrdering($extendedQuery, $extendingQuery);

        $extendedQuery->queries = [$extendedQuery];

        if (count($this->queries) > 1) {
            unset($this->queries[0]);
            $extendedQuery->queries = array_merge($extendedQuery->queries, $this->queries);
        }

        if (count($extendingQuery->queries) > 1) {

Accessing queries on the interface Jabe\Task\TaskQueryInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            unset($extendingQuery->queries[0]);
            $extendedQuery->queries = array_merge($extendedQuery->queries, $extendingQuery->queries);
        }

        return $extendedQuery;
    }