WorkflowService.php

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

<?php
 
namespace Bitrix\Lists\Api\Service;
 
use Bitrix\Bizproc\Workflow\Entity\EO_WorkflowMetadata;
use Bitrix\Lists\Api\Request\WorkflowService\StartWorkflowsRequest;
use Bitrix\Lists\Api\Response\Response;
use Bitrix\Lists\Api\Response\WorkflowService\GetParameterValuesResponse;
use Bitrix\Lists\Api\Response\WorkflowService\StartWorkflowsResponse;
use Bitrix\Main\Error;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
 
final class WorkflowService
{
    private string $iBlockTypeId;
    private bool $isBpEnabled;
    private ?array $complexDocumentType;
 
    public function __construct(array $iBlockInfo)
    {
        $this->iBlockTypeId = (string)($iBlockInfo['IBLOCK_TYPE_ID'] ?? '');
 
        $this->isBpEnabled = (
            Loader::includeModule('bizproc')
            && \CLists::isBpFeatureEnabled($this->iBlockTypeId)
            && (isset($iBlockInfo['BIZPROC']) && $iBlockInfo['BIZPROC'] === 'Y') // $iBlockInfo['BIZPROC'] != 'N'
        );
 
        $this->complexDocumentType = (
            $this->isBpEnabled
                ? \BizprocDocument::generateDocumentComplexType(
                    $this->iBlockTypeId,
                    max((int)($iBlockInfo['ID'] ?? 0), 0)
                )
                : null
        );
    }
 
    public function getSignedDocument(int $elementId): ?string
    {
        if ($this->isBpEnabled)
        {
            return \CBPDocument::signParameters([$this->complexDocumentType, (string)$elementId]);
        }
 
        return null;
    }
 
    public function canUserWriteDocument(int $elementId, int $userId, array $userGroups): bool
    {
        if ($elementId < 0 || $userId <= 0)
        {
            return false;
        }
 
        $canWrite = true;
        if ($this->isBpEnabled)
        {
            $complexDocumentId = $this->getComplexDocumentId($elementId);
 
            $operation = \CBPCanUserOperateOperation::WriteDocument;
            $parameters = ['AllUserGroups' => $userGroups];
 
            $canWrite = (
                $elementId > 0
                    ? \CBPDocument::canUserOperateDocument($operation, $userId, $complexDocumentId, $parameters)
                    : \CBPDocument::canUserOperateDocumentType($operation, $userId, $this->complexDocumentType, $parameters)
            );
        }
 
        return $canWrite;
    }
 
    public function canUserStartWorkflow(int $currentUserId, int $elementId, int $sectionId = 0): bool
    {
        if ($currentUserId <= 0 || $elementId < 0 || $sectionId < 0)
        {
            return false;
        }
 
        $canStart = true;
        if ($this->isBpEnabled)
        {
            $documentStates = $this->getDocumentStates($this->getComplexDocumentId($elementId));
 
            $canStart = \CBPDocument::canUserOperateDocumentType(
                \CBPCanUserOperateOperation::StartWorkflow,
                $currentUserId,
                $this->complexDocumentType,
                ['sectionId' => $sectionId, 'DocumentStates' => $documentStates]
            );
        }
 
        return $canStart;
    }
 
    public function isConstantsTuned(): bool
    {
        $isConstantsTuned = true;
        if ($this->isBpEnabled)
        {
            $templates = array_merge(
                \CBPWorkflowTemplateLoader::searchTemplatesByDocumentType(
                    $this->complexDocumentType, \CBPDocumentEventType::Create
                ),
                \CBPWorkflowTemplateLoader::searchTemplatesByDocumentType(
                    $this->complexDocumentType, \CBPDocumentEventType::Edit
                ),
            );
 
            foreach ($templates as $template)
            {
                if (!\CBPWorkflowTemplateLoader::isConstantsTuned($template['ID']))
                {
                    $isConstantsTuned = false;
 
                    break;
                }
            }
        }
 
        return $isConstantsTuned;
    }
 
    public function hasParameters(int $elementId): bool
    {
        $hasParameters = false;
        if ($this->isBpEnabled)
        {
            $states = $this->getNotRunningDocumentStates($elementId);
            foreach ($states as $state)
            {
                $parameters = $state['TEMPLATE_PARAMETERS'] ?? [];
                if (!empty($parameters) && is_array($parameters))
                {
                    $hasParameters = true;
 
                    break;
                }
            }
        }
 
        return $hasParameters;
    }
 
    public function getParameterValuesFromRequest(array $request, int $elementId): GetParameterValuesResponse
    {
        $response = new GetParameterValuesResponse();
 
        $parameters = [];
        if ($this->isBpEnabled && $elementId >= 0)
        {
            $documentStates = $this->getDocumentStates($this->getComplexDocumentId($elementId));
            foreach ($documentStates as $state)
            {
                if (empty($state['ID']))
                {
                    $errors = [];
                    $parameters[$state['TEMPLATE_ID']] = \CBPWorkflowTemplateLoader::checkWorkflowParameters(
                        $state['TEMPLATE_PARAMETERS'] ?? [],
                        $request[$state['TEMPLATE_ID']] ?? [],
                        $this->complexDocumentType,
                        $errors
                    );
 
                    foreach ($errors as $error)
                    {
                        $response->addError(new Error(!empty($error['message']) ? $error['message'] : ''));
                    }
                }
            }
        }
 
        return $response->setParameters($parameters);
    }
 
    public function startWorkflows(StartWorkflowsRequest $request): StartWorkflowsResponse
    {
        $response = new StartWorkflowsResponse();
 
        if ($request->elementId <= 0 || $request->currentUserId <= 0)
        {
            $response->addError(
                new Error(
                    Loc::getMessage('LISTS_LIB_API_WORKFLOW_SERVICE_INCORRECT_START_WORKFLOW_INPUT_DATA') ?? ''
                )
            );
        }
 
        $workflowIds = [];
        if ($this->isBpEnabled && $response->isSuccess())
        {
            $complexDocumentId = $this->getComplexDocumentId($request->elementId);
            $documentStates = $this->getDocumentStates($request->isNewElement ? null : $complexDocumentId);
            foreach ($documentStates as $state)
            {
                if (empty($state['ID']))
                {
                    $errors = [];
 
                    $startWorkflowParameters = [
                        \CBPDocument::PARAM_TAGRET_USER => 'user_' . $request->currentUserId,
                        \CBPDocument::PARAM_MODIFIED_DOCUMENT_FIELDS => $request->changedFields,
                    ];
 
                    $workflowIds[$state['TEMPLATE_ID']] = \CBPDocument::startWorkflow(
                        $state['TEMPLATE_ID'],
                        $complexDocumentId,
                        array_merge($request->parameters[$state['TEMPLATE_ID']] ?? [], $startWorkflowParameters),
                        $errors
                    );
 
                    if (!$errors && isset($request->timeToStart))
                    {
                        $metadata = new EO_WorkflowMetadata();
                        $metadata->setWorkflowId($workflowIds[$state['TEMPLATE_ID']]);
                        $metadata->setStartDuration($request->timeToStart);
                        $metadata->save();
                    }
 
                    foreach ($errors as $error)
                    {
                        $response->addError(new Error(!empty($error['message']) ? $error['message'] : ''));
                    }
                }
            }
        }
 
        return $response->setWorkflowIds($workflowIds);
    }
 
    public function getComplexDocumentId(int $elementId): ?array
    {
        if ($this->isBpEnabled)
        {
            return ($elementId > 0 ? \BizprocDocument::getDocumentComplexId($this->iBlockTypeId, $elementId) : null);
        }
 
        return null;
    }
 
    public function getComplexDocumentType(): ?array
    {
        return $this->complexDocumentType;
    }
 
    public function getDocumentStates(?array $complexDocumentId): array
    {
        if ($this->isBpEnabled)
        {
            return \CBPDocument::getDocumentStates($this->complexDocumentType, $complexDocumentId);
        }
 
        return [];
    }
 
    public function getNotRunningDocumentStates(int $elementId)
    {
        if (!$this->isBpEnabled)
        {
            return [];
        }
 
        $autoExecuteType = $elementId > 0 ? \CBPDocumentEventType::Edit: \CBPDocumentEventType::Create;
 
        return \CBPWorkflowTemplateLoader::getDocumentTypeStates($this->complexDocumentType, $autoExecuteType);
    }
 
    public function getDocumentTypeStates(): array
    {
        if (!$this->isBpEnabled)
        {
            return [];
        }
 
        $states = array_merge(
            \CBPWorkflowTemplateLoader::getDocumentTypeStates($this->complexDocumentType, \CBPDocumentEventType::Create),
            \CBPWorkflowTemplateLoader::getDocumentTypeStates($this->complexDocumentType, \CBPDocumentEventType::Edit),
        );
 
        $result = [];
        $templateIds = [];
        foreach ($states as $state)
        {
            $templateId = (int)$state['TEMPLATE_ID'];
            if (isset($templateIds[$templateId]))
            {
                continue;
            }
            $templateIds[$templateId] = true;
 
            $state['TEMPLATE_CONSTANTS'] = \CBPWorkflowTemplateLoader::getTemplateConstants($templateId);
            $result[] = $state;
        }
 
        return $result;
    }
 
    public function hasTemplatesOnStartup(?array $complexDocumentId = null): bool
    {
        if (!$this->isBpEnabled)
        {
            return false;
        }
 
        $templates = (
            $complexDocumentId
                ? \CBPWorkflowTemplateLoader::searchTemplatesByDocumentType(
                    $this->complexDocumentType, \CBPDocumentEventType::Edit
                )
                : \CBPWorkflowTemplateLoader::searchTemplatesByDocumentType(
                    $this->complexDocumentType, \CBPDocumentEventType::Create
                )
        );
 
        return !empty($templates);
    }
 
    public function getDocumentStatesWithParameters(int $elementId): array
    {
        if ($elementId < 0 || !$this->isBpEnabled)
        {
            return [];
        }
 
        $states = [];
        foreach ($this->getDocumentStates($this->getComplexDocumentId($elementId)) as $documentState)
        {
            $parameters = $documentState['TEMPLATE_PARAMETERS'] ?? [];
            if (!empty($parameters))
            {
                $states[] = $documentState;
            }
        }
 
        return $states;
    }
 
    public function getNotTunedDocumentTypeStates(): array
    {
        $notTuned = [];
        if ($this->isBpEnabled)
        {
            foreach ($this->getDocumentTypeStates() as $state)
            {
                $templateId = (int)$state['TEMPLATE_ID'];
                if (\CBPWorkflowTemplateLoader::isConstantsTuned($templateId))
                {
                    continue;
                }
 
                $notTuned[] = $state;
            }
        }
 
        return $notTuned;
    }
 
    public function setConstants(array $request): Response
    {
        $response = new Response();
 
        $properties = [];
        if ($this->isBpEnabled)
        {
            foreach ($this->getDocumentTypeStates() as $state)
            {
                $templateId = (int)$state['TEMPLATE_ID'];
                if (array_key_exists($templateId, $request) && is_array($state['TEMPLATE_CONSTANTS']))
                {
                    $errors = [];
                    $values = \CBPWorkflowTemplateLoader::checkWorkflowParameters(
                        $state['TEMPLATE_CONSTANTS'],
                        $request[$templateId] ?? [],
                        $this->complexDocumentType,
                        $errors
                    );
 
                    foreach ($errors as $error)
                    {
                        if (!empty($error['message']))
                        {
                            $response->addError(new Error($error['message']));
                        }
                    }
 
                    if (!$errors)
                    {
                        foreach ($state['TEMPLATE_CONSTANTS'] as $id => $property)
                        {
                            $property['Default'] = $values[$id] ?? null;
                            $properties[$templateId][$id] = $property;
                        }
                    }
                }
            }
 
            if ($response->isSuccess())
            {
                foreach ($properties as $templateId => $constants)
                {
                    \CBPWorkflowTemplateLoader::update($templateId, ['CONSTANTS' => $constants]);
                }
            }
        }
 
        return $response;
    }
}