httpapplication.php

<?php
namespace Bitrix\Main;
 
use Bitrix\Main\Config\Configuration;
use Bitrix\Main\Engine\AutoWire;
use Bitrix\Main\Engine\Controller;
use Bitrix\Main\Engine\ControllerBuilder;
use Bitrix\Main\Engine\CurrentUser;
use Bitrix\Main\Engine\Response\AjaxJson;
use Bitrix\Main\Engine\Router;
use Bitrix\Main\Engine\JsonPayload;
use Bitrix\Main\UI\PageNavigation;
use Bitrix\Main\Web;
 
class HttpApplication extends Application
{
    public const EXCEPTION_UNKNOWN_CONTROLLER = 221001;
 
    protected function initializeContext(array $params)
    {
        $context = new HttpContext($this);
 
        $server = new Server($params['server']);
 
        $request = new HttpRequest(
            $server,
            $params['get'],
            $params['post'],
            $params['files'],
            $params['cookie']
        );
 
        $response = new HttpResponse();
 
        $context->initialize($request, $response, $server, ['env' => $params['env']]);
 
        $this->setContext($context);
    }
 
    public function createExceptionHandlerOutput()
    {
        return new Diag\HttpExceptionHandlerOutput();
    }
 
    public function start()
    {
        $this->context->getRequest()->decodeJson();
    }
 
    public function finish()
    {
    }
 
    private function getSourceParametersList()
    {
        if (!$this->context->getServer()->get('HTTP_BX_AJAX_QB'))
        {
            return array(
                $this->context->getRequest()->getPostList(),
                $this->context->getRequest()->getQueryList(),
            );
        }
 
        return array(
            Web\Json::decode($this->context->getRequest()->getPost('bx_data'))
        );
    }
 
    public function run()
    {
        try
        {
            $router = new Router($this->context->getRequest());
 
            [$controller, $actionName] = $router->getControllerAndAction();
            if (!$controller)
            {
                throw new SystemException('Could not find controller for the request', self::EXCEPTION_UNKNOWN_CONTROLLER);
            }
 
            $this->runController($controller, $actionName);
        }
        catch (\Throwable $e)
        {
            $errorCollection = new ErrorCollection();
 
            $this->processRunError($e, $errorCollection);
            $this->finalizeControllerResult($controller ?? null, null, $errorCollection);
        }
    }
 
    final public function runController($controller, $action): void
    {
        $result = null;
        $errorCollection = new ErrorCollection();
 
        try
        {
            if (is_string($controller))
            {
                $controller = ControllerBuilder::build($controller, [
                    'scope' => Controller::SCOPE_AJAX,
                    'currentUser' => CurrentUser::get(),
                ]);
            }
 
            $this->registerAutoWirings();
 
            $result = $controller->run($action, $this->getSourceParametersList());
            $errorCollection->add($controller->getErrors());
        }
        catch (\Throwable $e)
        {
            $this->processRunError($e, $errorCollection);
        }
        finally
        {
            $this->finalizeControllerResult($controller, $result, $errorCollection);
        }
    }
 
    private function finalizeControllerResult($controller, $result, ErrorCollection $errorCollection): void
    {
        $response = $this->buildResponse($result, $errorCollection);
        $response = $this->context->getResponse()->copyHeadersTo($response);
 
        if ($controller)
        {
            $controller->finalizeResponse($response);
        }
 
        $this->context->setResponse($response);
 
        //todo exit code in Response?
        $this->end(0, $response);
    }
 
    private function shouldWriteToLogException(\Throwable $e): bool
    {
        if ($e instanceof AutoWire\BinderArgumentException)
        {
            return false;
        }
 
        $unnecessaryCodes = [
            self::EXCEPTION_UNKNOWN_CONTROLLER,
            Router::EXCEPTION_INVALID_COMPONENT_INTERFACE,
            Router::EXCEPTION_INVALID_COMPONENT,
            Router::EXCEPTION_INVALID_AJAX_MODE,
            Router::EXCEPTION_NO_MODULE,
            Router::EXCEPTION_INVALID_MODULE_NAME,
            Router::EXCEPTION_INVALID_COMPONENT_NAME,
            Router::EXCEPTION_NO_COMPONENT,
            Router::EXCEPTION_NO_COMPONENT_AJAX_CLASS,
        ];
 
        if ($e instanceof SystemException && in_array($e->getCode(), $unnecessaryCodes, true))
        {
            return false;
        }
 
        return true;
    }
 
    private function processRunError(\Throwable $e, ErrorCollection $errorCollection): void
    {
        $errorCollection[] = new Error($e->getMessage(), $e->getCode());
        $exceptionHandling = Configuration::getValue('exception_handling');
        $debugMode = !empty($exceptionHandling['debug']);
        if ($debugMode)
        {
            $errorCollection[] = new Error(Diag\ExceptionHandlerFormatter::format($e));
            if ($e->getPrevious())
            {
                $errorCollection[] = new Error(Diag\ExceptionHandlerFormatter::format($e->getPrevious()));
            }
        }
 
        if ($debugMode || $this->shouldWriteToLogException($e))
        {
            $this->getExceptionHandler()->writeToLog($e);
        }
    }
 
    private function registerAutoWirings()
    {
        AutoWire\Binder::registerGlobalAutoWiredParameter(new AutoWire\Parameter(
            PageNavigation::class,
            static function() {
                $pageNavigation = new PageNavigation('nav');
                $pageNavigation
                    ->setPageSizes(range(1, 50))
                    ->initFromUri()
                ;
 
                return $pageNavigation;
            }
        ));
 
        AutoWire\Binder::registerGlobalAutoWiredParameter(new AutoWire\Parameter(
            JsonPayload::class,
            static function() {
                return new JsonPayload();
            }
        ));
 
        AutoWire\Binder::registerGlobalAutoWiredParameter(new AutoWire\Parameter(
            CurrentUser::class,
            static function() {
                return CurrentUser::get();
            }
        ));
    }
 
    private function buildResponse($actionResult, ErrorCollection $errorCollection)
    {
        if ($actionResult instanceof HttpResponse)
        {
            return $actionResult;
        }
 
        if (!$errorCollection->isEmpty())
        {
            //todo There is opportunity to create DenyError() and recognize AjaxJson::STATUS_DENIED by this error.
 
            return new AjaxJson(
                $actionResult,
                AjaxJson::STATUS_ERROR,
                $errorCollection
            );
        }
 
        return new AjaxJson($actionResult);
    }
}