basetrigger.php

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

<?php
namespace Bitrix\Bizproc\Automation\Trigger;
 
use Bitrix\Bizproc\Automation\Engine\ConditionGroup;
use Bitrix\Bizproc\Automation\Target\BaseTarget;
use Bitrix\Bizproc\Workflow\Template\WorkflowTemplateSettingsTable;
use Bitrix\Main;
 
class BaseTrigger
{
    protected $target;
    protected $returnValues;

    public static function className()
    {
        return get_called_class();
    }
 
    public static function isEnabled()
    {
        return true;
    }

    public function setTarget(BaseTarget $target)
    {
        $this->target = $target;
        return $this;
    }

    public function getTarget()
    {
        if ($this->target === null)
        {
            throw new Main\InvalidOperationException('Target must be set by setTarget method.');
        }
        return $this->target;
    }

    public static function getCode()
    {
        return 'BASE';
    }

    public static function getName()
    {
        return 'Base trigger';
    }
 
    public function send()
    {
        $this->runWorkflowTriggers();
 
        $applied = false;
        $triggers = $this->getPotentialTriggers();
        if ($triggers)
        {
            foreach ($triggers as $trigger)
            {
                if ($this->checkApplyRules($trigger))
                {
                    $this->applyTrigger($trigger);
                    $applied = true;
 
                    break;
                }
            }
        }
 
        return $applied;
    }
 
    protected function runWorkflowTriggers(): void
    {
        if (
            !\CBPRuntime::isFeatureEnabled()
            || !\Bitrix\Main\Config\Option::get('bizproc', 'bp_triggers', false)
        )
        {
            return;
        }
 
        try
        {
            [$module, $entity, $documentType] = \CBPHelper::parseDocumentId($this->target->getDocumentType());
        }
        catch (\CBPArgumentNullException $exception)
        {
            return;
        }
 
        $code = static::getCode();
        $triggers =
            WorkflowTemplateSettingsTable::query()
                ->setSelect(['TEMPLATE', 'TEMPLATE_ID'])
                ->where('NAME', "TRIGGER_$code")
                ->where('VALUE', 'Y')
                ->where('TEMPLATE.MODULE_ID', $module)
                ->where('TEMPLATE.ENTITY', $entity)
                ->where('TEMPLATE.DOCUMENT_TYPE', $documentType)
                ->exec()
                ->fetchCollection()
        ;
 
        if ($triggers)
        {
            $complexDocumentId = $this->target->getComplexDocumentId();
            foreach ($triggers as $trigger)
            {
                $errors = [];
                \CBPDocument::startWorkflow($trigger->getTemplateId(), $complexDocumentId, [], $errors);
            }
        }
    }
 
    protected function applyTrigger(array $trigger)
    {
        $statusId = $trigger['DOCUMENT_STATUS'];
 
        $target = $this->getTarget();
 
        $target->setAppliedTrigger($trigger);
        $target->setDocumentStatus($statusId);
        $target->getRuntime()->onDocumentStatusChanged();
 
        return true;
    }
 
    protected function getPotentialTriggers()
    {
        $triggers = [];
 
        $currentStatus = $this->getTarget()->getDocumentStatus();
        $allStatuses = array_keys($this->getTarget()->getDocumentStatusList());
 
        $needleKey = array_search($currentStatus, $allStatuses, false);
 
        if ($needleKey === false)
        {
            return $triggers;
        }
 
        $forwardStatuses = array_slice($allStatuses, $needleKey + 1);
        unset($allStatuses[$needleKey]);
 
        $code = static::getCode();
        $rows = [];
        $targetTriggers = $this->getTarget()->getTriggers($allStatuses);
 
        foreach ($targetTriggers as $row)
        {
            if ($row['CODE'] !== $code)
            {
                continue;
            }
 
            if (!in_array($row['DOCUMENT_STATUS'], $forwardStatuses, false))
            {
                if (
                    !isset($row['APPLY_RULES']['ALLOW_BACKWARDS'])
                    ||
                    $row['APPLY_RULES']['ALLOW_BACKWARDS'] !== 'Y'
                )
                {
                    continue;
                }
            }
 
            $rows[$row['DOCUMENT_STATUS']][] = $row;
        }
 
        if ($rows)
        {
            foreach ($allStatuses as $needleStatus)
            {
                if (isset($rows[$needleStatus]))
                {
                    $triggers[] = $rows[$needleStatus];
                }
            }
        }
 
        return array_merge(...$triggers);
    }
 
    public function checkApplyRules(array $trigger)
    {
        $conditionRules = $trigger['APPLY_RULES']['Condition'] ?? null;
 
        if ($conditionRules)
        {
            $conditionGroup = new ConditionGroup($conditionRules);
            $target = $this->getTarget();
            $result = $conditionGroup->evaluate($target);
 
            if ($result)
            {
                $target->setAppliedTriggerConditionResults($conditionGroup->getEvaluateResults());
            }
 
            return $result;
        }
 
        return true;
    }
 
    public function getReturnValues(): ?array
    {
        return $this->returnValues;
    }

    public function setReturnValues(array $values)
    {
        $this->returnValues = $values;
        return $this;
    }
 
    public static function getReturnProperties(): array
    {
        return [];
    }
 
    public static function toArray()
    {
        return [
            'NAME' => static::getName(),
            'CODE' => static::getCode(),
            'RETURN' => static::getReturnProperties(),
            'DESCRIPTION' => static::getDescription(),
            'GROUP' => static::getGroup(),
            'SETTINGS' => static::getSettings(),
        ];
    }
 
    public static function getDescription(): string
    {
        return '';
    }
 
    public static function getGroup(): array
    {
        return [];
    }
 
    protected static function getSettings(): ?array
    {
        $map = static::getPropertiesMap();
        if ($map)
        {
            return ['Properties' => array_values($map)];
        }
 
        return null;
    }
 
    protected static function getPropertiesMap(): array
    {
        return [];
    }
}