restmanager.php

<?php
 
namespace Bitrix\Rest\Engine;
 
use Bitrix\Main\Config\Configuration;
use Bitrix\Main\Context;
use Bitrix\Main\Engine;
use Bitrix\Main\Engine\AutoWire;
use Bitrix\Main\Engine\Controller;
use Bitrix\Main\Engine\Resolver;
use Bitrix\Main\Errorable;
use Bitrix\Main\Error;
use Bitrix\Main\ErrorCollection;
use Bitrix\Main\HttpResponse;
use Bitrix\Main\Type\Contract;
use Bitrix\Main\Type\Date;
use Bitrix\Main\Type\DateTime;
use Bitrix\Main\UI\PageNavigation;
use Bitrix\Main\Web\Uri;
use Bitrix\Rest\Engine\ScopeManager;
use Bitrix\Rest\RestException;
 
class RestManager extends \IRestService
{
    public const DONT_CALCULATE_COUNT = -1;
 
    protected $restServer;
    private $pageNavigation;
    private $calculateTotalCount = true;
 
    public static function onFindMethodDescription($potentialAction)
    {
        $restManager = new static();
        $potentialActionData = ScopeManager::getInstance()->getMethodInfo($potentialAction);
 
        $request = new \Bitrix\Main\HttpRequest(
            Context::getCurrent()->getServer(),
            ['action' => $potentialActionData['method']],
            [], [], []
        );
 
        $router = new Engine\Router($request);
        $controllersConfig = Configuration::getInstance($router->getModule());
        if (empty($controllersConfig['controllers']['restIntegration']['enabled']))
        {
            return false;
        }
 
        list($controller) = $router->getControllerAndAction();
        if (!$controller || $controller instanceof Engine\DefaultController)
        {
            return false;
        }
 
        return [
            'scope' => static::getModuleScopeAlias($potentialActionData['scope']),
            'callback' => [
                $restManager, 'processMethodRequest'
            ]
        ];
    }
 
    public static function getModuleScopeAlias($moduleId)
    {
        if($moduleId === 'tasks')
        {
            return 'task';
        }
 
        return $moduleId;
    }
 
    private static function getAlternativeScope($scope): ?array
    {
        if ($scope === \Bitrix\Rest\Api\User::SCOPE_USER)
        {
            return [
                \Bitrix\Rest\Api\User::SCOPE_USER_BRIEF,
                \Bitrix\Rest\Api\User::SCOPE_USER_BASIC,
            ];
        }
 
        return null;
    }
 
    public static function fillAlternativeScope($scope, $scopeList)
    {
        if (!in_array($scope, $scopeList, true))
        {
            $altScopeList = static::getAlternativeScope($scope);
            if (is_array($altScopeList))
            {
                $hasScope = array_intersect($scopeList, $altScopeList);
                if (count($hasScope) > 0)
                {
                    $scopeList[] = $scope;
                }
            }
        }
 
        return $scopeList;
    }
 
    public function processMethodRequest(array $params, $start, \CRestServer $restServer)
    {
        $start = intval($start);
        $this->initialize($restServer, $start);
 
        $errorCollection = new ErrorCollection();
        $method = $restServer->getMethod();
        $methodData = ScopeManager::getInstance()->getMethodInfo($method);
 
        $request = new \Bitrix\Main\HttpRequest(
            Context::getCurrent()->getServer(),
            ['action' => $methodData['method']],
            [], [], []
        );
        $router = new Engine\Router($request);
 
        [$controller, $action] = Resolver::getControllerAndAction(
            $router->getVendor(),
            $router->getModule(),
            $router->getAction(),
            Controller::SCOPE_REST
        );
        if (!$controller)
        {
            throw new RestException("Unknown {$method}. There is not controller in module {$router->getModule()}");
        }
 
        $this->calculateTotalCount = true;
        if ((int)$start === self::DONT_CALCULATE_COUNT)
        {
            $this->calculateTotalCount = false;
        }
 
        $autoWirings = $this->getAutoWirings();
 
        $this->registerAutoWirings($autoWirings);
        $result = $controller->run($action, [$params, ['__restServer' => $restServer, '__calculateTotalCount' => $this->calculateTotalCount]]);
        $this->unRegisterAutoWirings($autoWirings);
 
        if ($result instanceof Engine\Response\File)
        {
            return $result->send();
        }
 
        if ($result instanceof HttpResponse)
        {
            if ($result instanceof Errorable)
            {
                $errorCollection->add($result->getErrors());
            }
 
            $result = $result->getContent();
        }
 
        if ($result instanceof RestException)
        {
            throw $result;
        }
 
        if ($result === null)
        {
            $errorCollection->add($controller->getErrors());
            if (!$errorCollection->isEmpty())
            {
                throw $this->createExceptionFromErrors($errorCollection->toArray());
            }
        }
 
        return $this->processData($result);
    }
 
    private function initialize(\CRestServer $restServer, int $start): void
    {
        $pageNavigation = new PageNavigation('nav');
        $pageNavigation->setPageSize(static::LIST_LIMIT);
        if ($start > 0)
        {
            $pageNavigation->setCurrentPage((int)($start / static::LIST_LIMIT) + 1);
        }
 
        $this->pageNavigation = $pageNavigation;
        $this->restServer = $restServer;
    }
 
    private function getNavigationData(Engine\Response\DataType\Page $page): array
    {
        if (!$this->calculateTotalCount)
        {
            return [];
        }
 
        $result = [];
        $offset = $this->pageNavigation->getOffset();
        $total = $page->getTotalCount();
 
        $currentPageSize = count($page->getItems());
 
        if ($offset + $currentPageSize < $total)
        {
            $result['next'] = $offset + $currentPageSize;
        }
 
        $result['total'] = $total;
 
        return $result;
    }
 
 
    private function processData($result)
    {
        if ($result instanceof DateTime)
        {
            return \CRestUtil::convertDateTime($result);
        }
 
        if ($result instanceof Date)
        {
            return \CRestUtil::convertDate($result);
        }
 
        if ($result instanceof Uri)
        {
            return $this->convertAjaxUriToRest($result);
        }
 
        if ($result instanceof Engine\Response\DataType\Page)
        {
            if (method_exists($result, 'getId'))
            {
                $data = [$result->getId() => $this->processData($result->getIterator())];
            }
            else
            {
                $data = $this->processData($result->getIterator());
            }
 
            return array_merge($data, $this->getNavigationData($result));
        }
 
        if ($result instanceof Contract\Arrayable)
        {
            $result = $result->toArray();
        }
 
        if (is_array($result))
        {
            foreach ($result as $key => $item)
            {
                if ($item instanceof Engine\Response\DataType\ContentUri)
                {
                    $result[$key . "Machine"] = $this->processData($item);
                    $result[$key] = $this->processData(new Uri($item));
                }
                else
                {
                    $result[$key] = $this->processData($item);
                }
 
            }
        }
        elseif ($result instanceof \Traversable)
        {
            $newResult = [];
            foreach ($result as $key => $item)
            {
                $newResult[$key] = $this->processData($item);
            }
 
            $result = $newResult;
        }
 
        return $result;
    }
 
    private function convertAjaxUriToRest(Uri $uri)
    {
        if (!($uri instanceof Engine\Response\DataType\ContentUri))
        {
            return $uri->getUri();
        }
 
        $endPoint = Engine\UrlManager::getInstance()->getEndPoint(Engine\UrlManager::ABSOLUTE_URL);
        if ($uri->getPath() !== $endPoint->getPath())
        {
            return $uri->getUri();
        }
 
        if ($uri->getHost() && $uri->getHost() !== $endPoint->getHost())
        {
            return $uri->getUri();
        }
 
        parse_str($uri->getQuery(), $params);
        if (empty($params['action']))
        {
            return $uri->getUri();
        }
 
        return \CRestUtil::getSpecialUrl($params['action'], $params, $this->restServer);
    }
 
    private function getRestEndPoint()
    {
        return \Bitrix\Main\Config\Option::get('rest', 'rest_server_path', '/rest');
    }
 
    private function createExceptionFromErrors(array $errors)
    {
        if(!$errors)
        {
            return null;
        }
 
        $firstError = reset($errors);
 
        return new RestException($firstError->getMessage(), $firstError->getCode());
    }
 
    private function registerAutoWirings(array $autoWirings): void
    {
        foreach ($autoWirings as $parameter)
        {
            AutoWire\Binder::registerGlobalAutoWiredParameter($parameter);
        }
    }
 
    private function unRegisterAutoWirings(array $autoWirings): void
    {
        foreach ($autoWirings as $parameter)
        {
            AutoWire\Binder::unRegisterGlobalAutoWiredParameter($parameter);
        }
    }
 
    private function getAutoWirings(): array
    {
        $buildRules = [
            'restServer' => [
                'class' => \CRestServer::class,
                'constructor' => function() {
                    return $this->restServer;
                },
            ],
            'pageNavigation' => [
                'class' => PageNavigation::class,
                'constructor' => function() {
                    return $this->pageNavigation;
                },
            ],
        ];
 
        $autoWirings = [];
        foreach ($buildRules as $rule)
        {
            $autoWirings[] = new AutoWire\Parameter($rule['class'], $rule['constructor']);
        }
 
        return $autoWirings;
    }
}