Url.php

Go to the documentation of this file.

<?php
namespace Magento\Framework;

use Magento\Framework\App\ObjectManager;
use Magento\Framework\Serialize\Serializer\Json;
use Magento\Framework\Url\HostChecker;

class Url extends \Magento\Framework\DataObject implements \Magento\Framework\UrlInterface
{
    protected static $_configDataCache;

    protected $_reservedRouteParams = [
        '_scope',
        '_type',
        '_secure',
        '_forced_secure',
        '_use_rewrite',
        '_nosid',
        '_absolute',
        '_current',
        '_direct',
        '_fragment',
        '_escape',
        '_query',
        '_scope_to_url',
    ];

    protected $_scopeType;

    protected $_request;

    protected $_useSession;

    protected $_urlSecurityInfo;

    protected $_session;

    protected $_sidResolver;

    protected $_routeConfig;

    private $_routeParamsResolver;

    private $_routeParamsResolverFactory;

    protected $_scopeResolver;

    protected $_queryParamsResolver;

    private $cacheUrl = [];

    protected $_scopeConfig;

    protected $routeParamsPreprocessor;

    private $urlModifier;

    private $escaper;

    private $hostChecker;

    private $serializer;

    public function __construct(
        \Magento\Framework\App\Route\ConfigInterface $routeConfig,
        \Magento\Framework\App\RequestInterface $request,
        \Magento\Framework\Url\SecurityInfoInterface $urlSecurityInfo,
        \Magento\Framework\Url\ScopeResolverInterface $scopeResolver,
        \Magento\Framework\Session\Generic $session,
        \Magento\Framework\Session\SidResolverInterface $sidResolver,
        \Magento\Framework\Url\RouteParamsResolverFactory $routeParamsResolverFactory,
        \Magento\Framework\Url\QueryParamsResolverInterface $queryParamsResolver,
        \Magento\Framework\App\Config\ScopeConfigInterface $scopeConfig,
        \Magento\Framework\Url\RouteParamsPreprocessorInterface $routeParamsPreprocessor,
        $scopeType,
        array $data = [],
        HostChecker $hostChecker = null,
        Json $serializer = null
    ) {
        $this->_request = $request;
        $this->_routeConfig = $routeConfig;
        $this->_urlSecurityInfo = $urlSecurityInfo;
        $this->_scopeResolver = $scopeResolver;
        $this->_session = $session;
        $this->_sidResolver = $sidResolver;
        $this->_routeParamsResolverFactory = $routeParamsResolverFactory;
        $this->_queryParamsResolver = $queryParamsResolver;
        $this->_scopeConfig = $scopeConfig;
        $this->routeParamsPreprocessor = $routeParamsPreprocessor;
        $this->_scopeType = $scopeType;
        $this->hostChecker = $hostChecker ?: \Magento\Framework\App\ObjectManager::getInstance()
            ->get(HostChecker::class);
        $this->serializer = $serializer ?: ObjectManager::getInstance()->get(Json::class);
        parent::__construct($data);
    }

    protected function _parseUrl($url)
    {
        $data = parse_url($url);
        $parts = [
            'scheme' => 'setScheme',
            'host' => 'setHost',
            'port' => 'setPort',
            'user' => 'setUser',
            'pass' => 'setPassword',
            'path' => 'setPath',
            'query' => '_setQuery',
            'fragment' => 'setFragment',
        ];

        foreach ($parts as $component => $method) {
            if (isset($data[$component])) {
                $this->{$method}($data[$component]);
            }
        }
        return $this;
    }

    public function setUseSession($useSession)
    {
        $this->_useSession = (bool) $useSession;
        return $this;
    }

    public function getUseSession()
    {
        if ($this->_useSession === null) {
            $this->_useSession = $this->_sidResolver->getUseSessionInUrl();
        }
        return $this->_useSession;
    }

    public function getConfigData($key, $prefix = null)
    {
        if ($prefix === null) {
            $prefix = 'web/' . ($this->_isSecure() ? 'secure' : 'unsecure') . '/';
        }
        $path = $prefix . $key;

        $cacheId = $this->_getConfigCacheId($path);
        if (!isset(self::$_configDataCache[$cacheId])) {
            $data = $this->_getConfig($path);
            self::$_configDataCache[$cacheId] = $data;
        }

        return self::$_configDataCache[$cacheId];
    }

    protected function _getConfigCacheId($path)
    {
        return $this->_getScope()->getCode() . '/' . $path;
    }

    protected function _getConfig($path)
    {
        return $this->_scopeConfig->getValue(
            $path,
            $this->_scopeType,
            $this->_getScope()
        );
    }

    public function setRequest(\Magento\Framework\App\RequestInterface $request)
    {
        $this->_request = $request;
        return $this;
    }

    protected function _getRequest()
    {
        return $this->_request;
    }

    protected function _getType()
    {
        if (!$this->getRouteParamsResolver()->hasData('type')) {
            $this->getRouteParamsResolver()->setData('type', self::DEFAULT_URL_TYPE);
        }
        return $this->getRouteParamsResolver()->getType();
    }

    protected function _isSecure()
    {
        if ($this->_request->isSecure()) {
            if ($this->getRouteParamsResolver()->hasData('secure')) {
                return (bool) $this->getRouteParamsResolver()->getData('secure');
            }
            return true;
        }

        if ($this->getRouteParamsResolver()->hasData('secure_is_forced')) {
            return (bool) $this->getRouteParamsResolver()->getData('secure');
        }

        if (!$this->_getScope()->isUrlSecure()) {
            return false;
        }

        if (!$this->getRouteParamsResolver()->hasData('secure')) {
            if ($this->_getType() == UrlInterface::URL_TYPE_LINK) {
                $pathSecure = $this->_urlSecurityInfo->isSecure('/' . $this->_getActionPath());
                $this->getRouteParamsResolver()->setData('secure', $pathSecure);
            } elseif ($this->_getType() == UrlInterface::URL_TYPE_STATIC) {
                $isRequestSecure = $this->_getRequest()->isSecure();
                $this->getRouteParamsResolver()->setData('secure', $isRequestSecure);
            } else {
                $this->getRouteParamsResolver()->setData('secure', true);
            }
        }

        return $this->getRouteParamsResolver()->getData('secure');
    }

    public function setScope($params)
    {
        $this->setData('scope', $this->_scopeResolver->getScope($params));
        $this->getRouteParamsResolver()->setScope($this->_scopeResolver->getScope($params));
        return $this;
    }

    protected function _getScope()
    {
        if (!$this->hasData('scope')) {
            $this->setScope(null);
        }
        return $this->_getData('scope');
    }

    public function getBaseUrl($params = [])
    {
        $origScope = $this->_getScope();

        if (isset($params['_scope'])) {
            $this->setScope($params['_scope']);
        }
        if (isset($params['_type'])) {
            $this->getRouteParamsResolver()->setType($params['_type']);
        }

        if (isset($params['_secure'])) {
            $this->getRouteParamsResolver()->setSecure($params['_secure']);
        }

        if ($this->_getType() == UrlInterface::URL_TYPE_LINK
            && $this->_getRequest()->isDirectAccessFrontendName(
                $this->_getRouteFrontName()
            )
        ) {
            $this->getRouteParamsResolver()->setType(UrlInterface::URL_TYPE_DIRECT_LINK);
        }

        $result = $this->_getScope()->getBaseUrl($this->_getType(), $this->_isSecure());

        // setting back the original scope
        $this->setScope($origScope);
        $this->getRouteParamsResolver()->setType(self::DEFAULT_URL_TYPE);

        return $result;
    }

    protected function _setRoutePath($data)
    {
        if ($this->_getData('route_path') == $data) {
            return $this;
        }

        $this->unsetData('route_path');
        $routePieces = explode('/', $data);

        $route = array_shift($routePieces);
        if ('*' === $route) {
            $route = $this->_getRequest()->getRouteName();
        }
        $this->_setRouteName($route);

        $controller = '';
        if (!empty($routePieces)) {
            $controller = array_shift($routePieces);
            if ('*' === $controller) {
                $controller = $this->_getRequest()->getControllerName();
            }
        }
        $this->_setControllerName($controller);

        $action = '';
        if (!empty($routePieces)) {
            $action = array_shift($routePieces);
            if ('*' === $action) {
                $action = $this->_getRequest()->getActionName();
            }
        }
        $this->_setActionName($action);

        if (!empty($routePieces)) {
            while (!empty($routePieces)) {
                $key = array_shift($routePieces);
                if (!empty($routePieces)) {
                    $value = array_shift($routePieces);
                    $this->getRouteParamsResolver()->setRouteParam($key, $value);
                }
            }
        }

        return $this;
    }

    protected function _getActionPath()
    {
        if (!$this->_getRouteName()) {
            return '';
        }

        $hasParams = (bool) $this->_getRouteParams();
        $path = $this->_getRouteFrontName() . '/';

        if ($this->_getControllerName()) {
            $path .= $this->_getControllerName() . '/';
        } elseif ($hasParams) {
            $path .= self::DEFAULT_CONTROLLER_NAME . '/';
        }
        if ($this->_getActionName()) {
            $path .= $this->_getActionName() . '/';
        } elseif ($hasParams) {
            $path .= self::DEFAULT_ACTION_NAME . '/';
        }

        return $path;
    }

    protected function _getRoutePath($routeParams = [])
    {
        if (!$this->hasData('route_path')) {
            $routePath = $this->_getRequest()->getAlias(self::REWRITE_REQUEST_PATH_ALIAS);
            if (!empty($routeParams['_use_rewrite']) && $routePath !== null) {
                $this->setData('route_path', $routePath);
                return $routePath;
            }
            $routePath = $this->_getActionPath();
            if ($this->_getRouteParams()) {
                foreach ($this->_getRouteParams() as $key => $value) {
                    if ($value === null || false === $value || '' === $value || !is_scalar($value)) {
                        continue;
                    }
                    $routePath .= $key . '/' . $value . '/';
                }
            }
            $this->setData('route_path', $routePath);
        }
        return $this->_getData('route_path');
    }

    protected function _setRouteName($data)
    {
        if ($this->_getData('route_name') == $data) {
            return $this;
        }
        $this->unsetData('route_front_name')
            ->unsetData('route_path')
            ->unsetData('controller_name')
            ->unsetData('action_name');
        $this->_queryParamsResolver->unsetData('secure');
        return $this->setData('route_name', $data);
    }

    protected function _getRouteFrontName()
    {
        if (!$this->hasData('route_front_name')) {
            $frontName = $this->_routeConfig->getRouteFrontName(
                $this->_getRouteName(),
                $this->_scopeResolver->getAreaCode()
            );
            $this->setData('route_front_name', $frontName);
        }
        return $this->_getData('route_front_name');
    }

    protected function _getRouteName($default = null)
    {
        return $this->_getData('route_name') ? $this->_getData('route_name') : $default;
    }

    protected function _setControllerName($data)
    {
        if ($this->_getData('controller_name') == $data) {
            return $this;
        }
        $this->unsetData('route_path')->unsetData('action_name');
        $this->_queryParamsResolver->unsetData('secure');
        return $this->setData('controller_name', $data);
    }

    protected function _getControllerName($default = null)
    {
        return $this->_getData('controller_name') ? $this->_getData('controller_name') : $default;
    }

    protected function _setActionName($data)
    {
        if ($this->_getData('action_name') == $data) {
            return $this;
        }
        $this->unsetData('route_path');
        $this->setData('action_name', $data);
        $this->_queryParamsResolver->unsetData('secure');
        return $this;
    }

    protected function _getActionName($default = null)
    {
        return $this->_getData('action_name') ? $this->_getData('action_name') : $default;
    }

    protected function _setRouteParams(array $data, $unsetOldParams = true)
    {
        $this->getRouteParamsResolver()->setRouteParams($data, $unsetOldParams);
        return $this;
    }

    protected function _getRouteParams()
    {
        return $this->getRouteParamsResolver()->getRouteParams();
    }

    public function getRouteUrl($routePath = null, $routeParams = null)
    {
        if (filter_var($routePath, FILTER_VALIDATE_URL)) {
            return $routePath;
        }

        $this->getRouteParamsResolver()->unsetData('route_params');

        if (isset($routeParams['_direct'])) {
            if (is_array($routeParams)) {
                $this->_setRouteParams($routeParams, false);
            }
            return $this->getBaseUrl() . $routeParams['_direct'];
        }

        $this->_setRoutePath($routePath);
        if (is_array($routeParams)) {
            $this->_setRouteParams($routeParams, false);
        }

        return $this->getBaseUrl($routeParams) . $this->_getRoutePath($routeParams);
    }

    public function addSessionParam()
    {
        $this->setQueryParam(
            $this->_sidResolver->getSessionIdQueryParam($this->_session),
            $this->_session->getSessionId()
        );
        return $this;
    }

    protected function _setQuery($data)
    {
        return $this->_queryParamsResolver->setQuery($data);
    }

    protected function _getQuery($escape = false)
    {
        return $this->_queryParamsResolver->getQuery($escape);
    }

    public function addQueryParams(array $data)
    {
        $this->_queryParamsResolver->addQueryParams($data);
        return $this;
    }

    public function setQueryParam($key, $data)
    {
        $this->_queryParamsResolver->setQueryParam($key, $data);
        return $this;
    }

    protected function _getFragment()
    {
        return $this->_getData('fragment');
    }

    public function getUrl($routePath = null, $routeParams = null)
    {
        if (filter_var($routePath, FILTER_VALIDATE_URL)) {
            return $routePath;
        }

        $routeParams = $this->routeParamsPreprocessor
            ->execute($this->_scopeResolver->getAreaCode(), $routePath, $routeParams);

        $isCached = true;
        $isArray = is_array($routeParams);

        if ($isArray) {
            array_walk_recursive(
                $routeParams,
                function ($item) use (&$isCached) {
                    if (is_object($item)) {
                        $isCached = false;
                    }
                }
            );
        }

        if (!$isCached) {
            return $this->getUrlModifier()->execute(
                $this->createUrl($routePath, $routeParams)
            );
        }

        $cachedParams = $routeParams;
        if ($isArray) {
            ksort($cachedParams);
        }

        $cacheKey = sha1($routePath . $this->serializer->serialize($cachedParams));
        if (!isset($this->cacheUrl[$cacheKey])) {
            $this->cacheUrl[$cacheKey] = $this->getUrlModifier()->execute(
                $this->createUrl($routePath, $routeParams)
            );
        }

        return $this->cacheUrl[$cacheKey];
    }

    private function createUrl($routePath = null, array $routeParams = null)
    {
        $escapeQuery = false;
        $escapeParams = true;

        $this->getRouteParamsResolver()->unsetData('secure');
        $fragment = null;
        if (isset($routeParams['_fragment'])) {
            $fragment = $routeParams['_fragment'];
            unset($routeParams['_fragment']);
        }

        if (isset($routeParams['_escape'])) {
            $escapeQuery = $routeParams['_escape'];
            unset($routeParams['_escape']);
        }

        if (isset($routeParams['_escape_params'])) {
            $escapeParams = $routeParams['_escape_params'];
            unset($routeParams['_escape_params']);
        }
        $this->getRouteParamsResolver()->setData('escape_params', $escapeParams);

        $query = null;
        if (isset($routeParams['_query'])) {
            $this->_queryParamsResolver->setQueryParams([]);
            $query = $routeParams['_query'];
            unset($routeParams['_query']);
        }

        $noSid = null;
        if (isset($routeParams['_nosid'])) {
            $noSid = (bool)$routeParams['_nosid'];
            unset($routeParams['_nosid']);
        }
        $url = $this->getRouteUrl($routePath, $routeParams);

        if ($query !== null) {
            if (is_string($query)) {
                $this->_setQuery($query);
            } elseif (is_array($query)) {
                $this->addQueryParams($query, !empty($routeParams['_current']));
            }
            if ($query === false) {
                $this->addQueryParams([]);
            }
        }

        if ($noSid !== true) {
            $this->_prepareSessionUrl($url);
        }

        $query = $this->_getQuery($escapeQuery);
        if ($query) {
            $mark = strpos($url, '?') === false ? '?' : ($escapeQuery ? '&amp;' : '&');
            $url .= $mark . $query;
            $this->_queryParamsResolver->unsetData('query');
            $this->_queryParamsResolver->unsetData('query_params');
        }

        if ($fragment !== null) {
            $url .= '#' . $this->getEscaper()->encodeUrlParam($fragment);
        }
        $this->getRouteParamsResolver()->unsetData('secure');
        $this->getRouteParamsResolver()->unsetData('escape_params');

        return $url;
    }

    protected function _prepareSessionUrl($url)
    {
        if (!$this->getUseSession()) {
            return $this;
        }
        $sessionId = $this->_session->getSessionIdForHost($url);
        if ($this->_sidResolver->getUseSessionVar() && !$sessionId) {
            $this->setQueryParam('___SID', $this->_isSecure() ? 'S' : 'U');
        } elseif ($sessionId) {
            $this->setQueryParam($this->_sidResolver->getSessionIdQueryParam($this->_session), $sessionId);
        }
        return $this;
    }

    public function getRebuiltUrl($url)
    {
        $this->_parseUrl($url);
        $port = $this->getPort();
        if ($port) {
            $port = ':' . $port;
        } else {
            $port = '';
        }
        $url = $this->getScheme() . '://' . $this->getHost() . $port . $this->getPath();

        $this->_prepareSessionUrl($url);

        $query = $this->_getQuery();
        if ($query) {
            $url .= '?' . $query;
        }

        $fragment = $this->_getFragment();
        if ($fragment) {
            $url .= '#' . $this->getEscaper()->encodeUrlParam($fragment);
        }

        return $url;
    }

    public function escape($value)
    {
        $value = str_replace('"', '%22', $value);
        $value = str_replace("'", '%27', $value);
        $value = str_replace('>', '%3E', $value);
        $value = str_replace('<', '%3C', $value);
        return $value;
    }

    public function getDirectUrl($url, $params = [])
    {
        $params['_direct'] = $url;
        return $this->getUrl('', $params);
    }

    public function sessionUrlVar($html)
    {
        return preg_replace_callback(
            '#(\?|&amp;|&)___SID=([SU])(&amp;|&)?#',
            // @codingStandardsIgnoreStart
            // @codingStandardsIgnoreEnd
            function ($match) {
                if ($this->useSessionIdForUrl($match[2] == 'S' ? true : false)) {
                    return $match[1] . $this->_sidResolver->getSessionIdQueryParam($this->_session) . '='
                        . $this->_session->getSessionId() . (isset($match[3]) ? $match[3] : '');
                } else {
                    if ($match[1] == '?') {
                        return isset($match[3]) ? '?' : '';
                    } elseif ($match[1] == '&amp;' || $match[1] == '&') {
                        return $match[3] ?? '';
                    }
                }
            },
            $html
        );
    }

    public function useSessionIdForUrl($secure = false)
    {
        $key = 'use_session_id_for_url_' . (int)$secure;
        if ($this->getData($key) === null) {
            $httpHost = $this->_request->getHttpHost();
            $urlHost = parse_url(
                $this->_getScope()->getBaseUrl(UrlInterface::URL_TYPE_LINK, $secure),
                PHP_URL_HOST
            );

            if ($httpHost != $urlHost) {
                $this->setData($key, true);
            } else {
                $this->setData($key, false);
            }
        }
        return $this->getData($key);
    }

    public function isOwnOriginUrl()
    {
        return $this->hostChecker->isOwnOrigin($this->_request->getServer('HTTP_REFERER'));
    }

    public function getRedirectUrl($url)
    {
        $this->_prepareSessionUrl($url);
        $query = $this->_getQuery(false);
        if ($query) {
            $url .= (strpos($url, '?') === false ? '?' : '&') . $query;
        }

        return $url;
    }

    public function getCurrentUrl()
    {
        $httpHostWithPort = $this->_request->getHttpHost(false);
        $httpHostWithPort = explode(':', $httpHostWithPort);
        $httpHost = isset($httpHostWithPort[0]) ? $httpHostWithPort[0] : '';
        $port = '';
        if (isset($httpHostWithPort[1])) {
            $defaultPorts = [
                \Magento\Framework\App\Request\Http::DEFAULT_HTTP_PORT,
                \Magento\Framework\App\Request\Http::DEFAULT_HTTPS_PORT,
            ];
            if (!in_array($httpHostWithPort[1], $defaultPorts)) {
                $port = ':' . $httpHostWithPort[1];
            }
        }
        return $this->_request->getScheme() . '://' . $httpHost . $port . $this->_request->getRequestUri();
    }

    protected function getRouteParamsResolver()
    {
        if (!$this->_routeParamsResolver) {
            $this->_routeParamsResolver = $this->_routeParamsResolverFactory->create();
        }
        return $this->_routeParamsResolver;
    }

    private function getUrlModifier()
    {
        if ($this->urlModifier === null) {
            $this->urlModifier = \Magento\Framework\App\ObjectManager::getInstance()->get(
                \Magento\Framework\Url\ModifierInterface::class
            );
        }

        return $this->urlModifier;
    }

    private function getEscaper()
    {
        if ($this->escaper == null) {
            $this->escaper = \Magento\Framework\App\ObjectManager::getInstance()
                ->get(\Magento\Framework\Escaper::class);
        }
        return $this->escaper;
    }
}