Jabe\Impl\History\Handler\DefaultHistoryEventProducer

Complexity

Total Complexity

183

Size/Duplication

Total Lines	1345
Duplicated Lines	0 %

Importance

Changes

0

81 Methods

Rating	Name	Duplication	Size	Complexity
A	newIdentityLinkEventEntity()	0	3	1
A	getHistoricBatchByJobId()	0	5	1
A	createBatchEvent()	0	25	3
A	createHistoricJobLogSuccessfulEvt()	0	3	1
A	createHistoricIdentityLinkEvt()	0	7	1
A	getHistoricBatchById()	0	5	1
A	createHistoricVariableUpdateEvt()	0	3	1
A	createActivityInstanceUpdateEvt()	0	17	2
A	createHistoricIncidentResolveEvt()	0	3	1
A	loadActivityInstanceEventEntity()	0	3	1
A	addRemovalTimeToHistoricDecisions()	0	5	1
A	createHistoricIncidentUpdateEvt()	0	3	1
A	isRootProcessInstance()	0	3	1
A	createFormPropertyUpdateEvt()	0	40	4
A	createTaskInstanceMigrateEvt()	0	9	1
A	createHistoricIdentityLinkAddEvent()	0	3	1
A	createProcessInstanceEndEvt()	0	43	6
A	initHistoricExternalTaskLog()	0	31	3
A	createHistoricExternalTaskLogCreatedEvt()	0	3	1
B	initHistoricIdentityLinkEvent()	0	52	7
A	createHistoricIdentityLinkDeleteEvent()	0	3	1
A	createProcessInstanceMigrateEvt()	0	17	2
A	newHistoricJobLogEntity()	0	3	1
A	createActivityInstanceStartEvt()	0	16	1
A	loadIncidentEvent()	0	3	1
A	createHistoricJobLogFailedEvt()	0	23	3
A	newIncidentEventEntity()	0	3	1
A	initActivityInstanceEventWithIds()	0	36	4
A	getHistoricRootProcessInstance()	0	5	1
A	initSequenceCounter()	0	6	3
A	createHistoricVariableMigrateEvt()	0	3	1
A	newTaskInstanceEventEntity()	0	3	1
A	createHistoricVariableDeleteEvt()	0	3	1
A	initUserOperationLogEvent()	0	37	2
A	newVariableUpdateEventEntity()	0	3	1
A	createHistoricIncidentDeleteEvt()	0	3	1
A	loadProcessInstanceEventEntity()	0	3	1
B	initHistoricIncidentEvent()	0	57	9
A	initActivityInstanceEventWithMigration()	0	23	2
A	initTaskInstanceEvent()	0	58	4
A	createProcessInstanceStartEvt()	0	35	4
A	addRemovalTimeToHistoricProcessInstances()	0	5	1
A	addRemovalTimeToHistoricJobLog()	0	7	2
A	findProcessDefinitionById()	0	6	1
A	createBatchStartEvent()	0	9	2
A	determineEndState()	0	10	4
A	newActivityInstanceEventEntity()	0	3	1
A	createActivityInstanceEndEvt()	0	17	2
A	initActivityInstanceEvent()	0	27	5
A	createProcessInstanceUpdateEvt()	0	17	2
A	initProcessInstanceEvent()	0	34	3
A	initHistoricVariableUpdateEvt()	0	51	5
C	createHistoricVariableEvent()	0	74	15
A	newProcessInstanceEventEntity()	0	3	1
A	createHistoricIncidentEvt()	0	12	3
A	createHistoricIncidentCreateEvt()	0	3	1
A	provideRemovalTime()	0	16	6
A	addRemovalTimeToHistoricIncidents()	0	7	2
A	createUserOperationLogEvents()	0	18	3
A	createHistoricVariableCreateEvt()	0	3	1
A	isHistoryRemovalTimeStrategyEnd()	0	3	1
A	createBatchEndEvent()	0	12	2
A	loadTaskInstanceEvent()	0	3	1
A	createHistoricExternalTaskLogSuccessfulEvt()	0	3	1
A	createHistoricJobLogCreateEvt()	0	3	1
C	initHistoricJobLogEvent()	0	80	14
A	loadBatchEntity()	0	3	1
A	createHistoricJobLogDeleteEvt()	0	3	1
A	createHistoricExternalTaskLogDeletedEvt()	0	3	1
A	newHistoricFormPropertyEvent()	0	3	1
A	getHistoryRemovalTimeStrategy()	0	4	1
A	createTaskInstanceUpdateEvt()	0	10	1
A	newBatchEventEntity()	0	3	1
A	calculateRemovalTime()	0	15	3
A	createTaskInstanceCompleteEvt()	0	18	2
A	createHistoricExternalTaskLogFailedEvt()	0	9	2
A	createActivityInstanceMigrateEvt()	0	10	1
A	createHistoricJobLogEvt()	0	5	1
A	isHistoryRemovalTimeStrategyStart()	0	3	1
A	createTaskInstanceCreateEvt()	0	12	1
A	createHistoricIncidentMigrateEvt()	0	3	1

<?php

namespace Jabe\Impl\History\Handler;

use Jabe\{
    ProcessEngineException,
    ProcessEngineConfiguration
};
use Jabe\Batch\BatchInterface;
use Jabe\Delegate\{
    DelegateExecutionInterface,
    DelegateTaskInterface,
    VariableScopeInterface
};
use Jabe\ExternalTask\ExternalTaskInterface;
use Jabe\History\{
    ExternalTaskStateImpl,
    ExternalTaskStateInterface,
    HistoricProcessInstanceInterface,
    IncidentStateImpl,
    JobStateImpl
};
use Jabe\Impl\ProcessEngineLogger;
use Jabe\Impl\Batch\BatchEntity;
use Jabe\Impl\Batch\History\HistoricBatchEntity;
use Jabe\Impl\Cfg\{
    ConfigurationLogger,
    IdGenerator
};
use Jabe\Impl\Context\Context;
use Jabe\Impl\History\DefaultHistoryRemovalTimeProvider;
use Jabe\Impl\History\Event\{
    HistoricActivityInstanceEventEntity,
    HistoricExternalTaskLogEntity,
    HistoricFormPropertyEventEntity,
    HistoricIdentityLinkLogEventEntity,
    HistoricIncidentEventEntity,
    HistoricProcessInstanceEventEntity,
    HistoricTaskInstanceEventEntity,
    HistoricVariableUpdateEventEntity,
    HistoryEvent,
    HistoryEventTypeInterface,
    HistoryEventTypes,
    UserOperationLogEntryEventEntity
};
use Jabe\Impl\JobExecutor\HistoryCleanup\HistoryCleanupJobHandler;
use Jabe\Impl\Migration\Instance\MigratingActivityInstance;
use Jabe\Impl\OpLog\{
    UserOperationLogContext,
    UserOperationLogContextEntry
};
use Jabe\Impl\Persistence\Entity\{
    ByteArrayEntity,
    ExecutionEntity,
    ExternalTaskEntity,
    HistoricJobLogEventEntity,
    IncidentEntity,
    JobEntity,
    ProcessDefinitionEntity,
    PropertyChange,
    TaskEntity,
    VariableInstanceEntity
};
use Jabe\Impl\Pvm\PvmScopeInterface;
use Jabe\Impl\Pvm\Runtime\CompensationBehavior;
use Jabe\Impl\Util\{
    ClockUtil,
    ExceptionUtil,
    ParseUtil,
    StringUtil
};
use Jabe\Repository\{
    ProcessDefinitionInterface,
    ResourceTypes
};
use Jabe\Runtime\{
    IncidentInterface,
    JobInterface
};
use Jabe\Task\IdentityLinkInterface;

class DefaultHistoryEventProducer implements HistoryEventProducerInterface
{
    //protected final static ConfigurationLogger LOG = ProcessEngineLogger.CONFIG_LOGGER;

    protected function initActivityInstanceEvent(
        HistoricActivityInstanceEventEntity $evt,
        ExecutionEntity $instance,
        HistoryEventTypeInterface $eventType
    ): void {
        $eventSource = $instance->getActivity();
        if ($eventSource == null) {
            $eventSource = $instance->getEventSource();
        }
        $activityInstanceId = $instance->getActivityInstanceId();

        $parentActivityInstanceId = null;
        $parentExecution = $instance->getParent();

        if ($parentExecution !== null && CompensationBehavior::isCompensationThrowing($parentExecution) && $instance->getActivity() !== null) {
            $parentActivityInstanceId = CompensationBehavior::getParentActivityInstanceId($instance);
        } else {
            $parentActivityInstanceId = $instance->getParentActivityInstanceId();
        }

        $this->initActivityInstanceEventWithIds(
            $evt,
            $instance,
            $eventSource,
            $activityInstanceId,

It seems like $activityInstanceId can also be of type null; however, parameter $activityInstanceId of Jabe\Impl\History\Handler\DefaultHistoryEventProducer::initActivityInstanceEventWithIds() does only seem to accept string, maybe add an additional type check?

            $parentActivityInstanceId,

It seems like $parentActivityInstanceId can also be of type null; however, parameter $parentActivityInstanceId of Jabe\Impl\History\Handler\DefaultHistoryEventProducer::initActivityInstanceEventWithIds() does only seem to accept string, maybe add an additional type check?

            $eventType
        );
    }

    protected function initActivityInstanceEventWithMigration(
        HistoricActivityInstanceEventEntity $evt,
        MigratingActivityInstance $migratingActivityInstance,
        HistoryEventTypeInterface $eventType
    ): void {
        $eventSource = $migratingActivityInstance->getTargetScope();
        $activityInstanceId = $migratingActivityInstance->getActivityInstanceId();

        $parentInstance = $migratingActivityInstance->getParent();
        $parentActivityInstanceId = null;
        if ($parentInstance !== null) {
            $parentActivityInstanceId = $parentInstance->getActivityInstanceId();
        }

        $execution = $migratingActivityInstance->resolveRepresentativeExecution();

        $this->initActivityInstanceEventWithIds(
            $evt,
            $execution,
            $eventSource,
            $activityInstanceId,
            $parentActivityInstanceId,
            $eventType
        );
    }

    protected function initActivityInstanceEventWithIds(
        HistoricActivityInstanceEventEntity $evt,
        ExecutionEntity $execution,
        PvmScopeInterface $eventSource,
        string $activityInstanceId,
        string $parentActivityInstanceId,
        HistoryEventTypeInterface $eventType
    ): void {

        $evt->setId($activityInstanceId);
        $evt->setEventType($eventType->getEventName());
        $evt->setActivityInstanceId($activityInstanceId);
        $evt->setParentActivityInstanceId($parentActivityInstanceId);
        $evt->setProcessDefinitionId($execution->getProcessDefinitionId());
        $evt->setProcessInstanceId($execution->getProcessInstanceId());
        $evt->setExecutionId($execution->getId());
        $evt->setTenantId($execution->getTenantId());
        $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

        if ($this->isHistoryRemovalTimeStrategyStart()) {
            $this->provideRemovalTime($evt);
        }

        $definition = $execution->getProcessDefinition();
        if ($definition !== null) {
            $evt->setProcessDefinitionKey($definition->getKey());
        }

        $evt->setActivityId($eventSource->getId());
        $evt->setActivityName($eventSource->getProperty("name"));
        $evt->setActivityType($eventSource->getProperty("type"));

        // update sub process reference
        $subProcessInstance = $execution->getSubProcessInstance();
        if ($subProcessInstance !== null) {
            $evt->setCalledProcessInstanceId($subProcessInstance->getId());
        }

        // update sub case reference
        /*CaseExecutionEntity subCaseInstance = $execution->getSubCaseInstance();
        if (subCaseInstance !== null) {
            $evt->setCalledCaseInstanceId(subCaseInstance->getId());
        }*/
    }

    protected function initProcessInstanceEvent(
        HistoricProcessInstanceEventEntity $evt,
        ExecutionEntity $execution,
        HistoryEventTypeInterface $eventType
    ): void {
        $processDefinitionId = $execution->getProcessDefinitionId();
        $processInstanceId = $execution->getProcessInstanceId();
        $executionId = $execution->getId();
        // the given execution is the process instance!
        //String caseInstanceId = $execution->getCaseInstanceId();
        $tenantId = $execution->getTenantId();

        $definition = $execution->getProcessDefinition();
        $processDefinitionKey = null;
        if ($definition !== null) {
            $processDefinitionKey = $definition->getKey();
        }

        $evt->setId($processInstanceId);
        $evt->setEventType($eventType->getEventName());
        $evt->setProcessDefinitionKey($processDefinitionKey);

It seems like $processDefinitionKey can also be of type null; however, parameter $processDefinitionKey of Jabe\Impl\History\Event\HistoryEvent::setProcessDefinitionKey() does only seem to accept string, maybe add an additional type check?

        $evt->setProcessDefinitionId($processDefinitionId);
        $evt->setProcessInstanceId($processInstanceId);
        $evt->setExecutionId($executionId);
        $evt->setBusinessKey($execution->getProcessBusinessKey());

It seems like $execution->getProcessBusinessKey() can also be of type null; however, parameter $businessKey of Jabe\Impl\History\Event\HistoricProcessInstanceEventEntity::setBusinessKey() does only seem to accept string, maybe add an additional type check?

        //$evt->setCaseInstanceId(caseInstanceId);
        $evt->setTenantId($tenantId);
        $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

        /*if ($execution->getSuperCaseExecution() !== null) {
            $evt->setSuperCaseInstanceId($execution->getSuperCaseExecution()->getCaseInstanceId());
        }*/
        if ($execution->getSuperExecution() !== null) {
            $evt->setSuperProcessInstanceId($execution->getSuperExecution()->getProcessInstanceId());
        }
    }

    protected function initTaskInstanceEvent(
        HistoricTaskInstanceEventEntity $evt,
        TaskEntity $taskEntity,
        HistoryEventTypeInterface $eventType
    ): void {
        $processDefinitionKey = null;
        $definition = $taskEntity->getProcessDefinition();
        if ($definition !== null) {
            $processDefinitionKey = $definition->getKey();
        }

        $processDefinitionId = $taskEntity->getProcessDefinitionId();
        $processInstanceId = $taskEntity->getProcessInstanceId();
        $executionId = $taskEntity->getExecutionId();

        /*String caseDefinitionKey = null;
        CaseDefinitionEntity caseDefinition = $taskEntity->getCaseDefinition();
        if (caseDefinition !== null) {
            caseDefinitionKey = caseDefinition->getKey();
        }

        String caseDefinitionId = $taskEntity->getCaseDefinitionId();
        String caseExecutionId = $taskEntity->getCaseExecutionId();
        String caseInstanceId = $taskEntity->getCaseInstanceId();*/
        $tenantId = $taskEntity->getTenantId();

        $evt->setId($taskEntity->getId());

It seems like $taskEntity->getId() can also be of type null; however, parameter $id of Jabe\Impl\History\Event\HistoryEvent::setId() does only seem to accept string, maybe add an additional type check?

        $evt->setEventType($eventType->getEventName());
        $evt->setTaskId($taskEntity->getId());

It seems like $taskEntity->getId() can also be of type null; however, parameter $taskId of Jabe\Impl\History\Event\HistoricTaskInstanceEventEntity::setTaskId() does only seem to accept string, maybe add an additional type check?

        $evt->setProcessDefinitionKey($processDefinitionKey);

It seems like $processDefinitionKey can also be of type null; however, parameter $processDefinitionKey of Jabe\Impl\History\Event\HistoryEvent::setProcessDefinitionKey() does only seem to accept string, maybe add an additional type check?

        $evt->setProcessDefinitionId($processDefinitionId);
        $evt->setProcessInstanceId($processInstanceId);
        $evt->setExecutionId($executionId);

        /*$evt->setCaseDefinitionKey(caseDefinitionKey);
        $evt->setCaseDefinitionId(caseDefinitionId);
        $evt->setCaseExecutionId(caseExecutionId);
        $evt->setCaseInstanceId(caseInstanceId);*/

        $evt->setAssignee($taskEntity->getAssignee());
        $evt->setDescription($taskEntity->getDescription());
        $evt->setDueDate($taskEntity->getDueDate());
        $evt->setFollowUpDate($taskEntity->getFollowUpDate());
        $evt->setName($taskEntity->getName());
        $evt->setOwner($taskEntity->getOwner());
        $evt->setParentTaskId($taskEntity->getParentTaskId());

It seems like $taskEntity->getParentTaskId() can also be of type null; however, parameter $parentTaskId of Jabe\Impl\History\Event\HistoricTaskInstanceEventEntity::setParentTaskId() does only seem to accept string, maybe add an additional type check?

        $evt->setPriority($taskEntity->getPriority());
        $evt->setTaskDefinitionKey($taskEntity->getTaskDefinitionKey());
        $evt->setTenantId($tenantId);

        $execution = $taskEntity->getExecution();
        if ($execution !== null) {
            $evt->setActivityInstanceId($execution->getActivityInstanceId());

It seems like $execution->getActivityInstanceId() can also be of type null; however, parameter $activityInstanceId of Jabe\Impl\History\Event\HistoricTaskInstanceEventEntity::setActivityInstanceId() does only seem to accept string, maybe add an additional type check?

            $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $this->provideRemovalTime($evt);
            }
        }
    }

    protected function initHistoricVariableUpdateEvt(
        HistoricVariableUpdateEventEntity $evt,
        VariableInstanceEntity $variableInstance,
        HistoryEventTypeInterface $eventType
    ): void {

        // init properties
        $evt->setEventType($eventType->getEventName());
        $evt->setTimestamp(ClockUtil::getCurrentTime()->format('c'));
        $evt->setVariableInstanceId($variableInstance->getId());

It seems like $variableInstance->getId() can also be of type null; however, parameter $variableInstanceId of Jabe\Impl\History\Event\HistoricVariableUpdateEventEntity::setVariableInstanceId() does only seem to accept string, maybe add an additional type check?

        $evt->setProcessInstanceId($variableInstance->getProcessInstanceId());
        $evt->setExecutionId($variableInstance->getExecutionId());
        //$evt->setCaseInstanceId($variableInstance->getCaseInstanceId());
        //$evt->setCaseExecutionId($variableInstance->getCaseExecutionId());
        $evt->setTaskId($variableInstance->getTaskId());
        $evt->setRevision($variableInstance->getRevision());
        $evt->setVariableName($variableInstance->getName());
        $evt->setSerializerName($variableInstance->getSerializerName());
        $evt->setTenantId($variableInstance->getTenantId());
        $evt->setUserOperationId(Context::getCommandContext()->getOperationId());

It seems like Jabe\Impl\Context\Context::getCommandContext()->getOperationId() can also be of type null; however, parameter $userOperationId of Jabe\Impl\History\Event\HistoricDetailEventEntity::setUserOperationId() does only seem to accept string, maybe add an additional type check?

        $execution = $variableInstance->getExecution();
        if ($execution !== null) {
            $definition = $execution->getProcessDefinition();
            if ($definition !== null) {
                $evt->setProcessDefinitionId($definition->getId());
                $evt->setProcessDefinitionKey($definition->getKey());
            }
            $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $this->provideRemovalTime($evt);
            }
        }

        /*CaseExecutionEntity caseExecution = variableInstance->getCaseExecution();
        if (caseExecution !== null) {
            CaseDefinitionEntity definition = (CaseDefinitionEntity) caseExecution->getCaseDefinition();
            if (definition !== null) {
            $evt->setCaseDefinitionId(definition->getId());
            $evt->setCaseDefinitionKey(definition->getKey());
            }
        }*/

        // copy value
        $evt->setTextValue($variableInstance->getTextValue());
        $evt->setTextValue2($variableInstance->getTextValue2());
        $evt->setDoubleValue($variableInstance->getDoubleValue());
        $evt->setLongValue($variableInstance->getLongValue());
        if ($variableInstance->getByteArrayValueId() !== null) {

The condition $variableInstance->getByteArrayValueId() !== null is always true.

            $evt->setByteValue($variableInstance->getByteArrayValue());
        }
    }

    protected function initUserOperationLogEvent(
        UserOperationLogEntryEventEntity $evt,
        UserOperationLogContext $context,
        UserOperationLogContextEntry $contextEntry,
        PropertyChange $propertyChange
    ): void {
        // init properties
        $evt->setDeploymentId($contextEntry->getDeploymentId());
        $evt->setEntityType($contextEntry->getEntityType());
        $evt->setOperationType($contextEntry->getOperationType());
        $evt->setOperationId($context->getOperationId());
        $evt->setUserId($context->getUserId());
        $evt->setProcessDefinitionId($contextEntry->getProcessDefinitionId());
        $evt->setProcessDefinitionKey($contextEntry->getProcessDefinitionKey());
        $evt->setProcessInstanceId($contextEntry->getProcessInstanceId());
        $evt->setExecutionId($contextEntry->getExecutionId());
        $evt->setCaseDefinitionId($contextEntry->getCaseDefinitionId());

The method getCaseDefinitionId() does not exist on Jabe\Impl\OpLog\UserOperationLogContextEntry.

The method setCaseDefinitionId() does not exist on Jabe\Impl\History\Event\UserOperationLogEntryEventEntity.

        //$evt->setCaseInstanceId($contextEntry->getCaseInstanceId());
        $evt->setCaseExecutionId($contextEntry->getCaseExecutionId());

The method setCaseExecutionId() does not exist on Jabe\Impl\History\Event\UserOperationLogEntryEventEntity. Did you maybe mean setExecutionId()?

The method getCaseExecutionId() does not exist on Jabe\Impl\OpLog\UserOperationLogContextEntry. Did you maybe mean getExecutionId()?

        $evt->setTaskId($contextEntry->getTaskId());
        $evt->setJobId($contextEntry->getJobId());
        $evt->setJobDefinitionId($contextEntry->getJobDefinitionId());
        $evt->setBatchId($contextEntry->getBatchId());
        $evt->setCategory($contextEntry->getCategory());
        $evt->setTimestamp(ClockUtil::getCurrentTime()->format('c'));
        $evt->setRootProcessInstanceId($contextEntry->getRootProcessInstanceId());
        $evt->setExternalTaskId($contextEntry->getExternalTaskId());
        $evt->setAnnotation($contextEntry->getAnnotation());

        if ($this->isHistoryRemovalTimeStrategyStart()) {
            $this->provideRemovalTime($evt);
        }

        // init property value
        $evt->setProperty($propertyChange->getPropertyName());

It seems like $propertyChange->getPropertyName() can also be of type null; however, parameter $property of Jabe\Impl\History\Event\UserOperationLogEntryEventEntity::setProperty() does only seem to accept string, maybe add an additional type check?

        $evt->setOrgValue($propertyChange->getOrgValueString());

It seems like $propertyChange->getOrgValueString() can also be of type null; however, parameter $orgValue of Jabe\Impl\History\Event\UserOperationLogEntryEventEntity::setOrgValue() does only seem to accept string, maybe add an additional type check?

        $evt->setNewValue($propertyChange->getNewValueString());

It seems like $propertyChange->getNewValueString() can also be of type null; however, parameter $newValue of Jabe\Impl\History\Event\UserOperationLogEntryEventEntity::setNewValue() does only seem to accept string, maybe add an additional type check?

    }

    protected function initHistoricIncidentEvent(
        HistoricIncidentEventEntity $evt,
        IncidentInterface $incident,
        HistoryEventTypeInterface $eventType
    ): void {
        // init properties
        $evt->setId($incident->getId());
        $evt->setProcessDefinitionId($incident->getProcessDefinitionId());
        $evt->setProcessInstanceId($incident->getProcessInstanceId());
        $evt->setExecutionId($incident->getExecutionId());
        $evt->setCreateTime($incident->getIncidentTimestamp());
        $evt->setIncidentType($incident->getIncidentType());
        $evt->setActivityId($incident->getActivityId());
        $evt->setCauseIncidentId($incident->getCauseIncidentId());
        $evt->setRootCauseIncidentId($incident->getRootCauseIncidentId());
        $evt->setConfiguration($incident->getConfiguration());
        $evt->setIncidentMessage($incident->getIncidentMessage());
        $evt->setTenantId($incident->getTenantId());
        $evt->setJobDefinitionId($incident->getJobDefinitionId());
        $evt->setHistoryConfiguration($incident->getHistoryConfiguration());
        $evt->setFailedActivityId($incident->getFailedActivityId());

It seems like $incident->getFailedActivityId() can also be of type null; however, parameter $failedActivityId of Jabe\Impl\History\Event\HistoricIncidentEventEntity::setFailedActivityId() does only seem to accept string, maybe add an additional type check?

        $evt->setAnnotation($incident->getAnnotation());

        $jobId = $incident->getConfiguration();
        if ($jobId !== null && $this->isHistoryRemovalTimeStrategyStart()) {
            $historicBatch = $this->getHistoricBatchByJobId($jobId);
            if ($historicBatch !== null) {
                $evt->setRemovalTime($historicBatch->getRemovalTime());
            }
        }

        $incidentEntity = $incident;
        $definition = $incidentEntity->getProcessDefinition();

The method getProcessDefinition() does not exist on Jabe\Runtime\IncidentInterface. Did you maybe mean getProcessDefinitionId()?

        if ($definition !== null) {
            $evt->setProcessDefinitionKey($definition->getKey());
        }

        $execution = $incidentEntity->getExecution();

The method getExecution() does not exist on Jabe\Runtime\IncidentInterface. Did you maybe mean getExecutionId()?

        if ($execution !== null) {
            $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $this->provideRemovalTime($evt);
            }
        }

        // init event type
        $evt->setEventType($eventType->getEventName());

        // init state
        $incidentState = IncidentStateImpl::default();
        if (HistoryEventTypes::incidentDelete()->equals($eventType)) {

The method equals() does not exist on Jabe\Impl\History\Event\HistoryEventTypeInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Jabe\Impl\History\Event\HistoryEventTypeInterface.

            $incidentState = IncidentStateImpl::deleted();
        } elseif (HistoryEventTypes::incidentResolve()->equals($eventType)) {
            $incidentState = IncidentStateImpl::resolved();
        }
        $evt->setIncidentState($incidentState->getStateCode());
    }

    protected function createHistoricVariableEvent(
        VariableInstanceEntity $variableInstance,
        VariableScopeInterface $sourceVariableScope,
        HistoryEventTypeInterface $eventType
    ): HistoryEvent {
        $scopeActivityInstanceId = null;
        $sourceActivityInstanceId = null;

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

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

            $scopeExecution = Context::getCommandContext()
            ->getDbEntityManager()
            ->selectById(ExecutionEntity::class, $variableInstance->getExecutionId());

            if (
                $variableInstance->getTaskId() == null
                && !$variableInstance->isConcurrentLocal()
            ) {
                $scopeActivityInstanceId = $scopeExecution->getParentActivityInstanceId();

The method getParentActivityInstanceId() does not exist on Jabe\Impl\Db\DbEntityInterface. It seems like you code against a sub-type of Jabe\Impl\Db\DbEntityInterface such as Jabe\Impl\Persistence\Entity\ExecutionEntity or Jabe\Impl\History\Event\HistoricActivityInstanceEventEntity.

            } else {
                $scopeActivityInstanceId = $scopeExecution->getActivityInstanceId();

The method getActivityInstanceId() does not exist on Jabe\Impl\Db\DbEntityInterface. It seems like you code against a sub-type of Jabe\Impl\Db\DbEntityInterface such as Jabe\Impl\Persistence\Entity\HistoricVariableInstanceEntity or Jabe\Impl\Persistence\Entity\VariableInstanceEntity or Jabe\Impl\Persistence\Entity\ExecutionEntity or Jabe\Impl\Persistence\Entity\ExternalTaskEntity or Jabe\Impl\History\Event\HistoricExternalTaskLogEntity or Jabe\Impl\History\Event\HistoricDetailEventEntity or Jabe\Impl\History\Event\HistoricTaskInstanceEventEntity or Jabe\Impl\History\Event\HistoricActivityInstanceEventEntity.

            }
        } elseif ($variableInstance->getCaseExecutionId() !== null) {
            $scopeActivityInstanceId = $variableInstance->getCaseExecutionId();
        }

        $sourceExecution = null;
        //CaseExecutionEntity sourceCaseExecution = null;
        if ($sourceVariableScope instanceof ExecutionEntity) {
            $sourceExecution = $sourceVariableScope;
            $sourceActivityInstanceId = $sourceExecution->getActivityInstanceId();
        } elseif ($sourceVariableScope instanceof TaskEntity) {
            $sourceExecution = $sourceVariableScope->getExecution();
            if ($sourceExecution !== null) {
                $sourceActivityInstanceId = $sourceExecution->getActivityInstanceId();
            }/* else {
                sourceCaseExecution = ((TaskEntity) sourceVariableScope)->getCaseExecution();
                if (sourceCaseExecution !== null) {
                    sourceActivityInstanceId = sourceCaseExecution->getId();
                }
            }*/
        } /*elseif (sourceVariableScopeInterface $instanceof CaseExecutionEntity) {
            sourceCaseExecution = (CaseExecutionEntity) sourceVariableScope;
            sourceActivityInstanceId = sourceCaseExecution->getId();
        }*/

        // create event
        $evt = $this->newVariableUpdateEventEntity($sourceExecution);

It seems like $sourceExecution can also be of type null; however, parameter $execution of Jabe\Impl\History\Handler\DefaultHistoryEventProducer::newVariableUpdateEventEntity() does only seem to accept Jabe\Impl\Persistence\Entity\ExecutionEntity, maybe add an additional type check?

        // initialize
        $this->initHistoricVariableUpdateEvt($evt, $variableInstance, $eventType);
        // initialize sequence counter
        $this->initSequenceCounter($variableInstance, $evt);

        // set scope activity instance id
        $evt->setScopeActivityInstanceId($scopeActivityInstanceId);

        // set source activity instance id
        $evt->setActivityInstanceId($sourceActivityInstanceId);

It seems like $sourceActivityInstanceId can also be of type null; however, parameter $activityInstanceId of Jabe\Impl\History\Event\HistoricDetailEventEntity::setActivityInstanceId() does only seem to accept string, maybe add an additional type check?

        // mark initial variables on process start
        if (
            $sourceExecution !== null
            && $sourceExecution->isProcessInstanceStarting()
            && HistoryEventTypes::variabelInstanceCreate()->equals($eventType)

The method variabelInstanceCreate() does not exist on Jabe\Impl\History\Event\HistoryEventTypes. Did you maybe mean variableInstanceCreate()?

        ) {
            if ($variableInstance->getSequenceCounter() == 1) {
                $evt->setInitial(true);
            }

            if ($sourceActivityInstanceId == null && $sourceExecution->getActivity() !== null && $sourceExecution->getTransition() == null) {

It seems like you are loosely comparing $sourceActivityInstanceId of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

                $evt->setActivityInstanceId($sourceExecution->getProcessInstanceId());
            }
        }

        return $evt;
    }

    // event instance factory ////////////////////////

    protected function newProcessInstanceEventEntity(ExecutionEntity $execution): HistoricProcessInstanceEventEntity

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

    {
        return new HistoricProcessInstanceEventEntity();
    }

    protected function newActivityInstanceEventEntity(ExecutionEntity $execution): HistoricActivityInstanceEventEntity

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

    {
        return new HistoricActivityInstanceEventEntity();
    }

    protected function newTaskInstanceEventEntity(DelegateTaskInterface $task): HistoricTaskInstanceEventEntity

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

    {
        return new HistoricTaskInstanceEventEntity();
    }

    protected function newVariableUpdateEventEntity(ExecutionEntity $execution): HistoricVariableUpdateEventEntity

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

    {
        return new HistoricVariableUpdateEventEntity();
    }

    protected function newHistoricFormPropertyEvent(): HistoricFormPropertyEventEntity
    {
        return new HistoricFormPropertyEventEntity();
    }

    protected function newIncidentEventEntity(IncidentInterface $incident): HistoricIncidentEventEntity

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

    {
        return new HistoricIncidentEventEntity();
    }

    protected function newHistoricJobLogEntity(JobInterface $job): HistoricJobLogEventEntity

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

    {
        return new HistoricJobLogEventEntity();
    }

    protected function newBatchEventEntity(BatchEntity $batch): HistoricBatchEntity

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

    {
        return new HistoricBatchEntity();
    }

    protected function loadProcessInstanceEventEntity(ExecutionEntity $execution): HistoricProcessInstanceEventEntity
    {
        return $this->newProcessInstanceEventEntity($execution);
    }

    protected function loadActivityInstanceEventEntity(ExecutionEntity $execution): HistoricActivityInstanceEventEntity
    {
        return $this->newActivityInstanceEventEntity($execution);
    }

    protected function loadTaskInstanceEvent(DelegateTaskInterface $task): HistoricTaskInstanceEventEntity
    {
        return newTaskInstanceEventEntity($task);

The function newTaskInstanceEventEntity was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    protected function loadIncidentEvent(IncidentInterface $incident): HistoricIncidentEventEntity
    {
        return $this->newIncidentEventEntity($incident);
    }

    protected function loadBatchEntity(BatchEntity $batch): HistoricBatchEntity
    {
        return newBatchEventEntity($batch);

The function newBatchEventEntity was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    // Implementation ////////////////////////////////

    public function createProcessInstanceStartEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->newProcessInstanceEventEntity($executionEntity);

        // initialize event
        $this->initProcessInstanceEvent($evt, $executionEntity, HistoryEventTypes::processInstanceStart());

        $evt->setStartActivityId($executionEntity->getActivityId());

The method getActivityId() does not exist on Jabe\Delegate\DelegateExecutionInterface. Did you maybe mean getActivityInstanceId()?

        $evt->setStartTime(ClockUtil::getCurrentTime()->format('c'));

        // set super process instance id
        $superExecution = $executionEntity->getSuperExecution();
        if ($superExecution !== null) {
            $evt->setSuperProcessInstanceId($superExecution->getProcessInstanceId());
        }

        //state
        $evt->setState(HistoricProcessInstanceInterface::STATE_ACTIVE);

        // set start user Id
        $evt->setStartUserId(Context::getCommandContext()->getAuthenticatedUserId());

It seems like Jabe\Impl\Context\Context::getCommandContext()->getAuthenticatedUserId() can also be of type null; however, parameter $startUserId of Jabe\Impl\History\Event\HistoricProcessInstanceEventEntity::setStartUserId() does only seem to accept string, maybe add an additional type check?

        if ($this->isHistoryRemovalTimeStrategyStart()) {
            if ($this->isRootProcessInstance($evt)) {
                $removalTime = $this->calculateRemovalTime($evt);
                $evt->setRemovalTime($removalTime);

It seems like $removalTime can also be of type null; however, parameter $removalTime of Jabe\Impl\History\Event\HistoryEvent::setRemovalTime() does only seem to accept string, maybe add an additional type check?

            } else {
                $this->provideRemovalTime($evt);
            }
        }

        return $evt;
    }

    public function createProcessInstanceUpdateEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->loadProcessInstanceEventEntity($executionEntity);

        // initialize event
        $this->initProcessInstanceEvent($evt, $executionEntity, HistoryEventTypes::processInstanceUpdate());

        if ($executionEntity->isSuspended()) {

The method isSuspended() does not exist on Jabe\Delegate\DelegateExecutionInterface. It seems like you code against a sub-type of Jabe\Delegate\DelegateExecutionInterface such as Jabe\Impl\Persistence\Entity\ExecutionEntity.

            $evt->setState(HistoricProcessInstanceInterface::STATE_SUSPENDED);
        } else {
            $evt->setState(HistoricProcessInstanceInterface::STATE_ACTIVE);
        }

        return $evt;
    }

    public function createProcessInstanceMigrateEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->newProcessInstanceEventEntity($executionEntity);

        // initialize event
        $this->initProcessInstanceEvent($evt, $executionEntity, HistoryEventTypes::processInstanceMigrate());

        if ($executionEntity->isSuspended()) {
            $evt->setState(HistoricProcessInstanceInterface::STATE_SUSPENDED);
        } else {
            $evt->setState(HistoricProcessInstanceInterface::STATE_ACTIVE);
        }

        return $evt;
    }

    public function createProcessInstanceEndEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->loadProcessInstanceEventEntity($executionEntity);

        // initialize event
        $this->initProcessInstanceEvent($evt, $executionEntity, HistoryEventTypes::processInstanceEnd());

        $this->determineEndState($executionEntity, $evt);

        // set end activity id
        $evt->setEndActivityId($executionEntity->getActivityId());
        $evt->setEndTime(ClockUtil::getCurrentTime()->format('c'));

        if ($evt->getStartTime() !== null) {

The condition $evt->getStartTime() !== null is always true.

            $et = new \DateTime($evt->getEndTime());
            $endTimeUt = $et->getTimestamp();

            $st = new \DateTime($evt->getStartTime());
            $startTimeUt = $st->getTimestamp();

            $evt->setDurationInMillis($endTimeUt * 1000 - $startTimeUt * 1000);
        }

        if ($this->isRootProcessInstance($evt) && $this->isHistoryRemovalTimeStrategyEnd()) {
            $removalTime = $this->calculateRemovalTime($evt);

            if ($removalTime !== null) {
                $this->addRemovalTimeToHistoricProcessInstances($evt->getRootProcessInstanceId(), $removalTime);
                /*if ($this->isDmnEnabled()) {
                    $this->addRemovalTimeToHistoricDecisions($evt->getRootProcessInstanceId(), $removalTime);
                }*/
            }
        }

        // set delete reason (if applicable).
        if ($executionEntity->getDeleteReason() !== null) {

The method getDeleteReason() does not exist on Jabe\Delegate\DelegateExecutionInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Jabe\Impl\Pvm\Delegate\ActivityExecutionInterface. Are you sure you never get one of those?

            $evt->setDeleteReason($executionEntity->getDeleteReason());
        }

        return $evt;
    }

    protected function addRemovalTimeToHistoricDecisions(string $rootProcessInstanceId, string $removalTime): void
    {
        Context::getCommandContext()
            ->getHistoricDecisionInstanceManager()

The method getHistoricDecisionInstanceManager() does not exist on Jabe\Impl\Interceptor\CommandContext. Did you maybe mean getHistoricProcessInstanceManager()?

            ->addRemovalTimeToDecisionsByRootProcessInstanceId($rootProcessInstanceId, $removalTime);
    }

    protected function addRemovalTimeToHistoricProcessInstances(string $rootProcessInstanceId, string $removalTime): void
    {
        Context::getCommandContext()
            ->getHistoricProcessInstanceManager()
            ->addRemovalTimeToProcessInstancesByRootProcessInstanceId($rootProcessInstanceId, $removalTime);
    }

    /*protected boolean isDmnEnabled() {
        return Context::getCommandContext()
            ->getProcessEngineConfiguration()
            ->isDmnEnabled();
    }*/

    protected function determineEndState(ExecutionEntity $executionEntity, HistoricProcessInstanceEventEntity $evt): void
    {
        //determine state
        if ($executionEntity->getActivity() !== null) {
            $evt->setState(HistoricProcessInstanceInterface::STATE_COMPLETED);
        } else {
            if ($executionEntity->isExternallyTerminated()) {
                $evt->setState(HistoricProcessInstanceInterface::STATE_EXTERNALLY_TERMINATED);
            } elseif (!$executionEntity->isExternallyTerminated()) {
                $evt->setState(HistoricProcessInstanceInterface::STATE_INTERNALLY_TERMINATED);
            }
        }
    }

    public function createActivityInstanceStartEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->newActivityInstanceEventEntity($executionEntity);

        // initialize event
        $this->initActivityInstanceEvent($evt, $executionEntity, HistoryEventTypes::activityInstanceStart());

        // initialize sequence counter
        $this->initSequenceCounter($executionEntity, $evt);

        $evt->setStartTime(ClockUtil::getCurrentTime()->format('c'));

        return $evt;
    }

    public function createActivityInstanceUpdateEvt(DelegateExecutionInterface $execution, ?DelegateTaskInterface $task = null): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->loadActivityInstanceEventEntity($executionEntity);

        // initialize event
        $this->initActivityInstanceEvent($evt, $executionEntity, HistoryEventTypes::activityInstanceUpdate());

        // update task assignment
        if ($task !== null) {
            $evt->setTaskId($task->getId());
            $evt->setTaskAssignee($task->getAssignee());
        }

        return $evt;
    }

    public function createActivityInstanceMigrateEvt(MigratingActivityInstance $actInstance): HistoryEvent
    {

        // create event instance
        $evt = $this->loadActivityInstanceEventEntity($actInstance->resolveRepresentativeExecution());

        // initialize event
        $this->initActivityInstanceEvent($evt, $actInstance, HistoryEventTypes::activityInstanceMigrate());

        return $evt;
    }

    public function createActivityInstanceEndEvt(DelegateExecutionInterface $execution): HistoryEvent
    {
        $executionEntity = $execution;

        // create event instance
        $evt = $this->loadActivityInstanceEventEntity($executionEntity);
        $evt->setActivityInstanceState($executionEntity->getActivityInstanceState());

The method getActivityInstanceState() does not exist on Jabe\Delegate\DelegateExecutionInterface. Did you maybe mean getActivityInstanceId()?

        // initialize event
        $this->initActivityInstanceEvent($evt, $execution, HistoryEventTypes::activityInstanceEnd());

        $evt->setEndTime(ClockUtil::getCurrentTime()->format('c'));
        if ($evt->getStartTime() !== null) {

The condition $evt->getStartTime() !== null is always true.

            $evt->setDurationInMillis((new \DateTime($evt->getEndTime()))->getTimestamp() * 1000 - (new \DateTime($evt->getStartTime()))->getTimestamp() * 1000);
        }

        return $evt;
    }

    public function createTaskInstanceCreateEvt(DelegateTaskInterface $task): HistoryEvent
    {

        // create event instance
        $evt = newTaskInstanceEventEntity($task);

The function newTaskInstanceEventEntity was not found. Maybe you did not declare it correctly or list all dependencies?

        // initialize event
        $this->initTaskInstanceEvent($evt, $task, HistoryEventTypes::taskInstanceCreate());

        $evt->setStartTime(ClockUtil::getCurrentTime()->format('c'));

        return $evt;
    }

    public function createTaskInstanceUpdateEvt(DelegateTaskInterface $task): HistoryEvent
    {

        // create event instance
        $evt = $this->loadTaskInstanceEvent($task);

        // initialize event
        $this->initTaskInstanceEvent($evt, $task, HistoryEventTypes::taskInstanceUpdate());

        return $evt;
    }

    public function createTaskInstanceMigrateEvt(DelegateTaskInterface $task): HistoryEvent
    {
        // create event instance
        $evt = $this->loadTaskInstanceEvent($task);

        // initialize event
        $this->initTaskInstanceEvent($evt, $task, HistoryEventTypes::taskInstanceMigrate());

        return $evt;
    }

    public function createTaskInstanceCompleteEvt(DelegateTaskInterface $task, string $deleteReason): HistoryEvent
    {
        // create event instance
        $evt = $this->loadTaskInstanceEvent($task);

        // initialize event
        $this->initTaskInstanceEvent($evt, $task, HistoryEventTypes::taskInstanceComplete());

        // set end time
        $evt->setEndTime(ClockUtil::getCurrentTime()->format('c'));
        if ($evt->getStartTime() !== null) {

The condition $evt->getStartTime() !== null is always true.

            $evt->setDurationInMillis((new \DateTime($evt->getEndTime()))->getTimestamp() * 1000 - (new \DateTime($evt->getStartTime()))->getTimestamp() * 1000);
        }

        // set delete reason
        $evt->setDeleteReason($deleteReason);

        return $evt;
    }

    // User Operation Logs ///////////////////////////

    public function createUserOperationLogEvents(UserOperationLogContext $context): array
    {
        $historyEvents = [];

        $operationId = Context::getCommandContext()->getOperationId();
        $context->setOperationId($operationId);

It seems like $operationId can also be of type null; however, parameter $operationId of Jabe\Impl\OpLog\UserOperationLogContext::setOperationId() does only seem to accept string, maybe add an additional type check?

        foreach ($context->getEntries() as $entry) {
            foreach ($entry->getPropertyChanges() as $propertyChange) {
                $evt = new UserOperationLogEntryEventEntity();

                $this->initUserOperationLogEvent($evt, $context, $entry, $propertyChange);

                $historyEvents[] = $evt;
            }
        }

        return $historyEvents;
    }

    // variables /////////////////////////////////

    public function createHistoricVariableCreateEvt(VariableInstanceEntity $variableInstance, VariableScopeInterface $sourceVariableScope): HistoryEvent
    {
        return $this->createHistoricVariableEvent($variableInstance, $sourceVariableScope, HistoryEventTypes::variableInstanceCreate());
    }

    public function createHistoricVariableDeleteEvt(VariableInstanceEntity $variableInstance, VariableScopeInterface $sourceVariableScope): HistoryEvent
    {
        return $this->createHistoricVariableEvent($variableInstance, $sourceVariableScope, HistoryEventTypes::variableInstanceDelete());
    }

    public function createHistoricVariableUpdateEvt(VariableInstanceEntity $variableInstance, VariableScopeInterface $sourceVariableScope): HistoryEvent
    {
        return $this->createHistoricVariableEvent($variableInstance, $sourceVariableScope, HistoryEventTypes::variableInstanceUpdate());
    }

    public function createHistoricVariableMigrateEvt(VariableInstanceEntity $variableInstance): HistoryEvent
    {
        return $this->createHistoricVariableEvent($variableInstance, null, HistoryEventTypes::variableInstanceMigrate());

null of type null is incompatible with the type Jabe\Delegate\VariableScopeInterface expected by parameter $sourceVariableScope of Jabe\Impl\History\Handler\DefaultHistoryEventProducer::createHistoricVariableEvent().

    }

    // form Properties ///////////////////////////

    public function createFormPropertyUpdateEvt(ExecutionEntity $execution, string $propertyId, string $propertyValue, string $taskId): HistoryEvent
    {
        $idGenerator = Context::getProcessEngineConfiguration()->getIdGenerator();

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

        $historicFormPropertyEntity = newHistoricFormPropertyEvent();

The function newHistoricFormPropertyEvent was not found. Maybe you did not declare it correctly or list all dependencies?

        $historicFormPropertyEntity->setId($idGenerator->getNextId());
        $historicFormPropertyEntity->setEventType(HistoryEventTypes::formPropertyUpdate()->getEventName());
        $historicFormPropertyEntity->setTimestamp(ClockUtil::getCurrentTime()->format('c'));
        $historicFormPropertyEntity->setExecutionId($execution->getId());
        $historicFormPropertyEntity->setProcessDefinitionId($execution->getProcessDefinitionId());
        $historicFormPropertyEntity->setProcessInstanceId($execution->getProcessInstanceId());
        $historicFormPropertyEntity->setPropertyId($propertyId);
        $historicFormPropertyEntity->setPropertyValue($propertyValue);
        $historicFormPropertyEntity->setTaskId($taskId);
        $historicFormPropertyEntity->setTenantId($execution->getTenantId());
        $historicFormPropertyEntity->setUserOperationId(Context::getCommandContext()->getOperationId());
        $historicFormPropertyEntity->setRootProcessInstanceId($execution->getRootProcessInstanceId());

        if ($this->isHistoryRemovalTimeStrategyStart()) {
            $this->provideRemovalTime($historicFormPropertyEntity);
        }

        $definition = $execution->getProcessDefinition();
        if ($definition !== null) {
            $historicFormPropertyEntity->setProcessDefinitionKey($definition->getKey());
        }

        // initialize sequence counter
        $this->initSequenceCounter($execution, $historicFormPropertyEntity);

        if ($execution->isProcessInstanceStarting()) {
            // instantiate activity instance id as process instance id when starting a process instance
            // via a form
            $historicFormPropertyEntity->setActivityInstanceId($execution->getProcessInstanceId());
        } else {
            $historicFormPropertyEntity->setActivityInstanceId($execution->getActivityInstanceId());
        }

        return $historicFormPropertyEntity;
    }

    // Incidents //////////////////////////////////

    public function createHistoricIncidentCreateEvt(IncidentInterface $incident): HistoryEvent
    {
        return $this->createHistoricIncidentEvt($incident, HistoryEventTypes::incidentCreate());
    }

    public function createHistoricIncidentUpdateEvt(IncidentInterface $incident): HistoryEvent
    {
        return $this->createHistoricIncidentEvt($incident, HistoryEventTypes::incidentUpdate());
    }

    public function createHistoricIncidentResolveEvt(IncidentInterface $incident): HistoryEvent
    {
        return $this->createHistoricIncidentEvt($incident, HistoryEventTypes::incidentResolve());
    }

    public function createHistoricIncidentDeleteEvt(IncidentInterface $incident): HistoryEvent
    {
        return $this->createHistoricIncidentEvt($incident, HistoryEventTypes::incidentDelete());
    }

    public function createHistoricIncidentMigrateEvt(IncidentInterface $incident): HistoryEvent
    {
        return $this->createHistoricIncidentEvt($incident, HistoryEventTypes::incidentMigrate());
    }

    protected function createHistoricIncidentEvt(IncidentInterface $incident, HistoryEventTypes $eventType): HistoryEvent
    {
        // create event
        $evt = $this->loadIncidentEvent($incident);
        // initialize
        $this->initHistoricIncidentEvent($evt, $incident, $eventType);

        if (HistoryEventTypes::incidentResolve()->equals($eventType) || HistoryEventTypes::incidentDelete()->equals($eventType)) {
            $evt->setEndTime(ClockUtil::getCurrentTime()->format('c'));
        }

        return $evt;
    }

    public function createHistoricIdentityLinkAddEvent(IdentityLinkInterface $identityLink): HistoryEvent
    {
        return $this->createHistoricIdentityLinkEvt($identityLink, HistoryEventTypes::identityLinkAdd());
    }

    public function createHistoricIdentityLinkDeleteEvent(IdentityLinkInterface $identityLink): HistoryEvent
    {
        return $this->createHistoricIdentityLinkEvt($identityLink, HistoryEventTypes::identityLinkDelete());
    }

    protected function createHistoricIdentityLinkEvt(IdentityLinkInterface $identityLink, HistoryEventTypes $eventType): HistoryEvent
    {
        // create historic identity link event
        $evt = newIdentityLinkEventEntity();

The function newIdentityLinkEventEntity was not found. Maybe you did not declare it correctly or list all dependencies?

        // Mapping all the values of identity link to HistoricIdentityLinkEvent
        $this->initHistoricIdentityLinkEvent($evt, $identityLink, $eventType);
        return $evt;
    }

    protected function newIdentityLinkEventEntity(): HistoricIdentityLinkLogEventEntity
    {
        return new HistoricIdentityLinkLogEventEntity();
    }

    protected function initHistoricIdentityLinkEvent(HistoricIdentityLinkLogEventEntity $evt, IdentityLinkInterface $identityLink, HistoryEventTypeInterface $eventType): void
    {
        if ($identityLink->getTaskId() !== null) {

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

            $task = Context::getCommandContext()
                ->getTaskManager()
                ->findTaskById($identityLink->getTaskId());

            $evt->setProcessDefinitionId($task->getProcessDefinitionId());

            if ($task->getProcessDefinition() !== null) {
                $evt->setProcessDefinitionKey($task->getProcessDefinition()->getKey());
            }

            $execution = $task->getExecution();
            if ($execution !== null) {
                $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

                if ($this->isHistoryRemovalTimeStrategyStart()) {
                    $this->provideRemovalTime($evt);
                }
            }
        }

        if ($identityLink->getProcessDefId() !== null) {

The condition $identityLink->getProcessDefId() !== null is always true.

            $evt->setProcessDefinitionId($identityLink->getProcessDefId());

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

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

                ->findProcessDefinitionFromCache($identityLink->getProcessDefId());
            $evt->setProcessDefinitionKey($definition->getKey());
        }

        $evt->setTime(ClockUtil::getCurrentTime()->format('c'));
        $evt->setType($identityLink->getType());
        $evt->setUserId($identityLink->getUserId());
        $evt->setGroupId($identityLink->getGroupId());
        $evt->setTaskId($identityLink->getTaskId());
        $evt->setTenantId($identityLink->getTenantId());
        // There is a conflict in HistoryEventTypes for 'delete' keyword,
        // So HistoryEventTypes.IDENTITY_LINK_ADD /
        // HistoryEventTypes.IDENTITY_LINK_DELETE is provided with the event name
        // 'add-identity-link' /'delete-identity-link'
        // and changed to 'add'/'delete' (While inserting it into the database) on
        // Historic identity link add / delete event
        $operationType = "add";
        if ($eventType->getEventName() == HistoryEventTypes::identityLinkDelete()->getEventName()) {
            $operationType = "delete";
        }

        $evt->setOperationType($operationType);
        $evt->setEventType($eventType->getEventName());
        $evt->setAssignerId(Context::getCommandContext()->getAuthenticatedUserId());

It seems like Jabe\Impl\Context\Context::getCommandContext()->getAuthenticatedUserId() can also be of type null; however, parameter $assignerId of Jabe\Impl\History\Event\HistoricIdentityLinkLogEventEntity::setAssignerId() does only seem to accept string, maybe add an additional type check?

    }
    // Batch

    public function createBatchStartEvent(BatchInterface $batch): HistoryEvent
    {
        $historicBatch = $this->createBatchEvent($batch, HistoryEventTypes::batchStart());

        if ($this->isHistoryRemovalTimeStrategyStart()) {
            $this->provideRemovalTime($historicBatch);
        }

        return $historicBatch;
    }

    public function createBatchEndEvent(BatchInterface $batch): HistoryEvent
    {
        $historicBatch = $this->createBatchEvent($batch, HistoryEventTypes::batchEnd());

        if ($this->isHistoryRemovalTimeStrategyEnd()) {
            $this->provideRemovalTime($historicBatch);

            $this->addRemovalTimeToHistoricJobLog($historicBatch);
            $this->addRemovalTimeToHistoricIncidents($historicBatch);
        }

        return $historicBatch;
    }

    protected function createBatchEvent(BatchEntity $batch, HistoryEventTypes $eventType): HistoryEvent
    {
        $event = $this->loadBatchEntity($batch);

        $event->setId($batch->getId());
        $event->setType($batch->getType());
        $event->setTotalJobs($batch->getTotalJobs());
        $event->setBatchJobsPerSeed($batch->getBatchJobsPerSeed());
        $event->setInvocationsPerBatchJob($batch->getInvocationsPerBatchJob());
        $event->setSeedJobDefinitionId($batch->getSeedJobDefinitionId());
        $event->setMonitorJobDefinitionId($batch->getMonitorJobDefinitionId());
        $event->setBatchJobDefinitionId($batch->getBatchJobDefinitionId());
        $event->setTenantId($batch->getTenantId());
        $event->setEventType($eventType->getEventName());

        if (HistoryEventTypes::batchStart()->equals($eventType)) {
            $event->setStartTime(ClockUtil::getCurrentTime()->format('c'));
            $event->setCreateUserId(Context::getCommandContext()->getAuthenticatedUserId());

It seems like Jabe\Impl\Context\Context::getCommandContext()->getAuthenticatedUserId() can also be of type null; however, parameter $createUserId of Jabe\Impl\Batch\History\HistoricBatchEntity::setCreateUserId() does only seem to accept string, maybe add an additional type check?

        }

        if (HistoryEventTypes::batchEnd()->equals($eventType)) {
            $event->setEndTime(ClockUtil::getCurrentTime()->format('c'));
        }

        return $event;
    }

    // Job Log

    public function createHistoricJobLogCreateEvt(JobInterface $job): HistoryEvent
    {
        return $this->createHistoricJobLogEvt($job, HistoryEventTypes::jobCreate());
    }

    public function createHistoricJobLogFailedEvt(JobInterface $job, ?\Throwable $exception = null): HistoryEvent
    {
        $event = $this->createHistoricJobLogEvt($job, HistoryEventTypes::jobFail());

        if ($exception !== null) {
            // exception message
            $event->setJobExceptionMessage($exception->getMessage());

The method setJobExceptionMessage() does not exist on Jabe\Impl\History\Event\HistoryEvent. It seems like you code against a sub-type of Jabe\Impl\History\Event\HistoryEvent such as Jabe\Impl\History\Event\HistoricJobLogEvent.

            // stacktrace
            $exceptionStacktrace = ExceptionUtil::getExceptionStacktrace($exception);
            $exceptionBytes = StringUtil::toByteArray($exceptionStacktrace);

            $byteArray = ExceptionUtil::createJobExceptionByteArray($exceptionBytes, ResourceTypes::history());
            $byteArray->setRootProcessInstanceId($event->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $byteArray->setRemovalTime($event->getRemovalTime());
            }

            $event->setExceptionByteArrayId($byteArray->getId());

The method setExceptionByteArrayId() does not exist on Jabe\Impl\History\Event\HistoryEvent. It seems like you code against a sub-type of Jabe\Impl\History\Event\HistoryEvent such as Jabe\Impl\History\Event\HistoricJobLogEvent.

        }

        return $event;
    }

    public function createHistoricJobLogSuccessfulEvt(JobInterface $job): HistoryEvent
    {
        return $this->createHistoricJobLogEvt($job, HistoryEventTypes::jobSuccess());
    }

    public function createHistoricJobLogDeleteEvt(JobInterface $job): HistoryEvent
    {
        return $this->createHistoricJobLogEvt($job, HistoryEventTypes::jobDelete());
    }

    protected function createHistoricJobLogEvt(JobInterface $job, HistoryEventTypeInterface $eventType): HistoryEvent
    {
        $event = newHistoricJobLogEntity($job);

The function newHistoricJobLogEntity was not found. Maybe you did not declare it correctly or list all dependencies?

        $this->initHistoricJobLogEvent($event, $job, $eventType);
        return $event;
    }

    protected function initHistoricJobLogEvent(HistoricJobLogEventEntity $evt, JobInterface $job, HistoryEventTypeInterface $eventType): void
    {
        $currentTime = ClockUtil::getCurrentTime()->format('c');
        $evt->setTimestamp($currentTime);

        $jobEntity = $job;
        $evt->setJobId($jobEntity->getId());

It seems like $jobEntity->getId() can also be of type null; however, parameter $jobId of Jabe\Impl\History\Event\HistoricJobLogEvent::setJobId() does only seem to accept string, maybe add an additional type check?

        $evt->setJobDueDate($jobEntity->getDuedate());
        $evt->setJobRetries($jobEntity->getRetries());
        $evt->setJobPriority($jobEntity->getPriority());

$jobEntity->getPriority() of type double is incompatible with the type integer expected by parameter $jobPriority of Jabe\Impl\History\Event\HistoricJobLogEvent::setJobPriority().

        $hostName = Context::getCommandContext()->getProcessEngineConfiguration()->getHostname();

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

        $evt->setHostname($hostName);

        if (HistoryCleanupJobHandler::TYPE == $jobEntity->getJobHandlerType()) {

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

            $timeToLive = Context::getProcessEngineConfiguration()->getHistoryCleanupJobLogTimeToLive();

The method getHistoryCleanupJobLogTimeToLive() does not exist on Jabe\Impl\Cfg\ProcessEngineConfigurationImpl. Did you maybe mean getHistory()?

            if ($timeToLive !== null) {
                try {
                    $timeToLiveDays = ParseUtil::parseHistoryTimeToLive($timeToLive);
                    $removalTime = DefaultHistoryRemovalTimeProvider::determineRemovalTime($currentTime, $timeToLiveDays);

It seems like $timeToLiveDays can also be of type null; however, parameter $timeToLive of Jabe\Impl\History\DefaultHistoryRemovalTimeProvider::determineRemovalTime() does only seem to accept integer, maybe add an additional type check?

                    $evt->setRemovalTime($removalTime);
                } catch (ProcessEngineException $e) {
                    //$wrappedException = LOG.invalidPropertyValue("historyCleanupJobLogTimeToLive", timeToLive, e);
                    //LOG.invalidPropertyValue(wrappedException);
                    throw $e;
                }
            }
        }

        $jobDefinition = $jobEntity->getJobDefinition();

The method getJobDefinition() does not exist on Jabe\Runtime\JobInterface. Did you maybe mean getJobDefinitionId()?

        if ($jobDefinition !== null) {
            $evt->setJobDefinitionId($jobDefinition->getId());
            $evt->setJobDefinitionType($jobDefinition->getJobType());
            $evt->setJobDefinitionConfiguration($jobDefinition->getJobConfiguration());

            $historicBatchId = $jobDefinition->getJobConfiguration();
            if ($historicBatchId !== null && $this->isHistoryRemovalTimeStrategyStart()) {
                $historicBatch = $this->getHistoricBatchById($historicBatchId);
                if ($historicBatch !== null) {
                    $evt->setRemovalTime($historicBatch->getRemovalTime());
                }
            }
        } else {
            // in case of async signal there does not exist a job definition
            // but we use the jobHandlerType as jobDefinitionType
            $evt->setJobDefinitionType($jobEntity->getJobHandlerType());
        }

        $evt->setActivityId($jobEntity->getActivityId());

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

        $evt->setFailedActivityId($jobEntity->getFailedActivityId());

It seems like $jobEntity->getFailedActivityId() can also be of type null; however, parameter $failedActivityId of Jabe\Impl\History\Event\HistoricJobLogEvent::setFailedActivityId() does only seem to accept string, maybe add an additional type check?

        $evt->setExecutionId($jobEntity->getExecutionId());
        $evt->setProcessInstanceId($jobEntity->getProcessInstanceId());
        $evt->setProcessDefinitionId($jobEntity->getProcessDefinitionId());
        $evt->setProcessDefinitionKey($jobEntity->getProcessDefinitionKey());
        $evt->setDeploymentId($jobEntity->getDeploymentId());

It seems like $jobEntity->getDeploymentId() can also be of type null; however, parameter $deploymentId of Jabe\Impl\History\Event\HistoricJobLogEvent::setDeploymentId() does only seem to accept string, maybe add an additional type check?

        $evt->setTenantId($jobEntity->getTenantId());

        $execution = $jobEntity->getExecution();

The method getExecution() does not exist on Jabe\Runtime\JobInterface. Did you maybe mean getExecutionId()?

        if ($execution !== null) {
            $evt->setRootProcessInstanceId($execution->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $this->provideRemovalTime($evt);
            }
        }

        // initialize sequence counter
        $this->initSequenceCounter($jobEntity, $evt);

        $state = null;
        if (HistoryEventTypes::jobCreate()->equals($eventType)) {
            $state = JobStateImpl::created();
        } elseif (HistoryEventTypes::jobFail()->equals($eventType)) {
            $state = JobStateImpl::failed();
        } elseif (HistoryEventTypes::jobSuccess()->equals($eventType)) {
            $state = JobStateImpl::successful();
        } elseif (HistoryEventTypes::jobDelete()->equals($eventType)) {
            $state = JobStateImpl::deleted();
        }
        $evt->setState($state->getStateCode());
    }

    public function createHistoricExternalTaskLogCreatedEvt(ExternalTaskInterface $task): HistoryEvent
    {
        return initHistoricExternalTaskLog($task, ExternalTaskStateImpl::created());

The function initHistoricExternalTaskLog was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    public function createHistoricExternalTaskLogFailedEvt(ExternalTaskInterface $task): HistoryEvent
    {
        $event = $this->initHistoricExternalTaskLog($task, ExternalTaskStateImpl::failed());
        $event->setErrorMessage($task->getErrorMessage());
        $errorDetails = $task->getErrorDetails();

The method getErrorDetails() does not exist on Jabe\ExternalTask\ExternalTaskInterface. Did you maybe mean getErrorMessage()?

        if ($errorDetails !== null) {
            $event->setErrorDetails($errorDetails);
        }
        return $event;
    }

    public function createHistoricExternalTaskLogSuccessfulEvt(ExternalTaskInterface $task): HistoryEvent
    {
        return $this->initHistoricExternalTaskLog($task, ExternalTaskStateImpl::successful());
    }

    public function createHistoricExternalTaskLogDeletedEvt(ExternalTaskInterface $task): HistoryEvent
    {
        return $this->initHistoricExternalTaskLog($task, ExternalTaskStateImpl::deleted());
    }

    protected function initHistoricExternalTaskLog(ExternalTaskEntity $entity, ExternalTaskStateInterface $state): HistoricExternalTaskLogEntity
    {
        $event = new HistoricExternalTaskLogEntity();
        $event->setTimestamp(ClockUtil::getCurrentTime()->format('c'));
        $event->setExternalTaskId($entity->getId());

It seems like $entity->getId() can also be of type null; however, parameter $externalTaskId of Jabe\Impl\History\Event\HistoricExternalTaskLogEntity::setExternalTaskId() does only seem to accept string, maybe add an additional type check?

        $event->setTopicName($entity->getTopicName());
        $event->setWorkerId($entity->getWorkerId());

        $event->setPriority($entity->getPriority());
        $event->setRetries($entity->getRetries());

        $event->setActivityId($entity->getActivityId());
        $event->setActivityInstanceId($entity->getActivityInstanceId());
        $event->setExecutionId($entity->getExecutionId());

        $event->setProcessInstanceId($entity->getProcessInstanceId());
        $event->setProcessDefinitionId($entity->getProcessDefinitionId());
        $event->setProcessDefinitionKey($entity->getProcessDefinitionKey());
        $event->setTenantId($entity->getTenantId());
        $event->setState($state->getStateCode());

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

        $execution = $entity->getExecution();
        if ($execution !== null) {
            $event->setRootProcessInstanceId($execution->getRootProcessInstanceId());

            if ($this->isHistoryRemovalTimeStrategyStart()) {
                $this->provideRemovalTime($event);
            }
        }

        return $event;
    }

    protected function isRootProcessInstance(HistoricProcessInstanceEventEntity $evt): bool
    {
        return $evt->getProcessInstanceId() == $evt->getRootProcessInstanceId();
    }

    protected function isHistoryRemovalTimeStrategyStart(): bool
    {
        return ProcessEngineConfiguration::HISTORY_REMOVAL_TIME_STRATEGY_START == $this->getHistoryRemovalTimeStrategy();
    }

    protected function isHistoryRemovalTimeStrategyEnd(): bool
    {
        return ProcessEngineConfiguration::HISTORY_REMOVAL_TIME_STRATEGY_END == $this->getHistoryRemovalTimeStrategy();
    }

    protected function getHistoryRemovalTimeStrategy(): string
    {
        return Context::getProcessEngineConfiguration()
            ->getHistoryRemovalTimeStrategy();

The method getHistoryRemovalTimeStrategy() does not exist on Jabe\Impl\Cfg\ProcessEngineConfigurationImpl. Did you maybe mean getHistory()?

    }

    protected function calculateRemovalTime($event): ?string
    {
        if ($event instanceof HistoryEvent) {
            $processDefinitionId = $event->getProcessDefinitionId();
            $processDefinition = findProcessDefinitionById($processDefinitionId);

The function findProcessDefinitionById was not found. Maybe you did not declare it correctly or list all dependencies?

            return Context::getProcessEngineConfiguration()
                ->getHistoryRemovalTimeProvider()

The method getHistoryRemovalTimeProvider() does not exist on Jabe\Impl\Cfg\ProcessEngineConfigurationImpl. Did you maybe mean getHistory()?

                ->calculateRemovalTime($event, $processDefinition);
        } elseif ($event instanceof HistoricBatchEntity) {
            return Context::getProcessEngineConfiguration()
            ->getHistoryRemovalTimeProvider()
            ->calculateRemovalTime($event);
        }
        return null;
    }

    protected function provideRemovalTime($event): void
    {
        if ($event instanceof HistoryEvent) {
            $rootProcessInstanceId = $event->getRootProcessInstanceId();
            if ($rootProcessInstanceId !== null) {

The condition $rootProcessInstanceId !== null is always true.

                $historicRootProcessInstance = $this->getHistoricRootProcessInstance($rootProcessInstanceId);

                if ($historicRootProcessInstance !== null) {
                    $removalTime = $historicRootProcessInstance->getRemovalTime();
                    $event->setRemovalTime($removalTime);
                }
            }
        } elseif ($event instanceof HistoricBatchEntity) {
            $removalTime = $this->calculateRemovalTime($event);
            if ($removalTime !== null) {
                $event->setRemovalTime($removalTime);
            }
        }
    }

    protected function getHistoricRootProcessInstance(string $rootProcessInstanceId): ?HistoricProcessInstanceEventEntity
    {
        return Context::getCommandContext()
            ->getDbEntityManager()
            ->selectById(HistoricProcessInstanceEventEntity::class, $rootProcessInstanceId);
    }

    protected function findProcessDefinitionById(string $processDefinitionId): ?ProcessDefinitionInterface
    {
        return Context::getCommandContext()
            ->getProcessEngineConfiguration()
            ->getDeploymentCache()
            ->findDeployedProcessDefinitionById($processDefinitionId);
    }

    protected function getHistoricBatchById(string $batchId): ?HistoricBatchEntity
    {
        return Context::getCommandContext()
            ->getHistoricBatchManager()
            ->findHistoricBatchById($batchId);
    }

    protected function getHistoricBatchByJobId(string $jobId): ?HistoricBatchEntity
    {
        return Context::getCommandContext()
            ->getHistoricBatchManager()
            ->findHistoricBatchByJobId($jobId);
    }

    protected function addRemovalTimeToHistoricJobLog(HistoricBatchEntity $historicBatch): void
    {
        $removalTime = $historicBatch->getRemovalTime();
        if ($removalTime !== null) {

The condition $removalTime !== null is always true.

            Context::getCommandContext()
            ->getHistoricJobLogManager()
            ->addRemovalTimeToJobLogByBatchId($historicBatch->getId(), $removalTime);
        }
    }

    protected function addRemovalTimeToHistoricIncidents(HistoricBatchEntity $historicBatch): void
    {
        $removalTime = $historicBatch->getRemovalTime();
        if ($removalTime !== null) {

The condition $removalTime !== null is always true.

            Context::getCommandContext()
            ->getHistoricIncidentManager()
            ->addRemovalTimeToHistoricIncidentsByBatchId($historicBatch->getId(), $removalTime);
        }
    }

    // sequence counter //////////////////////////////////////////////////////

    protected function initSequenceCounter($obj, HistoryEvent $event): void
    {
        if (is_int($obj)) {
            $event->setSequenceCounter($obj);
        } elseif (method_exists($obj, 'getSequenceCounter')) {
            $this->initSequenceCounter($obj->getSequenceCounter(), $event);
        }
    }
}