WorkflowStateService.php

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

<?php
 
namespace Bitrix\Bizproc\Api\Service;
 
use Bitrix\Bizproc\Api\Data\WorkflowStateService\WorkflowStateToGet;
use Bitrix\Bizproc\Api\Request\WorkflowAccessService\CanViewTimelineRequest;
use Bitrix\Bizproc\Api\Request\WorkflowStateService\GetAverageWorkflowDurationRequest;
use Bitrix\Bizproc\Api\Request\WorkflowStateService\GetExecutionTimeRequest;
use Bitrix\Bizproc\Api\Request\WorkflowStateService\GetEfficiencyDataRequest;
use Bitrix\Bizproc\Api\Request\WorkflowStateService\GetTimelineRequest;
use Bitrix\Bizproc\Api\Response\Error;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetAverageWorkflowDurationResponse;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetExecutionTimeResponse;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetEfficiencyDataResponse;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetFullFilledListResponse;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetListResponse;
use Bitrix\Bizproc\Api\Response\WorkflowStateService\GetTimelineResponse;
use Bitrix\Bizproc\Workflow\Entity\EO_WorkflowState_Collection;
use Bitrix\Bizproc\Workflow\Entity\WorkflowDurationStatTable;
use Bitrix\Bizproc\Workflow\Entity\WorkflowInstanceTable;
use Bitrix\Bizproc\Workflow\Entity\WorkflowStateTable;
use Bitrix\Bizproc\Workflow\Entity\WorkflowUserTable;
use Bitrix\Bizproc\Workflow\Task\EO_Task_Collection;
use Bitrix\Bizproc\Workflow\Task\TaskTable;
use Bitrix\Bizproc\Workflow\Timeline;
use Bitrix\Bizproc\Workflow\WorkflowState;
use Bitrix\Main\SystemException;
use Bitrix\Main\Type\DateTime;
 
class WorkflowStateService
{
    private const CONVERTER_VERSION = 2;
 
    private const THREE_DAYS_IN_SECONDS = 259200; // 3600 * 24 *3
 
    public function getList(WorkflowStateToGet $toGet): GetListResponse
    {
        $this->convertProcesses($toGet->getFilterUserId());
 
        $response = new GetListResponse();
        $responseCollection = new EO_WorkflowState_Collection();
 
        $query = WorkflowUserTable::query()
            ->addSelect('WORKFLOW_ID')
            ->addSelect('MODIFIED')
            ->setFilter($toGet->getOrmFilter())
            ->setOrder($toGet->getOrder())
            ->setLimit($toGet->getLimit())
            ->setOffset($toGet->getOffset())
            ->countTotal($toGet->isCountingTotal())
        ;
        $runtimeField = $toGet->getOrmRuntime();
 
        if ($runtimeField)
        {
            $query->registerRuntimeField($runtimeField);
        }
 
        $queryResult = $query->exec();
 
        if ($toGet->isCountingTotal())
        {
            $response->setTotalCount($queryResult->getCount());
        }
        $workflowStates = $queryResult->fetchAll();
        $ids = array_column($workflowStates, 'WORKFLOW_ID');
        $mods = array_column($workflowStates, 'MODIFIED');
 
        if ($ids)
        {
            $query = WorkflowStateTable::query()->setSelect($toGet->getSelect());
            if (count($ids) === 1)
            {
                $query->where('ID', '=', $ids[0]);
            }
            else
            {
                $query->whereIn('ID', $ids);
            }
 
            $collection = $query->exec()->fetchCollection();
 
            foreach ($ids as $k => $id)
            {
                $workflowState = $collection->getByPrimary($id);
                if ($workflowState)
                {
                    $responseCollection->add($workflowState);
                    $response->setUserModified($id, $mods[$k]);
                    $workflowTasks = $this->getWorkflowTasks($workflowState, $toGet);
                    if (isset($workflowTasks))
                    {
                        $response->setWorkflowTasks($id, $workflowTasks);
                    }
                }
            }
        }
 
        return $response->setWorkflowStatesCollection($responseCollection);
    }
 
    private function getWorkflowTasks(WorkflowState $workflowState, WorkflowStateToGet $toGet): ?EO_Task_Collection
    {
        $taskFields = $toGet->getSelectTaskFields();
        if ($taskFields)
        {
            $activeTasksQuery = TaskTable::query()
                ->setSelect($taskFields)
                ->setFilter([
                    '=WORKFLOW_ID' => $workflowState->getId(),
                    '=TASK_USERS.USER_ID' => $toGet->getFilterUserId(),
                    '=TASK_USERS.STATUS' => \CBPTaskUserStatus::Waiting,
                ])
                ->setOrder(['ID' => 'DESC'])
            ;
 
            $taskLimit = $toGet->getSelectTaskLimit();
            if (isset($taskLimit))
            {
                $activeTasksQuery->setLimit($taskLimit);
            }
 
            $userActiveTasks = $activeTasksQuery->exec()->fetchCollection();
 
            $remainingTasksCount = null;
            if (isset($taskLimit))
            {
                $remainingTasksCount = $taskLimit - $userActiveTasks->count();
            }
 
            if (isset($remainingTasksCount) && $remainingTasksCount <= 0)
            {
                return $userActiveTasks;
            }
 
            $workflowTasksQuery = TaskTable::query()
                ->setSelect($taskFields)
                ->setFilter([
                    '=WORKFLOW_ID' => $workflowState->getId(),
                    [
                        'LOGIC' => 'OR',
                        '!=TASK_USERS.USER_ID' => $toGet->getFilterUserId(),
                        '!=TASK_USERS.STATUS' => \CBPTaskUserStatus::Waiting,
                    ],
                ])
                ->setOrder(['ID' => 'DESC'])
            ;
 
            if (isset($remainingTasksCount))
            {
                $workflowTasksQuery->setLimit($remainingTasksCount);
            }
 
            return $userActiveTasks->merge($workflowTasksQuery->exec()->fetchCollection());
        }
 
        return null;
    }
 
    public function getFullFilledList(WorkflowStateToGet $toGet): GetFullFilledListResponse
    {
        $response = new GetFullFilledListResponse();
 
        $toGet->setSelectAllFields();
        $getListResult = $this->getList($toGet);
        $collection = $getListResult->getWorkflowStatesCollection();
        if (!$collection)
        {
            return $response->setWorkflowStatesList([]);
        }
 
        $fullFilledList = [];
        $userIds = [];
        foreach ($collection as $stateElement)
        {
            $tasksInfo = $stateElement->getTasksInfo();
            foreach ($tasksInfo as $task)
            {
                if (!empty($task['TASK_USERS']))
                {
                    foreach ($task['TASK_USERS'] as $row)
                    {
                        $userIds[$row['USER_ID']] = true;
                        $userIds[$row['ORIGINAL_USER_ID']] = true;
                    }
                }
            }
 
            $fullFilledList[] = [
                'ID' => $stateElement->getId(),
                'STARTED' => $stateElement->getStarted(),
                'MODIFIED' => $stateElement->getModified(),
                'STATE_INFO' => $stateElement->getStateInfo(),
                'DOCUMENT_INFO' => $this->getDocumentInfo($stateElement->getComplexDocumentId()),
                'STARTED_USER_INFO' => [
                    'ID' => $stateElement->getStartedBy(),
                ],
                'TASKS_INFO' => $tasksInfo,
                'WORKFLOW_TEMPLATE_ID' => $stateElement->getWorkflowTemplateId(),
                'TEMPLATE_NAME' => $stateElement->getTemplate()?->getName(),
                'META' => $stateElement->getMeta()?->collectValues() ?? [],
            ];
 
            $userIds[$stateElement->getStartedBy()] = true;
        }
 
        return (
            $response
                ->setWorkflowStatesList($fullFilledList)
                ->setMembersInfo($this->getMembersInfo(array_keys($userIds)))
        );
    }
 
    public function getTimeline(GetTimelineRequest $request): GetTimelineResponse
    {
        if (!$request->workflowId)
        {
            return GetTimelineResponse::createError(Error::fromCode(Error::WORKFLOW_NOT_FOUND));
        }
 
        $isAdmin = (new \CBPWorkflowTemplateUser($request->userId))->isAdmin();
 
        if (!$isAdmin)
        {
            $accessService = new WorkflowAccessService();
            $accessRequest = new CanViewTimelineRequest(workflowId: $request->workflowId, userId: $request->userId);
 
            $accessResponse = $accessService->canViewTimeline($accessRequest);
            if (!$accessResponse->isSuccess())
            {
                return (new GetTimelineResponse())->addErrors($accessResponse->getErrors());
            }
        }
 
        $timeline = Timeline::createByWorkflowId($request->workflowId);
 
        if (!$timeline)
        {
            return GetTimelineResponse::createError(Error::fromCode(Error::WORKFLOW_NOT_FOUND));
        }
 
        return GetTimelineResponse::createOk(['timeline' => $timeline->setUserId($request->userId)]);
    }
 
    private function getDocumentInfo(array $complexDocumentId): array
    {
        $documentService = \CBPRuntime::getRuntime()->getDocumentService();
 
        $key = null;
        try
        {
            $complexDocumentType = $documentService->getDocumentType($complexDocumentId);
            if ($complexDocumentType)
            {
                $key = $complexDocumentId[0] . '@' . $complexDocumentId[1] . '@' . $complexDocumentType[2];
            }
        }
        catch (SystemException | \Exception $exception)
        {
            $complexDocumentType = null;
        }
 
        static $cache = [];
        if ($key && !isset($cache[$key]))
        {
            $cache[$key] = $documentService->getDocumentTypeCaption($complexDocumentType);
        }
        $typeCaption = $key ? $cache[$key] : '';
 
        return [
            'COMPLEX_ID' => $complexDocumentId,
            'COMPLEX_TYPE' => $complexDocumentType,
            'NAME' => $documentService->getDocumentName($complexDocumentId),
            'TYPE_CAPTION' => $typeCaption,
        ];
    }
 
    private function getMembersInfo(array $ids): array
    {
        if (empty($ids))
        {
            return [];
        }
 
        $userFields = ['ID', 'NAME', 'SECOND_NAME', 'LAST_NAME', 'LOGIN', 'TITLE', 'EMAIL', 'PERSONAL_PHOTO'];
 
        $users = \CUser::GetList(
            'id',
            'asc',
            ['ID' => implode('|', $ids)],
            ['FIELDS' => $userFields]
        );
 
        $info = [];
        while ($user = $users->Fetch())
        {
            $fullName = \CUser::FormatName(\CSite::GetNameFormat(false), $user, true, false);
            $personalPhoto = (int)$user['PERSONAL_PHOTO'];
 
            $info[] = [
                'ID' => (int)($user['ID'] ?? 0),
                'FULL_NAME' => $fullName,
                'PERSONAL_PHOTO' => $personalPhoto,
            ];
        }
 
        return $info;
    }
 
    private function convertProcesses(int $userId)
    {
        if (empty($userId))
        {
            return;
        }
 
        $converterVersion = \CUserOptions::getOption(
            'bizproc',
            'processes_converted',
            0,
            $userId
        );
 
        if ($converterVersion === self::CONVERTER_VERSION)
        {
            return;
        }
 
        WorkflowUserTable::convertUserProcesses($userId);
 
        \CUserOptions::setOption(
            'bizproc',
            'processes_converted',
            self::CONVERTER_VERSION,
            false,
            $userId
        );
    }
 
    public function getAverageWorkflowDuration(
        GetAverageWorkflowDurationRequest $request
    ): GetAverageWorkflowDurationResponse
    {
        // rights? canUserOperateDocumentType(CBPCanUserOperateOperation::ReadDocument, ...)
 
        $response = new GetAverageWorkflowDurationResponse();
        if ($request->templateId <= 0)
        {
            $response->addError(new Error('incorrect template id'));
        }
 
        if ($response->isSuccess())
        {
            $averageDuration = WorkflowDurationStatTable::getAverageDurationByTemplateId($request->templateId);
            if ($averageDuration !== null)
            {
                $response->setAverageDuration($averageDuration);
            }
        }
 
        return $response;
    }
 
    public function getExecutionTime(GetExecutionTimeRequest $request): GetExecutionTimeResponse
    {
        $response = new GetExecutionTimeResponse();
 
        if ($request->workflowStarted === null)
        {
            return $response->addError(new Error('incorrect workflowStarted'));
        }
 
        $startedTimestamp = $request->workflowStarted?->getTimestamp();
        if (WorkflowInstanceTable::exists($request->workflowId))
        {
            $currentTimestamp = (new DateTime())->getTimestamp();
 
            return $response->setExecutionTime($currentTimestamp - $startedTimestamp);
        }
 
        $modifiedTimestamp = $request->workflowModified->getTimestamp();
 
        return $response->setExecutionTime($modifiedTimestamp - $startedTimestamp);
    }
 
    public function getCompletedWorkflowEfficiency(string $workflowId): GetEfficiencyDataResponse
    {
        $workflow = WorkflowStateTable::query()
            ->setSelect([
                'ID',
                'MODIFIED',
                'STARTED',
                'WORKFLOW_TEMPLATE_ID',
            ])
            ->setFilter([
                '=ID' => $workflowId,
                '=STATE' => 'Completed',
            ])
            ->exec()
            ->fetchObject()
        ;
 
        if ($workflow)
        {
            $executionTime = $this->getExecutionTime(
                new GetExecutionTimeRequest(
                    workflowId: $workflow->getId(),
                    workflowStarted: $workflow->getStarted(),
                    workflowModified: $workflow->getModified()
                )
            )->getRoundedExecutionTime();
            $averageDuration = $this->getAverageWorkflowDuration(
                new GetAverageWorkflowDurationRequest(
                    templateId: $workflow->getWorkflowTemplateId(),
                )
            )->getRoundedAverageDuration();
            $request = new GetEfficiencyDataRequest(
                executionTime: $executionTime,
                averageDuration: $averageDuration ?? $executionTime
            );
 
            return $this->getEfficiencyData($request);
        }
 
        $response = new GetEfficiencyDataResponse();
        $response->addError(new Error('WorkflowState not found'));
 
        return $response;
    }
 
    public function getEfficiencyData(GetEfficiencyDataRequest $request): GetEfficiencyDataResponse
    {
        $response = new GetEfficiencyDataResponse();
 
        $averageDuration = $request->averageDuration;
        $currentDuration = $request->executionTime;
 
        $efficiency = 'stopped';
        if (null === $averageDuration)
        {
            $efficiency = 'first';
        }
        elseif ($currentDuration <= $averageDuration)
        {
            $efficiency = 'fast';
        }
        elseif ($currentDuration <= ($averageDuration + self::THREE_DAYS_IN_SECONDS))
        {
            $efficiency = 'slow';
        }
 
        $response->setAverageDuration($request->averageDuration);
        $response->setExecutionTime($request->executionTime);
        $response->setEfficiency($efficiency);
 
        return $response;
    }
}