router.php

<?php
 
namespace Bitrix\Main\UrlPreview;
 
use Bitrix\Main\Application;
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Web\Uri;
 
class Router
{
    const CACHE_ID = 'UrlPreviewRouteCache';
    const CACHE_TTL = 315360000;
 
    protected static $routeTable = array();
 
    protected static $managedCache;
 
    protected static $initialized = false;
 
    public static function setRouteHandler($route, $handlerModule, $handlerClass, array $handlerParameters)
    {
        static::init();
 
        if(!is_string($route) || $route == '')
            throw new ArgumentException('Route could not be empty', '$route');
        if(!is_string($handlerModule) || $handlerModule == '')
            throw new ArgumentException('Handler module could not be empty', '$handler');
        if(!is_string($handlerClass) || $handlerClass == '')
            throw new ArgumentException('Handler class could not be empty', '$handler');
 
        $newRoute = true;
        if(isset(static::$routeTable[$route]))
        {
            if (   $handlerModule === static::$routeTable[$route]['MODULE']
                && $handlerClass === static::$routeTable[$route]['CLASS']
                && $handlerParameters == static::$routeTable[$route]['PARAMETERS']
            )
            {
                return;
            }
            $newRoute = false;
        }
 
        $allowSlashes = ($handlerParameters['allowSlashes'] ?? 'N') === 'Y';
        static::$routeTable[$route]['ROUTE'] = $route;
        static::$routeTable[$route]['REGEXP'] = static::convertRouteToRegexp($route, $allowSlashes);
        static::$routeTable[$route]['MODULE'] = $handlerModule;
        static::$routeTable[$route]['CLASS'] = $handlerClass;
        static::$routeTable[$route]['PARAMETERS'] = $handlerParameters;
 
        static::persistRoute($route, $newRoute);
    }
 
    public static function dispatch(Uri $uri)
    {
        static::init();
 
        $urlPath = $uri->getPath();
        //todo: replace cycle with compiled regexp for all routes
        foreach(static::$routeTable as $routeRecord)
        {
            if(preg_match($routeRecord['REGEXP'], $urlPath, $matches))
            {
                $result = $routeRecord;
                //replace parameters variables with values
                foreach($result['PARAMETERS'] as $parameterName => &$parameterValue)
                {
                    if(mb_strpos($parameterValue, '$') === 0)
                    {
                        $variableName = mb_substr($parameterValue, 1);
                        if(isset($matches[$variableName]))
                        {
                            $parameterValue = $matches[$variableName];
                        }
                    }
                }
                unset($parameterValue);
 
                $uriQuery = $uri->getQuery();
                if (mb_strlen($uriQuery) > 0)
                {
                    $uriQueryParams = static::parseQueryParams($uriQuery);
                    foreach ($result['PARAMETERS'] as $parameterName => &$parameterValue)
                    {
                        if (mb_strpos($parameterValue, '$') === 0)
                        {
                            $variableName = mb_substr($parameterValue, 1);
                            if (isset($uriQueryParams[$variableName]))
                            {
                                $parameterValue = $uriQueryParams[$variableName];
                            }
                        }
                    }
                    unset($parameterValue);
                }
 
                return $result;
            }
        }
 
        return false;
    }
 
    protected static function parseQueryParams($uriQuery): array
    {
        $data = preg_replace_callback(
            '/(?:^|(?<=&))[^=[]+/',
            function($match)
            {
                return bin2hex(urldecode($match[0]));
            },
            $uriQuery
        );
 
        parse_str($data, $values);
 
        return array_combine(array_map('hex2bin', array_keys($values)), $values);
    }
 
    protected static function init()
    {
        if(static::$initialized)
            return;
 
        static::$managedCache = Application::getInstance()->getManagedCache();
 
        if(static::$managedCache->read(static::CACHE_TTL, static::CACHE_ID))
        {
            static::$routeTable = (array)static::$managedCache->get(static::CACHE_ID);
        }
        else
        {
            $queryResult = RouteTable::getList(array(
                'select' => array('*')
            ));
 
            while($routeRecord = $queryResult->fetch())
            {
                $allowSlashes = ($routeRecord['PARAMETERS']['allowSlashes'] ?? 'N') === 'Y';
                $routeRecord['REGEXP'] = static::convertRouteToRegexp($routeRecord['ROUTE'], $allowSlashes);
                static::$routeTable[$routeRecord['ROUTE']] = $routeRecord;
            }
 
            uksort(static::$routeTable, function($a, $b)
            {
                $lengthOfA = mb_strlen($a);
                $lengthOfB = mb_strlen($b);
                if($lengthOfA > $lengthOfB)
                    return -1;
                else if($lengthOfA == $lengthOfB)
                    return 0;
                else
                    return 1;
            });
 
            static::$managedCache->set(static::CACHE_ID, static::$routeTable);
        }
 
        static::$initialized = true;
    }
 
    protected static function persistRoute($route, $isNew)
    {
        static::invalidateRouteCache();
        //Oracle does not support 'merge ... returning field into :field' clause, thus we can't merge clob fields into the table.
        $routeData = array(
            'ROUTE' => static::$routeTable[$route]['ROUTE'],
            'MODULE' => static::$routeTable[$route]['MODULE'],
            'CLASS' => static::$routeTable[$route]['CLASS'],
        );
 
        if($isNew)
        {
            $addResult = RouteTable::merge($routeData);
            if($addResult->isSuccess())
            {
                static::$routeTable[$route]['ID'] = $addResult->getId();
                RouteTable::update(
                        static::$routeTable[$route]['ID'],
                        array(
                                'PARAMETERS' => static::$routeTable[$route]['PARAMETERS']
                        )
                );
            }
            $result = $addResult->isSuccess();
        }
        else
        {
            $routeData['PARAMETERS'] = static::$routeTable[$route]['PARAMETERS'];
            $updateResult = RouteTable::update(static::$routeTable[$route]['ID'], $routeData);
            $result = $updateResult->isSuccess();
        }
        return $result;
    }
 
    protected static function convertRouteToRegexp(string $route, bool $allowSlashes = false): string
    {
        $result = preg_replace(
            "/#(\w+)#/",
            $allowSlashes ? "(?'\\1'.*?)" : "(?'\\1'[^/]+)",
            $route
        );
        $result = str_replace('/', '\/', $result);
        $result = '/^'.$result.'$/';
 
        return $result;
    }
 
    public static function invalidateRouteCache()
    {
        Application::getInstance()->getManagedCache()->clean(static::CACHE_ID);
    }
}