controller.php

<?php
 
namespace Bitrix\Main\Engine;
 
use Bitrix\Main\Application;
use Bitrix\Main\Component\ParameterSigner;
use Bitrix\Main\Config\Configuration;
use Bitrix\Main\Diag\ExceptionHandlerFormatter;
use Bitrix\Main\Engine\AutoWire\BinderArgumentException;
use Bitrix\Main\Engine\AutoWire\Parameter;
use Bitrix\Main\Engine\Contract\Controllerable;
use Bitrix\Main\Engine\Response\Converter;
use Bitrix\Main\Error;
use Bitrix\Main\ErrorCollection;
use Bitrix\Main\Errorable;
use Bitrix\Main\ArgumentNullException;
use Bitrix\Main\ArgumentTypeException;
use Bitrix\Main\Context;
use Bitrix\Main\Event;
use Bitrix\Main\EventManager;
use Bitrix\Main\EventResult;
use Bitrix\Main\HttpResponse;
use Bitrix\Main\Request;
use Bitrix\Main\Response;
use Bitrix\Main\Security\Sign\BadSignatureException;
use Bitrix\Main\SystemException;
use Bitrix\Main\Web\FileDecodeFilter;
use Bitrix\Main\Web\PostDecodeFilter;
use Bitrix\Main\Web\Uri;
 
class Controller implements Errorable, Controllerable
{
    public const SCOPE_REST = 'rest';
    public const SCOPE_AJAX = 'ajax';
    public const SCOPE_CLI  = 'cli';
 
    public const EVENT_ON_BEFORE_ACTION = 'onBeforeAction';
    public const EVENT_ON_AFTER_ACTION  = 'onAfterAction';
 
    public const ERROR_REQUIRED_PARAMETER = 'MAIN_CONTROLLER_22001';
    public const ERROR_UNKNOWN_ACTION     = 'MAIN_CONTROLLER_22002';
 
    public const EXCEPTION_UNKNOWN_ACTION = 22002;
 
    protected $errorCollection;
    protected $request;
    protected Configurator $configurator;
    private Action $currentAction;
    private array $eventHandlersIds = [
        'prefilters' => [],
        'postfilters' => [],
    ];
    private $configurationOfActions = null;
    private string $scope;
    private $currentUser;
    private Converter $converter;
    private $filePath;
    private $sourceParametersList;
    private $unsignedParameters;
 
 
    final public static function className(): string
    {
        return static::class;
    }
 
    public function __construct(Request $request = null)
    {
        $this->scope = self::SCOPE_AJAX;
        $this->errorCollection = new ErrorCollection;
        $this->request = $request?: Context::getCurrent()->getRequest();
        $this->configurator = new Configurator();
        $this->converter = Converter::toJson();
 
        $this->init();
    }
 
    public function forward($controller, string $actionName, array $parameters = null)
    {
        if (is_string($controller))
        {
            $controller = new $controller;
        }
 
        //propbably should refactor with ControllerBuilder::build
 
        // override parameters
        $controller->request = $this->getRequest();
        $controller->setScope($this->getScope());
        $controller->setCurrentUser($this->getCurrentUser() ?? CurrentUser::get());
 
        $currentAction = $this->getCurrentAction();
        $this->detachFilters($currentAction);
 
        // run action
        $result = $controller->run(
            $actionName,
            $parameters === null ? $this->getSourceParametersList() : [$parameters]
        );
 
        $this->attachFilters($currentAction);
        $this->addErrors($controller->getErrors());
 
        return $result;
    }
 
    protected function init()
    {
        $this->buildConfigurationOfActions();
    }
 
    final public function getConfigurationOfActions()
    {
        return $this->configurationOfActions;
    }
 
    final public function getModuleId()
    {
        return getModuleId($this->getFilePath());
    }
 
    private function getCurrentAction(): Action
    {
        return $this->currentAction;
    }
 
    private function setCurrentAction(Action $currentAction): self
    {
        $this->currentAction = $currentAction;
 
        return $this;
    }
 
    final public function isLocatedUnderPsr4(): bool
    {
        // do not lower if probably psr4
        $firstLetter = mb_substr(basename($this->getFilePath()), 0, 1);
 
        return $firstLetter !== mb_strtolower($firstLetter);
    }
 
    final protected function getFilePath()
    {
        if (!$this->filePath)
        {
            $reflector = new \ReflectionClass($this);
            $this->filePath = preg_replace('#[\\\/]+#', '/', $reflector->getFileName());
        }
 
        return $this->filePath;
    }
 
    final public function getActionUri(string $actionName, array $params = [], bool $absolute = false): Uri
    {
        if (strpos($this->getFilePath(), '/components/') === false)
        {
            return UrlManager::getInstance()->createByController($this, $actionName, $params, $absolute);
        }
 
        return UrlManager::getInstance()->createByComponentController($this, $actionName, $params, $absolute);
    }
 
    final public function getUnsignedParameters()
    {
        return $this->unsignedParameters;
    }
 
    final protected function processUnsignedParameters(): void
    {
        foreach ($this->getSourceParametersList() as $source)
        {
            $signedParameters = $source['signedParameters'] ?? null;
            if (is_string($signedParameters))
            {
                try
                {
                    $this->unsignedParameters = ParameterSigner::unsignParameters(
                        $this->getSaltToUnsign(),
                        $signedParameters
                    );
                }
                catch (BadSignatureException $exception)
                {}
 
                return;
            }
        }
    }
 
    protected function getSaltToUnsign()
    {
        foreach ($this->getSourceParametersList() as $source)
        {
            if (isset($source['c']) && is_string($source['c']))
            {
                return $source['c'];
            }
        }
 
        return null;
    }
 
    final public function getCurrentUser(): ?CurrentUser
    {
        return $this->currentUser;
    }
 
    final public function setCurrentUser(CurrentUser $currentUser): void
    {
        $this->currentUser = $currentUser;
    }
 
    public function convertKeysToCamelCase($data)
    {
        return $this->converter->process($data);
    }
 
    final public function listNameActions(): array
    {
        $actions = array_keys($this->getConfigurationOfActions());
        $lengthSuffix = mb_strlen(self::METHOD_ACTION_SUFFIX);
 
        $class = new \ReflectionClass($this);
        foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method)
        {
            $probablySuffix = mb_substr($method->getName(), -$lengthSuffix);
            if ($probablySuffix === self::METHOD_ACTION_SUFFIX)
            {
                $actions[] = mb_strtolower(mb_substr($method->getName(), 0, -$lengthSuffix));
            }
        }
 
        return array_unique($actions);
    }
 
    public function configureActions()
    {
        return [];
    }
 
    public function getAutoWiredParameters()
    {
        return [];
    }
 
    public function getPrimaryAutoWiredParameter()
    {
        return null;
    }
 
    final public function getDefaultAutoWiredParameters()
    {
        return [];
    }
 
    private function buildConfigurationOfActions(): void
    {
        $this->configurationOfActions = $this->configurator->getConfigurationByController($this);
    }
 
    final public function getRequest()
    {
        return $this->request;
    }
 
    final public function getScope()
    {
        return $this->scope;
    }
 
    final public function setScope($scope)
    {
        $this->scope = $scope;
 
        return $this;
    }
 
    final public function getSourceParametersList()
    {
        return $this->sourceParametersList;
    }
 
    final public function setSourceParametersList($sourceParametersList)
    {
        $this->sourceParametersList = $sourceParametersList;
 
        return $this;
    }
 
    final public function run($actionName, array $sourceParametersList)
    {
        $this->collectDebugInfo();
 
        $result = null;
 
        try
        {
            $this->setSourceParametersList($sourceParametersList);
            $this->processUnsignedParameters();
 
            $action = $this->create($actionName);
            if (!$action)
            {
                throw new SystemException("Could not create action by name {$actionName}");
            }
            $this->setCurrentAction($action);
 
            $this->attachFilters($action);
            if ($this->shouldDecodePostData($action))
            {
                $this->decodePostData();
            }
 
            if ($this->prepareParams() &&
                $this->processBeforeAction($action) === true &&
                $this->triggerOnBeforeAction($action) === true)
            {
                $result = $action->runWithSourceParametersList();
 
                if ($action instanceof Errorable)
                {
                    $this->errorCollection->add($action->getErrors());
                }
            }
 
            $result = $this->triggerOnAfterAction($action, $result);
            $probablyResult = $this->processAfterAction($action, $result);
            if ($probablyResult !== null)
            {
                $result = $probablyResult;
            }
        }
        catch (\Throwable $e)
        {
            $this->runProcessingThrowable($e);
            $this->processExceptionInDebug($e);
        }
        finally
        {
            if (isset($action))
            {
                $this->detachFilters($action);
            }
        }
 
        $this->logDebugInfo();
 
        return $result;
    }
 
    protected function writeToLogException(\Throwable $e)
    {
        $exceptionHandler = Application::getInstance()->getExceptionHandler();
        $exceptionHandler->writeToLog($e);
    }
 
    private function processExceptionInDebug(\Throwable $e)
    {
        if ($this->shouldWriteToLogException($e))
        {
            $this->writeToLogException($e);
        }
 
        $exceptionHandling = Configuration::getValue('exception_handling');
        if (!empty($exceptionHandling['debug']))
        {
            $this->addError(new Error(ExceptionHandlerFormatter::format($e)));
            if ($e->getPrevious())
            {
                $this->addError(new Error(ExceptionHandlerFormatter::format($e->getPrevious())));
            }
        }
    }
 
    private function shouldWriteToLogException(\Throwable $e): bool
    {
        if ($e instanceof BinderArgumentException)
        {
            return false;
        }
 
        if ($e instanceof SystemException && ($e->getCode() === self::EXCEPTION_UNKNOWN_ACTION))
        {
            return false;
        }
 
        return true;
    }
 
    final public static function getFullEventName($eventName): string
    {
        return static::class . '::' . $eventName;
    }
 
    final protected function collectDebugInfo(): void
    {
    }
 
    final protected function logDebugInfo(): void
    {
    }
 
    protected function prepareParams()
    {
        return true;
    }
 
    protected function processBeforeAction(Action $action)
    {
        return true;
    }
 
    protected function shouldDecodePostData(Action $action): bool
    {
        return $this->request->isPost();
    }
 
    final protected function decodePostData(): void
    {
        \CUtil::jSPostUnescape();
        $this->request->addFilter(new PostDecodeFilter);
        $this->request->addFilter(new FileDecodeFilter);
    }
 
    final protected function triggerOnBeforeAction(Action $action): bool
    {
        $event = new Event(
            'main',
            static::getFullEventName(static::EVENT_ON_BEFORE_ACTION),
            [
                'action' => $action,
                'controller' => $this,
            ]
        );
        $event->send($this);
 
        $allow = true;
        foreach ($event->getResults() as $eventResult)
        {
            if ($eventResult->getType() != EventResult::SUCCESS)
            {
                $handler = $eventResult->getHandler();
                if ($handler instanceof Errorable)
                {
                    $this->errorCollection->add($handler->getErrors());
                }
 
                $allow = false;
            }
        }
 
        $this->detachPreFilters($action);
 
        return $allow;
    }
 
    protected function processAfterAction(Action $action, $result)
    {}
 
    public function finalizeResponse(Response $response)
    {}
 
    final protected function triggerOnAfterAction(Action $action, $result)
    {
        $event = new Event(
            'main',
            static::getFullEventName(static::EVENT_ON_AFTER_ACTION),
            [
                'result' => $result,
                'action' => $action,
                'controller' => $this,
            ]
        );
        $event->send($this);
 
        $this->detachPostFilters($action);
 
        return $event->getParameter('result');
    }
 
    final public function generateActionMethodName($action): string
    {
        return $action . self::METHOD_ACTION_SUFFIX;
    }
 
    protected function create($actionName)
    {
        $config = $this->getActionConfig($actionName);
        $methodName = $this->generateActionMethodName($actionName);
 
        if (method_exists($this, $methodName))
        {
            $method = new \ReflectionMethod($this, $methodName);
            if ($method->isPublic() && mb_strtolower($method->getName()) === mb_strtolower($methodName))
            {
                return new InlineAction($actionName, $this, $config);
            }
        }
        else
        {
            if (!$config && ($this instanceof Contract\FallbackActionInterface))
            {
                return new FallbackAction($actionName, $this, []);
            }
            if (!$config)
            {
                throw new SystemException(
                    "Could not find description of {$actionName} in {$this::className()}",
                    self::EXCEPTION_UNKNOWN_ACTION
                );
            }
 
            return $this->buildActionInstance($actionName, $config);
        }
 
        return null;
    }
 
    final protected function buildActionInstance($actionName, array $config): Action
    {
        if (isset($config['callable']))
        {
            $callable = $config['callable'];
            if (!is_callable($callable))
            {
                throw new ArgumentTypeException('callable', 'callable');
            }
 
            return new ClosureAction($actionName, $this, $callable);
        }
 
        if (empty($config['class']))
        {
            throw new SystemException(
                "Could not find class in description of {$actionName} in {$this::className()} to create instance",
                self::EXCEPTION_UNKNOWN_ACTION
            );
        }
 
        return new $config['class']($actionName, $this, $config);
    }
 
    final protected function existsAction($actionName): bool
    {
        try
        {
            $action = $this->create($actionName);
        }
        catch (SystemException $e)
        {
            if ($e->getCode() !== Controller::EXCEPTION_UNKNOWN_ACTION)
            {
                throw $e;
            }
        }
 
        return isset($action);
    }
 
    protected function getDefaultPreFilters()
    {
        return [
            new ActionFilter\Authentication(),
            new ActionFilter\HttpMethod(
                [ActionFilter\HttpMethod::METHOD_GET, ActionFilter\HttpMethod::METHOD_POST]
            ),
            new ActionFilter\Csrf(),
        ];
    }
 
    protected function getDefaultPostFilters()
    {
        return [];
    }
 
    final protected function buildFilters(array $config = null): array
    {
        if ($config === null)
        {
            $config = [];
        }
 
        if (!isset($config['prefilters']))
        {
            $config['prefilters'] = $this->configurator->wrapFiltersClosure(
                $this->getDefaultPreFilters()
            );
        }
        if (!isset($config['postfilters']))
        {
            $config['postfilters'] = $this->configurator->wrapFiltersClosure(
                $this->getDefaultPostFilters()
            );
        }
 
        $hasPostMethod = $hasCsrfCheck = false;
        foreach ($config['prefilters'] as $filter)
        {
            if ($filter instanceof ActionFilter\HttpMethod && $filter->containsPostMethod())
            {
                $hasPostMethod = true;
            }
            if ($filter instanceof ActionFilter\Csrf)
            {
                $hasCsrfCheck = true;
            }
        }
 
        if ($hasPostMethod && !$hasCsrfCheck && $this->request->isPost())
        {
            $config['prefilters'][] = new ActionFilter\Csrf;
        }
 
        if (!empty($config['-prefilters']))
        {
            $config['prefilters'] = $this->removeFilters($config['prefilters'], $config['-prefilters']);
        }
 
        if (!empty($config['-postfilters']))
        {
            $config['postfilters'] = $this->removeFilters($config['postfilters'], $config['-postfilters']);
        }
 
        if (!empty($config['+prefilters']))
        {
            $config['prefilters'] = $this->appendFilters($config['prefilters'], $config['+prefilters']);
        }
 
        if (!empty($config['+postfilters']))
        {
            $config['postfilters'] = $this->appendFilters($config['postfilters'], $config['+postfilters']);
        }
 
        return $config;
    }
 
    final protected function appendFilters(array $filters, array $filtersToAppend): array
    {
        return array_merge($filters, $filtersToAppend);
    }
 
    final protected function removeFilters(array $filters, array $filtersToRemove): array
    {
        $cleanedFilters = [];
        foreach ($filters as $filter)
        {
            $found = false;
            foreach ($filtersToRemove as $filterToRemove)
            {
                if (is_a($filter, $filterToRemove))
                {
                    $found = true;
                    break;
                }
            }
 
            if (!$found)
            {
                $cleanedFilters[] = $filter;
            }
        }
 
        return $cleanedFilters;
    }
 
    final protected function attachFilters(Action $action): void
    {
        $modifiedConfig = $this->buildFilters(
            $this->getActionConfig($action->getName())
        );
 
        $eventManager = EventManager::getInstance();
        foreach ($modifiedConfig['prefilters'] as $filter)
        {
            if (!in_array($this->getScope(), $filter->listAllowedScopes(), true))
            {
                continue;
            }
 
            $filter->bindAction($action);
 
            $this->eventHandlersIds['prefilters'][] = $eventManager->addEventHandler(
                'main',
                static::getFullEventName(static::EVENT_ON_BEFORE_ACTION),
                [$filter, 'onBeforeAction']
            );
        }
 
        foreach ($modifiedConfig['postfilters'] as $filter)
        {
            if (!in_array($this->getScope(), $filter->listAllowedScopes(), true))
            {
                continue;
            }
 
            $filter->bindAction($action);
 
            $this->eventHandlersIds['postfilters'][] = $eventManager->addEventHandler(
                'main',
                static::getFullEventName(static::EVENT_ON_AFTER_ACTION),
                [$filter, 'onAfterAction']
            );
        }
    }
 
    final protected function detachFilters(Action $action): void
    {
        $this->detachPreFilters($action);
        $this->detachPostFilters($action);
    }
 
    final protected function detachPreFilters(Action $action): void
    {
        $eventManager = EventManager::getInstance();
        foreach ($this->eventHandlersIds['prefilters'] as $handlerId)
        {
            $eventManager->removeEventHandler(
                'main',
                static::getFullEventName(static::EVENT_ON_BEFORE_ACTION),
                $handlerId
            );
        }
 
        $this->eventHandlersIds['prefilters'] = [];
    }
 
    final protected function detachPostFilters(Action $action): void
    {
        $eventManager = EventManager::getInstance();
        foreach ($this->eventHandlersIds['postfilters'] as $handlerId)
        {
            $eventManager->removeEventHandler(
                'main',
                static::getFullEventName(static::EVENT_ON_AFTER_ACTION),
                $handlerId
            );
        }
 
        $this->eventHandlersIds['postfilters'] = [];
    }
 
    final protected function getActionConfig($actionName): ?array
    {
        $listOfActions = array_change_key_case($this->configurationOfActions, CASE_LOWER);
        $actionName = mb_strtolower($actionName);
 
        if (!isset($listOfActions[$actionName]))
        {
            return null;
        }
 
        return $listOfActions[$actionName];
    }
 
    final protected function setActionConfig($actionName, array $config = null): self
    {
        $this->configurationOfActions[$actionName] = $config;
 
        return $this;
    }
 
    protected function runProcessingThrowable(\Throwable $throwable)
    {
        if ($throwable instanceof BinderArgumentException)
        {
            $this->runProcessingBinderThrowable($throwable);
        }
        elseif ($throwable instanceof \Exception)
        {
            $this->runProcessingException($throwable);
        }
        elseif ($throwable instanceof \Error)
        {
            $this->runProcessingError($throwable);
        }
    }
 
    protected function runProcessingException(\Exception $e)
    {
        //      throw $e;
        $this->errorCollection[] = $this->buildErrorFromException($e);
    }
 
    protected function runProcessingError(\Error $error)
    {
        //      throw $error;
        $this->errorCollection[] = $this->buildErrorFromPhpError($error);
    }
 
    protected function runProcessingBinderThrowable(BinderArgumentException $e): void
    {
        $currentControllerErrors = $this->getErrors();
        $errors = $e->getErrors();
        if ($errors)
        {
            foreach ($errors as $error)
            {
                if (in_array($error, $currentControllerErrors, true))
                {
                    continue;
                }
 
                $this->addError($error);
            }
        }
        else
        {
            $this->runProcessingException($e);
        }
    }
 
    protected function buildErrorFromException(\Exception $e)
    {
        if ($e instanceof ArgumentNullException)
        {
            return new Error($e->getMessage(), self::ERROR_REQUIRED_PARAMETER);
        }
 
        return new Error($e->getMessage(), $e->getCode());
    }
 
    protected function buildErrorFromPhpError(\Error $error)
    {
        return new Error($error->getMessage(), $error->getCode());
    }
 
    protected function runProcessingIfUserNotAuthorized()
    {
        $this->addError(new Error('User is not authorized'));
 
        throw new SystemException('User is not authorized');
    }
 
    protected function runProcessingIfInvalidCsrfToken()
    {
        $this->addError(new Error('Invalid csrf token'));
 
        throw new SystemException('Invalid csrf token');
    }
 
    public function redirectTo($url): HttpResponse
    {
        return Context::getCurrent()->getResponse()->redirectTo($url);
    }
 
    protected function addError(Error $error)
    {
        $this->errorCollection[] = $error;
 
        return $this;
    }
 
    protected function addErrors(array $errors)
    {
        $this->errorCollection->add($errors);
 
        return $this;
    }
 
    final public function getErrors()
    {
        return $this->errorCollection->toArray();
    }
 
    final public function getErrorByCode($code)
    {
        return $this->errorCollection->getErrorByCode($code);
    }
}