Jabe\Impl\HistoricProcessInstanceQueryImpl

Complexity

Total Complexity

145

Size/Duplication

Total Lines	843
Duplicated Lines	0 %

Importance

Changes

0

120 Methods

Rating	Name	Duplication	Size	Complexity
A	isWithIncidents()	0	3	1
A	processInstanceIds()	0	5	1
A	processDefinitionKeyIn()	0	5	1
A	subProcessInstanceId()	0	4	1
A	getProcessKeyNotIn()	0	3	1
A	getStartedBy()	0	3	1
A	incidentMessageLike()	0	5	1
A	getStartDateOnEnd()	0	3	1
A	processDefinitionNameLike()	0	4	1
A	getFinishDateOnEnd()	0	3	1
A	isRootProcessInstances()	0	3	1
A	executedJobBefore()	0	4	1
A	executeCount()	0	7	1
A	isOpen()	0	3	1
A	processInstanceBusinessKey()	0	4	1
A	executedActivityBefore()	0	4	1
A	processDefinitionKeyNotIn()	0	6	1
A	getExecutedActivityBefore()	0	3	1
A	startedBefore()	0	4	1
A	orderByTenantId()	0	6	2
A	getSuperProcessInstanceId()	0	3	1
A	incidentType()	0	5	1
A	getFinishDateOnBegin()	0	3	1
A	getFinishedAfter()	0	3	1
A	orderByProcessDefinitionKey()	0	6	2
A	getFinishedBefore()	0	3	1
A	finished()	0	4	1
A	executedActivityIdIn()	0	6	1
B	hasExcludingConditions()	0	8	7
A	startedAfter()	0	4	1
A	getBusinessKeyIn()	0	3	1
A	getProcessDefinitionId()	0	3	1
A	getProcessDefinitionName()	0	3	1
A	endOr()	0	6	3
A	executeList()	0	7	1
A	processDefinitionId()	0	4	1
A	startDateOn()	0	6	1
A	getExecutedJobBefore()	0	3	1
A	getStartDateBy()	0	3	1
A	processInstanceBusinessKeyLike()	0	4	1
A	getProcessDefinitionKey()	0	3	1
A	getProcessDefinitionNameLike()	0	3	1
A	calculateMidnight()	0	5	1
A	incidentStatus()	0	4	1
A	getProcessInstanceId()	0	3	1
A	incidentMessage()	0	5	1
A	getIncidentType()	0	3	1
A	startDateBy()	0	4	1
A	getProcessDefinitionKeys()	0	3	1
A	getBusinessKey()	0	3	1
A	finishedAfter()	0	5	1
A	getActiveActivityIds()	0	3	1
A	getExecutedJobAfter()	0	3	1
A	withoutTenantId()	0	5	1
A	suspended()	0	5	1
A	getSubProcessInstanceId()	0	3	1
A	getStartedBefore()	0	3	1
A	getProcessDefinitionIdLike()	0	3	1
A	isFinished()	0	3	1
A	getFinishDateBy()	0	3	1
A	getStartDateOnBegin()	0	3	1
A	finishedBefore()	0	5	1
A	getQueries()	0	3	1
A	orderByProcessDefinitionId()	0	6	2
A	internallyTerminated()	0	5	1
A	tenantIdIn()	0	6	1
A	processInstanceBusinessKeyIn()	0	4	1
A	superProcessInstanceId()	0	7	2
A	setOrQueryActive()	0	3	1
A	isUnfinished()	0	3	1
A	startedBy()	0	4	1
A	orderByProcessInstanceBusinessKey()	0	6	2
A	active()	0	5	1
A	or()	0	10	2
A	getState()	0	3	1
A	processDefinitionName()	0	4	1
A	isTenantIdSet()	0	3	1
A	unfinished()	0	4	1
A	executeDeploymentIdMappingsList()	0	7	1
A	executedJobAfter()	0	4	1
A	completed()	0	5	1
A	setSuperProcessInstanceId()	0	3	1
A	withRootIncidents()	0	4	1
A	getStartDateOn()	0	3	1
A	orderByProcessInstanceEndTime()	0	6	2
A	getQueryVariableValues()	0	3	1
A	getExecutedActivityIds()	0	3	1
A	executedActivityAfter()	0	4	1
A	orderByProcessInstanceStartTime()	0	6	2
A	processInstanceId()	0	4	1
A	getProcessInstanceIds()	0	3	1
A	getBusinessKeyLike()	0	3	1
A	getTenantIds()	0	3	1
A	isOrQueryActive()	0	3	1
A	executeIdsList()	0	7	1
A	orderByProcessDefinitionName()	0	6	2
A	rootProcessInstances()	0	10	2
A	processDefinitionKey()	0	4	1
A	orderByProcessInstanceId()	0	6	2
A	finishDateBy()	0	4	1
A	addOrQuery()	0	4	1
A	calculateBeforeMidnight()	0	3	1
A	getIncidentMessageLike()	0	3	1
A	activeActivityIdIn()	0	6	1
A	getQueryVariableNameToValuesMap()	0	3	1
A	orderByProcessDefinitionVersion()	0	6	2
A	addVariable()	0	7	2
A	getIncidentMessage()	0	3	1
A	getExecutedActivityAfter()	0	3	1
A	isWithRootIncidents()	0	3	1
A	getIncidentStatus()	0	3	1
A	getStartedAfter()	0	3	1
A	getFinishDateOn()	0	3	1
A	finishDateOn()	0	6	1
A	__construct()	0	4	1
A	getIsTenantIdSet()	0	3	1
A	externallyTerminated()	0	5	1
A	orderByProcessInstanceDuration()	0	6	2
A	ensureVariablesInitialized()	0	12	4
A	withIncidents()	0	4	1

<?php

namespace Jabe\Impl;

use Jabe\{
    BadUserRequestException,
    ProcessEngineException
};
use Jabe\History\{
    HistoricProcessInstanceInterface,
    HistoricProcessInstanceQueryInterface
};
use Jabe\Impl\Cfg\ProcessEngineConfigurationImpl;
use Jabe\Impl\Context\Context;
use Jabe\Impl\Interceptor\{
    CommandContext,
    CommandExecutorInterface
};
use Jabe\Impl\Util\{
    CompareUtil,
    EnsureUtil//,
    //ImmutablePair
};

class HistoricProcessInstanceQueryImpl extends AbstractVariableQueryImpl implements HistoricProcessInstanceQueryInterface
{
    protected $processInstanceId;
    protected $processDefinitionId;
    protected $processDefinitionName;
    protected $processDefinitionNameLike;
    protected $businessKey;
    protected $businessKeyIn = [];
    protected $businessKeyLike;
    protected $finished = false;
    protected $unfinished = false;
    protected $withIncidents = false;
    protected $withRootIncidents = false;
    protected $incidentType;
    protected $incidentStatus;
    protected $incidentMessage;
    protected $incidentMessageLike;
    protected $startedBy;
    protected $isRootProcessInstances;
    protected $superProcessInstanceId;
    protected $subProcessInstanceId;
    //protected $superCaseInstanceId;
    //protected $subCaseInstanceId;
    protected $processKeyNotIn = [];
    protected $startedBefore;
    protected $startedAfter;
    protected $finishedBefore;
    protected $finishedAfter;
    protected $executedActivityAfter;
    protected $executedActivityBefore;
    protected $executedJobAfter;
    protected $executedJobBefore;
    protected $processDefinitionKey;
    protected $processDefinitionKeys = [];
    protected $processInstanceIds = [];
    protected $tenantIds = [];
    protected $isTenantIdSet;
    protected $executedActivityIds = [];
    protected $activeActivityIds = [];
    protected $state;
    protected $caseInstanceId;
    protected $queries = [];
    protected $isOrQueryActive = false;
    protected $queryVariableNameToValuesMap = [];

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

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

    public function processInstanceIds(array $processInstanceIds): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNotEmpty("Set of process instance ids", "processInstanceIds", $processInstanceIds);
        $this->processInstanceIds = $processInstanceIds;
        return $this;
    }

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

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

    public function processDefinitionKeyIn(array $processDefinitionKeys): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull("processDefinitionKeys", "processDefinitionKeys", $processDefinitionKeys);
        $this->processDefinitionKeys = $processDefinitionKeys;
        return $this;
    }

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

    public function processDefinitionNameLike(string $nameLike): HistoricProcessInstanceQueryInterface
    {
        $this->processDefinitionNameLike = $nameLike;
        return $this;
    }

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

    public function processInstanceBusinessKeyIn(array $businessKeyIn): HistoricProcessInstanceQueryInterface
    {
        $this->businessKeyIn = $businessKeyIn;
        return $this;
    }

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

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

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

    public function withIncidents(): HistoricProcessInstanceQueryInterface
    {
        $this->withIncidents = true;
        return $this;
    }

    public function withRootIncidents(): HistoricProcessInstanceQueryInterface
    {
        $this->withRootIncidents = true;
        return $this;
    }

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

    public function incidentStatus(string $status): HistoricProcessInstanceQueryInterface
    {
        $this->incidentStatus = $status;
        return $this;
    }

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

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

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

    public function processDefinitionKeyNotIn(array $processDefinitionKeys): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNotContainsNull("processDefinitionKeys cannot contain null", "processDefinitionKeys", $processDefinitionKeys);
        EnsureUtil::ensureNotContainsEmptyString("processDefinitionKey cannot contain empty string", "processDefinitionKeys", $processDefinitionKeys);
        $this->processKeyNotIn = $processDefinitionKeys;
        return $this;
    }

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

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

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

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

    public function rootProcessInstances(): HistoricProcessInstanceQueryInterface
    {
        if ($this->superProcessInstanceId !== null) {
            throw new BadUserRequestException("Invalid query usage: cannot set both rootProcessInstances and superProcessInstanceId");
        }
        /*if (superCaseInstanceId !== null) {
            throw new BadUserRequestException("Invalid query usage: cannot set both rootProcessInstances and superCaseInstanceId");
        }*/
        $this->isRootProcessInstances = true;
        return $this;
    }

    public function superProcessInstanceId(string $superProcessInstanceId): HistoricProcessInstanceQueryInterface
    {
        if ($this->isRootProcessInstances) {
            throw new BadUserRequestException("Invalid query usage: cannot set both rootProcessInstances and superProcessInstanceId");
        }
        $this->superProcessInstanceId = $superProcessInstanceId;
        return $this;
    }

    public function subProcessInstanceId(string $subProcessInstanceId): HistoricProcessInstanceQueryInterface
    {
        $this->subProcessInstanceId = $subProcessInstanceId;
        return $this;
    }

    /*public function superCaseInstanceId(string $superCaseInstanceId): HistoricProcessInstanceQueryInterface
    {
        if ($this->isRootProcessInstances) {
            throw new BadUserRequestException("Invalid query usage: cannot set both rootProcessInstances and superCaseInstanceId");
        }
        $this->superCaseInstanceId = superCaseInstanceId;
        return $this;
    }

    public HistoricProcessInstanceQueryInterface subCaseInstanceId(string $subCaseInstanceId) {
        $this->subCaseInstanceId = subCaseInstanceId;
        return $this;
    }

    public HistoricProcessInstanceQueryInterface caseInstanceId(string $caseInstanceId) {
        $this->caseInstanceId = caseInstanceId;
        return $this;
    }*/

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

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

    protected function hasExcludingConditions(): bool
    {
        return parent::hasExcludingConditions()
            || ($this->finished && $this->unfinished)
            || CompareUtil::areNotInAscendingOrder($this->startedAfter, $this->startedBefore)
            || CompareUtil::areNotInAscendingOrder($this->finishedAfter, $this->finishedBefore)
            || CompareUtil::elementIsContainedInList($this->processDefinitionKey, $this->processKeyNotIn)
            || CompareUtil::elementIsNotContainedInList($this->processInstanceId, $this->processInstanceIds);
    }

    public function orderByProcessInstanceBusinessKey(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessInstanceBusinessKey() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::businessKey());
    }

    public function orderByProcessInstanceDuration(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessInstanceDuration() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::duration());
    }

    public function orderByProcessInstanceStartTime(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessInstanceStartTime() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::startTime());
    }

    public function orderByProcessInstanceEndTime(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessInstanceEndTime() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::endTime());
    }

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

    public function orderByProcessDefinitionKey(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessDefinitionKey() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::processDefinitionKey());
    }

    public function orderByProcessDefinitionName(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessDefinitionName() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::processDefinitionName());
    }

    public function orderByProcessDefinitionVersion(): HistoricProcessInstanceQueryInterface
    {
        if ($this->isOrQueryActive) {
            throw new ProcessEngineException("Invalid query usage: cannot set orderByProcessDefinitionVersion() within 'or' query");
        }
        return $this->orderBy(HistoricProcessInstanceQueryProperty::processDefinitionVersion());
    }

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

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

    public function executeCount(CommandContext $commandContext): int
    {
        $this->checkQueryOk();
        EnsureUtil::ensureVariablesInitialized();

The method ensureVariablesInitialized() does not exist on Jabe\Impl\Util\EnsureUtil.

        return $commandContext
            ->getHistoricProcessInstanceManager()
            ->findHistoricProcessInstanceCountByQueryCriteria($this);
    }

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

    public function executeIdsList(CommandContext $commandContext): array
    {
        $this->checkQueryOk();
        EnsureUtil::ensureVariablesInitialized();
        return $commandContext
            ->getHistoricProcessInstanceManager()
            ->findHistoricProcessInstanceIds($this);
    }

    public function executeDeploymentIdMappingsList(CommandContext $commandContext): array
    {
        $this->checkQueryOk();
        EnsureUtil::ensureVariablesInitialized();
        return $commandContext
            ->getHistoricProcessInstanceManager()
            ->findDeploymentIdMappingsByQueryCriteria($this);
    }

    public function getQueryVariableValues(): array
    {
        return array_values($this->queryVariableNameToValuesMap);
    }

    public function getQueryVariableNameToValuesMap(): array
    {
        return $this->queryVariableNameToValuesMap;
    }

    protected function ensureVariablesInitialized(): void
    {
        parent::ensureVariablesInitialized();

        if (!empty($this->queries)) {
            $processEngineConfiguration = Context::getProcessEngineConfiguration();
            $variableSerializers = $processEngineConfiguration->getVariableSerializers();

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

            $dbType = $processEngineConfiguration->getDatabaseType();

            foreach ($this->queries as $orQuery) {
                foreach ($orQuery->getQueryVariableValues() as $var) {
                    $var->initialize($variableSerializers, $dbType);
                }
            }
        }
    }

    protected function addVariable(string $name, $value, string $operator, bool $processInstanceScope): void
    {
        $queryVariableValue = $this->createQueryVariableValue($name, $value, $operator, $processInstanceScope);
        if (!array_key_exists($name, $this->queryVariableNameToValuesMap)) {
            $this->queryVariableNameToValuesMap[$name] = [$queryVariableValue];
        } else {
            $this->queryVariableNameToValuesMap[$name][] = $queryVariableValue;
        }
    }

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

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

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

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

    public function getActiveActivityIds(): array
    {
        return $this->activeActivityIds;
    }

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

    public function getBusinessKeyIn(): array
    {
        return $this->businessKeyIn;
    }

    public function getBusinessKeyLike(): string
    {
        return $this->businessKeyLike;
    }

    public function getExecutedActivityIds(): array
    {
        return $this->executedActivityIds;
    }

    public function getExecutedActivityAfter(): string
    {
        return $this->executedActivityAfter;
    }

    public function getExecutedActivityBefore(): string
    {
        return $this->executedActivityBefore;
    }

    public function getExecutedJobAfter(): string
    {
        return $this->executedJobAfter;
    }

    public function getExecutedJobBefore(): string
    {
        return $this->executedJobBefore;
    }

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

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

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

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

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

    public function getProcessDefinitionKeys(): array
    {
        return $this->processDefinitionKeys;
    }

    public function getProcessDefinitionIdLike(): string
    {
        return $this->processDefinitionKey . ":%:%";
    }

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

    public function getProcessDefinitionNameLike(): string
    {
        return $this->processDefinitionNameLike;
    }

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

    public function getProcessInstanceIds(): array
    {
        return $this->processInstanceIds;
    }

    public function getStartedBy(): string
    {
        return $this->startedBy;
    }

    public function getSuperProcessInstanceId(): string
    {
        return $this->superProcessInstanceId;
    }

    public function setSuperProcessInstanceId(string $superProcessInstanceId): void
    {
        $this->superProcessInstanceId = $superProcessInstanceId;
    }

    public function getProcessKeyNotIn(): array
    {
        return $this->processKeyNotIn;
    }

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

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

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

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

    /*public String getCaseInstanceId() {
        return caseInstanceId;
    }*/

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

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

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

    public function getIncidentStatus(): string
    {
        return $this->incidentStatus;
    }

    public function getState(): string
    {
        return $this->state;
    }

    public function getFinishDateBy(): string
    {
        return $this->finishDateBy;
    }

    public function getStartDateBy(): string
    {
        return $this->startDateBy;
    }

    public function getStartDateOn(): string
    {
        return $this->startDateOn;
    }

    public function getStartDateOnBegin(): string
    {
        return $this->startDateOnBegin;
    }

    public function getStartDateOnEnd(): string
    {
        return $this->startDateOnEnd;
    }

    public function getFinishDateOn(): string
    {
        return $this->finishDateOn;
    }

    public function getFinishDateOnBegin(): string
    {
        return $this->finishDateOnBegin;
    }

    public function getFinishDateOnEnd(): string
    {
        return $this->finishDateOnEnd;
    }

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

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

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

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

    protected $startDateBy;
    protected $startDateOn;
    protected $finishDateBy;
    protected $finishDateOn;
    protected $startDateOnBegin;
    protected $startDateOnEnd;
    protected $finishDateOnBegin;
    protected $finishDateOnEnd;

    public function startDateBy(string $date): HistoricProcessInstanceQueryInterface
    {
        $this->startDateBy = $this->calculateMidnight($date);
        return $this;
    }

    public function startDateOn(string $date): HistoricProcessInstanceQueryInterface
    {
        $this->startDateOn = $date;
        $this->startDateOnBegin = $this->calculateMidnight($date);
        $this->startDateOnEnd = $this->calculateBeforeMidnight($date);
        return $this;
    }

    public function finishDateBy(string $date): HistoricProcessInstanceQueryInterface
    {
        $this->finishDateBy = $this->calculateBeforeMidnight($date);
        return $this;
    }

    public function finishDateOn(string $date): HistoricProcessInstanceQueryInterface
    {
        $this->finishDateOn = $date;
        $this->finishDateOnBegin = $this->calculateMidnight($date);
        $this->finishDateOnEnd = $this->calculateBeforeMidnight($date);
        return $this;
    }

    private function calculateBeforeMidnight(string $date): string
    {
        return (new \DateTime())->setTimestamp(strtotime("+1 day -1 second", strtotime($date)))->format('c');
    }

    private function calculateMidnight(string $date): string
    {
        $date = new \DateTime($date);
        $date->setTime(0, 0, 0, 0);
        return $date->format('c');
    }

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

    public function getSubProcessInstanceId(): string
    {
        return $this->subProcessInstanceId;
    }

    /*public String getSuperCaseInstanceId() {
        return superCaseInstanceId;
    }

    public String getSubCaseInstanceId() {
        return subCaseInstanceId;
    }*/

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

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

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

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

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

    public function executedActivityIdIn(array $ids): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull("activity ids", "ids", $ids);
        EnsureUtil::ensureNotContainsNull("ids cannot contain null", "ids", $ids);
        $this->executedActivityIds = $ids;
        return $this;
    }

    public function activeActivityIdIn(array $ids): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNotNull("activity ids", "ids", $ids);
        EnsureUtil::ensureNotContainsNull("ids cannot contain null", "ids", $ids);
        $this->activeActivityIds = $ids;
        return $this;
    }

    public function active(): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNull("Already querying for historic process instance with another state", "state", $this->state);

The method ensureNull() does not exist on Jabe\Impl\Util\EnsureUtil. Did you maybe mean ensureNotNull()?

        $state = HistoricProcessInstanceInterface::STATE_ACTIVE;

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

        return $this;
    }

    public function suspended(): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNull("Already querying for historic process instance with another state", "state", $this->state);
        $this->state = HistoricProcessInstanceInterface::STATE_SUSPENDED;
        return $this;
    }

    public function completed(): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNull("Already querying for historic process instance with another state", "state", $this->state);
        $this->state = HistoricProcessInstanceInterface::STATE_COMPLETED;
        return $this;
    }

    public function externallyTerminated(): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNull("Already querying for historic process instance with another state", "state", $this->state);
        $this->state = HistoricProcessInstanceInterface::STATE_EXTERNALLY_TERMINATED;
        return $this;
    }

    public function internallyTerminated(): HistoricProcessInstanceQueryInterface
    {
        EnsureUtil::ensureNull("Already querying for historic process instance with another state", "state", $this->state);
        $this->state = HistoricProcessInstanceInterface::STATE_INTERNALLY_TERMINATED;
        return $this;
    }

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

    public function endOr(): HistoricProcessInstanceQueryInterface
    {
        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];
    }
}