workflow.php

См. документацию.

<?php
 
use Bitrix\Bizproc\Workflow\Entity\WorkflowUserTable;

class CBPWorkflow
{
    private bool $isNew = false;
    private bool $isAbandoned = false;
    private string $instanceId;
 
    protected CBPRuntime $runtime;
    protected CBPWorkflowPersister $persister;
 
    protected ?CBPCompositeActivity $rootActivity;
 
    protected array $activitiesQueue = [];
    protected array $eventsQueue = [];
 
    private array $activitiesNamesMap = [];
 
    /************************  PROPERTIES  *******************************/
 
    public function getInstanceId()
    {
        return $this->instanceId;
    }

    public function getRuntime()
    {
        return $this->runtime;
    }
 
    public function getRootActivity(): CBPCompositeActivity
    {
        return $this->rootActivity;
    }
 
    private function getWorkflowStatus()
    {
        return $this->rootActivity->getWorkflowStatus();
    }
 
    protected function setWorkflowStatus($newStatus)
    {
        $this->rootActivity->setWorkflowStatus($newStatus);
        $this->getRuntime()->onWorkflowStatusChanged($this->getInstanceId(), $newStatus);
        $this->syncStatus($newStatus);
    }
 
    public function getService($name)
    {
        return $this->runtime->getService($name);
    }
 
    public function getDocumentId()
    {
        return $this->rootActivity->getDocumentId();
    }
 
    public function getDocumentType()
    {
        return $this->rootActivity->getDocumentType();
    }
 
    public function getTemplateId(): int
    {
        return (int)$this->rootActivity->getWorkflowTemplateId();
    }
 
    public function getStartedBy(): ?int
    {
        $startedBy = (int)CBPHelper::stripUserPrefix($this->rootActivity->{\CBPDocument::PARAM_TAGRET_USER});
 
        return $startedBy ?: null;
    }
 
    public function getPersister(): CBPWorkflowPersister
    {
        return $this->persister;
    }
 
    /************************  CONSTRUCTORS  ****************************************************/

    public function __construct($instanceId, CBPRuntime $runtime)
    {
        if (!$instanceId)
        {
            throw new Exception("instanceId");
        }
 
        $this->instanceId = $instanceId;
        $this->runtime = $runtime;
        $this->persister = CBPWorkflowPersister::GetPersister();
    }

    public function __sleep()
    {
        return [];
    }
 
    /************************  CREATE / LOAD WORKFLOW  ****************************************/
 
    public function initialize(
        CBPActivity $rootActivity,
        $documentId,
        $workflowParameters = [],
        $workflowVariablesTypes = [],
        $workflowParametersTypes = [],
        $workflowTemplateId = 0
    )
    {
        $this->rootActivity = $rootActivity;
        $rootActivity->setWorkflow($this);
        if (method_exists($rootActivity, 'setWorkflowTemplateId'))
        {
            $rootActivity->setWorkflowTemplateId($workflowTemplateId);
        }
 
        if (method_exists($rootActivity, 'setTemplateUserId'))
        {
            $rootActivity->setTemplateUserId(
                CBPWorkflowTemplateLoader::getTemplateUserId($workflowTemplateId)
            );
        }
 
        $arDocumentId = CBPHelper::parseDocumentId($documentId);
 
        $rootActivity->setDocumentId($arDocumentId);
 
        $documentService = $this->getService("DocumentService");
        $documentType = $workflowParameters[CBPDocument::PARAM_DOCUMENT_TYPE]
            ?? $documentService->getDocumentType($arDocumentId)
        ;
 
        unset($workflowParameters[CBPDocument::PARAM_DOCUMENT_TYPE]);
 
        if ($documentType !== null)
        {
            $rootActivity->setDocumentType($documentType);
            $rootActivity->setFieldTypes($documentService->getDocumentFieldTypes($documentType));
        }
 
        $rootActivity->setProperties($workflowParameters);
 
        $rootActivity->setVariablesTypes($workflowVariablesTypes);
        if (is_array($workflowVariablesTypes))
        {
            foreach ($workflowVariablesTypes as $k => $v)
            {
                $variableValue = $v["Default"] ?? null;
                if ($documentType && $fieldTypeObject = $documentService->getFieldTypeObject($documentType, $v))
                {
                    $fieldTypeObject->setDocumentId($arDocumentId);
                    $variableValue = $fieldTypeObject->internalizeValue('Variable', $variableValue);
                }
 
                //set defaults on start
                $rootActivity->setVariable($k, $variableValue);
            }
        }
 
        $rootActivity->setPropertiesTypes($workflowParametersTypes);
    }
 
    public function reload(CBPActivity $rootActivity)
    {
        $this->rootActivity = $rootActivity;
        $rootActivity->setWorkflow($this);
 
        switch ($this->getWorkflowStatus())
        {
            case CBPWorkflowStatus::Completed:
            case CBPWorkflowStatus::Terminated:
                throw new Exception("InvalidAttemptToLoad");
        }
    }
 
    /************************  EXECUTE WORKFLOW  ************************************************/

    public function start(): void
    {
        if ($this->getWorkflowStatus() !== CBPWorkflowStatus::Created)
        {
            throw new Exception("CanNotStartInstanceTwice");
        }
 
        $this->isNew = true;
        $this->run();
    }

    public function resume(): void
    {
        if ($this->getWorkflowStatus() !== CBPWorkflowStatus::Suspended)
        {
            throw new Exception("CanNotResumeInstance");
        }
 
        $this->run();
    }
 
    private function run(): void
    {
        try
        {
            $this->setWorkflowStatus(CBPWorkflowStatus::Running);
            if ($this->isNew)
            {
                $this->rootActivity->setReadOnlyData(
                    $this->rootActivity->pullProperties()
                );
 
                $this->initializeActivity($this->rootActivity);
                $this->executeActivity($this->rootActivity);
            }
 
            $this->runQueue();
        }
        catch (Exception $e)
        {
            $this->terminate($e);
 
            throw $e;
        }
 
        if ($this->rootActivity->executionStatus === CBPActivityExecutionStatus::Closed)
        {
            $this->setWorkflowStatus(CBPWorkflowStatus::Completed);
        }
        elseif ($this->getWorkflowStatus() === CBPWorkflowStatus::Running)
        {
            $this->setWorkflowStatus(CBPWorkflowStatus::Suspended);
        }
 
        $this->persister->saveWorkflow($this->rootActivity, true);
    }
 
    public function isNew()
    {
        return $this->isNew;
    }
 
    public function abandon(): void
    {
        $this->isAbandoned = true;
    }
 
    public function isAbandoned(): bool
    {
        return $this->isAbandoned;
    }
 
    public function isFinished(): bool
    {
        if ($this->isAbandoned())
        {
            return true;
        }
 
        return CBPWorkflowStatus::isFinished((int)$this->getWorkflowStatus());
    }
 
    /**********************  EXTERNAL EVENTS  **************************************************************/

    public function sendExternalEvent(string $eventName, array $eventParameters = []): void
    {
        $this->addEventToQueue($eventName, $eventParameters);
 
        if ($this->getWorkflowStatus() !== CBPWorkflowStatus::Running)
        {
            $this->resume();
        }
    }
 
    /***********************  SEARCH ACTIVITY BY NAME  ****************************************************/
 
    private function fillNameActivityMapInternal(CBPActivity $activity)
    {
        $this->activitiesNamesMap[$activity->getName()] = $activity;
 
        if ($activity instanceof \CBPCompositeActivity)
        {
            $arSubActivities = $activity->collectNestedActivities();
            foreach ($arSubActivities as $subActivity)
            {
                $this->fillNameActivityMapInternal($subActivity);
            }
        }
    }
 
    private function fillNameActivityMap()
    {
        if (!is_array($this->activitiesNamesMap))
        {
            $this->activitiesNamesMap = [];
        }
 
        if (count($this->activitiesNamesMap) > 0)
        {
            return;
        }
 
        $this->fillNameActivityMapInternal($this->rootActivity);
    }

    public function getActivityByName($activityName)
    {
        if ($activityName == '')
        {
            throw new Exception('activityName');
        }
 
        $activity = null;
 
        $this->fillNameActivityMap();
 
        if (array_key_exists($activityName, $this->activitiesNamesMap))
        {
            $activity = $this->activitiesNamesMap[$activityName];
        }
 
        return $activity;
    }
 
    /************************  ACTIVITY EXECUTION  *************************************************/

    public function initializeActivity(CBPActivity $activity)
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Initialized)
        {
            throw new Exception("InvalidInitializingState");
        }
 
        $activity->initialize();
    }

    public function executeActivity(CBPActivity $activity, array $eventParameters = [])
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Initialized)
        {
            throw new Exception("InvalidExecutionState");
        }
 
        $activity->setStatus(CBPActivityExecutionStatus::Executing, $eventParameters);
        $this->addItemToQueue([$activity, CBPActivityExecutorOperationType::Execute]);
    }

    public function closeActivity(CBPActivity $activity, $arEventParameters = [])
    {
        switch ($activity->executionStatus)
        {
            case CBPActivityExecutionStatus::Executing:
                $activity->markCompleted($arEventParameters);
                return;
 
            case CBPActivityExecutionStatus::Canceling:
                $activity->markCanceled($arEventParameters);
                return;
 
            case CBPActivityExecutionStatus::Closed:
                return;
 
            case CBPActivityExecutionStatus::Faulting:
                $activity->markFaulted($arEventParameters);
                return;
        }
 
        throw new Exception("InvalidClosingState");
    }

    public function cancelActivity(CBPActivity $activity, $arEventParameters = [])
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Executing)
        {
            throw new Exception("InvalidCancelingState");
        }
 
        $activity->setStatus(CBPActivityExecutionStatus::Canceling, $arEventParameters);
        $this->addItemToQueue(array($activity, CBPActivityExecutorOperationType::Cancel));
    }
 
    public function faultActivity(CBPActivity $activity, Exception $e, $arEventParameters = [])
    {
        if ($activity->executionStatus === CBPActivityExecutionStatus::Closed)
        {
            if ($activity->parent === null)
            {
                $this->Terminate($e);
            }
            else
            {
                $this->FaultActivity($activity->parent, $e, $arEventParameters);
            }
        }
        else
        {
            $activity->setStatus(CBPActivityExecutionStatus::Faulting);
            $this->addItemToQueue(array($activity, CBPActivityExecutorOperationType::HandleFault, $e));
        }
    }
 
    /************************  ACTIVITIES QUEUE  ***********************************************/
 
    private function addItemToQueue($item)
    {
        $this->activitiesQueue[] = $item;
    }
 
    protected function runQueue()
    {
        $canRun = $this->runStep();
 
        while ($canRun)
        {
            $canRun = $this->runStep();
        }
    }
 
    protected function runStep(): bool
    {
        if (empty($this->activitiesQueue))
        {
            $this->ProcessQueuedEvents();
        }
 
        $item = array_shift($this->activitiesQueue);
        if ($item === null)
        {
            return false;
        }
 
        try
        {
            $this->runQueuedItem($item[0], $item[1], (count($item) > 2 ? $item[2] : null));
        }
        catch (Exception $e)
        {
            $this->faultActivity($item[0], $e);
 
            if ($this->getWorkflowStatus() === CBPWorkflowStatus::Terminated)
            {
                return false;
            }
        }
 
        return true;
    }

    private function runQueuedItem(CBPActivity $activity, $activityOperation, Exception $exception = null): void
    {
        match ($activityOperation)
        {
            CBPActivityExecutorOperationType::Execute => $this->runExecuteActivityOperation($activity),
            CBPActivityExecutorOperationType::Cancel => $this->runCancelActivityOperation($activity),
            CBPActivityExecutorOperationType::HandleFault => $this->runHandleFaultActivityOperation($activity, $exception),
        };
    }

    private function runExecuteActivityOperation(CBPActivity $activity): void
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Executing)
        {
            return;
        }
 
        $newStatus = CBPActivityExecutionStatus::Closed;
        if ($activity->isActivated())
        {
            $trackingService = $this->getService('TrackingService');
            $trackingService->write(
                $this->getInstanceId(),
                CBPTrackingType::ExecuteActivity,
                $activity->getName(),
                $activity->executionStatus,
                $activity->executionResult,
                $activity->getTitle(),
                ''
            );
            $newStatus = $activity->execute();
        }
 
        if ($newStatus === CBPActivityExecutionStatus::Closed)
        {
            $this->closeActivity($activity);
        }
        elseif ($newStatus !== CBPActivityExecutionStatus::Executing)
        {
            throw new Exception('InvalidExecutionStatus');
        }
    }

    private function runCancelActivityOperation(CBPActivity $activity): void
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Canceling)
        {
            return;
        }

        $trackingService = $this->getService("TrackingService");
        $trackingService->write(
            $this->getInstanceId(),
            CBPTrackingType::CancelActivity,
            $activity->getName(),
            $activity->executionStatus,
            $activity->executionResult,
            $activity->getTitle()
        );
 
        $newStatus = $activity->cancel();
 
        if ($newStatus === CBPActivityExecutionStatus::Closed)
        {
            $this->closeActivity($activity);
        }
        elseif ($newStatus !== CBPActivityExecutionStatus::Canceling)
        {
            throw new Exception("InvalidExecutionStatus");
        }
    }

    private function runHandleFaultActivityOperation(CBPActivity $activity, ?Exception $exception): void
    {
        if ($activity->executionStatus !== CBPActivityExecutionStatus::Faulting)
        {
            return;
        }

        $trackingService = $this->getService("TrackingService");
        $trackingService->write(
            $this->getInstanceId(),
            CBPTrackingType::FaultActivity,
            $activity->getName(),
            $activity->executionStatus,
            $activity->executionResult,
            $activity->getTitle(),
            ($exception ? ($exception->getCode() ? "[" . $exception->getCode() . "] " : '') . $exception->getMessage() : "")
        );
 
        $newStatus = $activity->handleFault($exception);
 
        if ($newStatus === CBPActivityExecutionStatus::Closed)
        {
            $this->closeActivity($activity);
        }
        elseif ($newStatus !== CBPActivityExecutionStatus::Faulting)
        {
            throw new Exception("InvalidExecutionStatus");
        }
    }
 
    public function terminate(Exception $e = null, $stateTitle = '')
    {
        CBPTaskService::deleteByWorkflow($this->getInstanceId(), \CBPTaskStatus::Running);
 
        $this->setWorkflowStatus(CBPWorkflowStatus::Terminated);
 
        $this->persister->SaveWorkflow($this->rootActivity, true);

        $stateService = $this->GetService("StateService");
        $stateService->SetState(
            $this->instanceId,
            [
                "STATE" => "Terminated",
                "TITLE" => $stateTitle ?: GetMessage("BPCGWF_TERMINATED_MSGVER_1"),
                "PARAMETERS" => [],
            ],
            false
        );
 
        if ($e)
        {
            $trackingService = $this->getService("TrackingService");
            $trackingService->write(
                $this->instanceId,
                CBPTrackingType::FaultActivity,
                "none",
                CBPActivityExecutionStatus::Faulting,
                CBPActivityExecutionResult::Faulted,
                GetMessage('BPCGWF_EXCEPTION_TITLE'),
                ($e->getCode() ? "[" . $e->getCode() . "] " : '') . $e->getMessage()
            );
        }
    }

    public function finalizeActivity(CBPActivity $activity)
    {
        $activity->finalize();
    }
 
    /************************  EVENTS QUEUE  ********************************************************/
 
    private function addEventToQueue($eventName, $arEventParameters = array())
    {
        $this->eventsQueue[] = [$eventName, $arEventParameters];
    }
 
    private function processQueuedEvents()
    {
        while (true)
        {
            $event = array_shift($this->eventsQueue);
            if ($event === null)
            {
                return;
            }
 
            [$eventName, $eventParameters] = $event;
 
            $this->processQueuedEvent($eventName, $eventParameters);
        }
    }
 
    private function processQueuedEvent($eventName, $eventParameters = [])
    {
        if (!array_key_exists($eventName, $this->rootActivity->arEventsMap))
        {
            return;
        }
 
        foreach ($this->rootActivity->arEventsMap[$eventName] as $eventHandler)
        {
            if (!empty($eventParameters['DebugEvent']) && $eventHandler instanceof IBPActivityDebugEventListener)
            {
                $eventHandler->onDebugEvent($eventParameters);
 
                continue;
            }
 
            if ($eventHandler instanceof IBPActivityExternalEventListener)
            {
                $eventHandler->onExternalEvent($eventParameters);
            }
        }
    }
 
    private function syncStatus(int $status): void
    {
        if ($status < CBPWorkflowStatus::Completed) // skip Created and Running
        {
            return;
        }
 
        WorkflowUserTable::syncOnWorkflowUpdated($this, $status);
    }

    public function addEventHandler($eventName, IBPActivityExternalEventListener $eventHandler)
    {
        if (!is_array($this->rootActivity->arEventsMap))
        {
            $this->rootActivity->arEventsMap = [];
        }
 
        if (!array_key_exists($eventName, $this->rootActivity->arEventsMap))
        {
            $this->rootActivity->arEventsMap[$eventName] = [];
        }
 
        $this->rootActivity->arEventsMap[$eventName][] = $eventHandler;
    }
 
    public function getEventsMap(): array
    {
        return is_array($this->rootActivity->arEventsMap) ? $this->rootActivity->arEventsMap : [];
    }

    public function removeEventHandler($eventName, IBPActivityExternalEventListener $eventHandler)
    {
        if (!is_array($this->rootActivity->arEventsMap))
        {
            $this->rootActivity->arEventsMap = [];
        }
 
        if (!array_key_exists($eventName, $this->rootActivity->arEventsMap))
        {
            $this->rootActivity->arEventsMap[$eventName] = [];
        }
 
        $idx = array_search($eventHandler, $this->rootActivity->arEventsMap[$eventName], true);
        if ($idx !== false)
        {
            unset($this->rootActivity->arEventsMap[$eventName][$idx]);
        }
 
        if (count($this->rootActivity->arEventsMap[$eventName]) <= 0)
        {
            unset($this->rootActivity->arEventsMap[$eventName]);
        }
    }
 
    public function isDebug(): bool
    {
        return false;
    }
}