vendor/pimcore/pimcore/models/Staticroute.php line 487

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @category   Pimcore
  12.  * @package    Staticroute
  13.  *
  14.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  16.  */
  18. namespace Pimcore\Model;
  20. use Pimcore\Event\FrontendEvents;
  21. use Symfony\Component\EventDispatcher\GenericEvent;
  23. /**
  24.  * @method Staticroute\Dao getDao()
  25.  * @method void save()
  26.  * @method void delete()
  27.  */
  28. class Staticroute extends AbstractModel
  29. {
  30.     /**
  31.      * @var int
  32.      */
  33.     public $id;
  35.     /**
  36.      * @var string
  37.      */
  38.     public $name;
  40.     /**
  41.      * @var string
  42.      */
  43.     public $pattern;
  45.     /**
  46.      * @var string
  47.      */
  48.     public $reverse;
  50.     /**
  51.      * @var string
  52.      */
  53.     public $module;
  55.     /**
  56.      * @var string
  57.      */
  58.     public $controller;
  60.     /**
  61.      * @var string
  62.      */
  63.     public $action;
  65.     /**
  66.      * @var string
  67.      */
  68.     public $variables;
  70.     /**
  71.      * @var string
  72.      */
  73.     public $defaults;
  75.     /**
  76.      * @var array
  77.      */
  78.     public $siteId;
  80.     /**
  81.      * @var array
  82.      */
  83.     public $methods;
  85.     /**
  86.      * @var int
  87.      */
  88.     public $priority = 1;
  90.     /**
  91.      * @var int
  92.      */
  93.     public $creationDate;
  95.     /**
  96.      * @var int
  97.      */
  98.     public $modificationDate;
  100.     /**
  101.      * Associative array filled on match() that holds matched path values
  102.      * for given variable names.
  103.      *
  104.      * @var array
  105.      */
  106.     public $_values = [];
  108.     /**
  109.      * this is a small per request cache to know which route is which is, this info is used in self::getByName()
  110.      *
  111.      * @var array
  112.      */
  113.     protected static $nameIdMappingCache = [];
  115.     /**
  116.      * contains the static route which the current request matches (it he does), this is used in the view to get the current route
  117.      *
  118.      * @var Staticroute
  119.      */
  120.     protected static $_currentRoute;
  122.     /**
  123.      * @static
  124.      *
  125.      * @param Staticroute $route
  126.      */
  127.     public static function setCurrentRoute($route)
  128.     {
  129.         self::$_currentRoute = $route;
  130.     }
  132.     /**
  133.      * @static
  134.      *
  135.      * @return Staticroute
  136.      */
  137.     public static function getCurrentRoute()
  138.     {
  139.         return self::$_currentRoute;
  140.     }
  142.     /**
  143.      * @param int $id
  144.      *
  145.      * @return self|null
  146.      */
  147.     public static function getById($id)
  148.     {
  149.         $cacheKey = 'staticroute_' . $id;
  151.         try {
  152.             $route = \Pimcore\Cache\Runtime::get($cacheKey);
  153.             if (!$route) {
  154.                 throw new \Exception('Route in registry is null');
  155.             }
  156.         } catch (\Exception $e) {
  157.             try {
  158.                 $route = new self();
  159.                 $route->setId(intval($id));
  160.                 $route->getDao()->getById();
  161.                 \Pimcore\Cache\Runtime::set($cacheKey, $route);
  162.             } catch (\Exception $e) {
  163.                 return null;
  164.             }
  165.         }
  167.         return $route;
  168.     }
  170.     /**
  171.      * @param string $name
  172.      * @param int|null $siteId
  173.      *
  174.      * @return self|null
  175.      */
  176.     public static function getByName($name, $siteId = null)
  177.     {
  178.         $cacheKey = $name . '~~~' . $siteId;
  180.         // check if pimcore already knows the id for this $name, if yes just return it
  181.         if (array_key_exists($cacheKey, self::$nameIdMappingCache)) {
  182.             return self::getById(self::$nameIdMappingCache[$cacheKey]);
  183.         }
  185.         // create a tmp object to obtain the id
  186.         $route = new self();
  188.         try {
  189.             $route->getDao()->getByName($name, $siteId);
  190.         } catch (\Exception $e) {
  191.             return null;
  192.         }
  194.         // to have a singleton in a way. like all instances of Element\ElementInterface do also, like DataObject\AbstractObject
  195.         if ($route->getId() > 0) {
  196.             // add it to the mini-per request cache
  197.             self::$nameIdMappingCache[$cacheKey] = $route->getId();
  199.             return self::getById($route->getId());
  200.         }
  202.         return null;
  203.     }
  205.     /**
  206.      * @return self
  207.      */
  208.     public static function create()
  209.     {
  210.         $route = new self();
  211.         $route->save();
  213.         return $route;
  214.     }
  216.     /**
  217.      * Get the defaults defined in a string as array
  218.      *
  219.      * @return array
  220.      */
  221.     public function getDefaultsArray()
  222.     {
  223.         $defaults = [];
  225.         $t = explode('|', $this->getDefaults());
  226.         foreach ($t as $v) {
  227.             $d = explode('=', $v);
  228.             if (strlen($d[0]) > 0 && strlen($d[1]) > 0) {
  229.                 $defaults[$d[0]] = $d[1];
  230.             }
  231.         }
  233.         return $defaults;
  234.     }
  236.     /**
  237.      * @return int
  238.      */
  239.     public function getId()
  240.     {
  241.         return $this->id;
  242.     }
  244.     /**
  245.      * @return string
  246.      */
  247.     public function getPattern()
  248.     {
  249.         return $this->pattern;
  250.     }
  252.     /**
  253.      * @return string
  254.      */
  255.     public function getModule()
  256.     {
  257.         return $this->module;
  258.     }
  260.     /**
  261.      * @return string
  262.      */
  263.     public function getController()
  264.     {
  265.         return $this->controller;
  266.     }
  268.     /**
  269.      * @return string
  270.      */
  271.     public function getAction()
  272.     {
  273.         return $this->action;
  274.     }
  276.     /**
  277.      * @return string
  278.      */
  279.     public function getVariables()
  280.     {
  281.         return $this->variables;
  282.     }
  284.     /**
  285.      * @return string
  286.      */
  287.     public function getDefaults()
  288.     {
  289.         return $this->defaults;
  290.     }
  292.     /**
  293.      * @param int $id
  294.      *
  295.      * @return $this
  296.      */
  297.     public function setId($id)
  298.     {
  299.         $this->id = (int) $id;
  301.         return $this;
  302.     }
  304.     /**
  305.      * @param string $pattern
  306.      *
  307.      * @return $this
  308.      */
  309.     public function setPattern($pattern)
  310.     {
  311.         $this->pattern = $pattern;
  313.         return $this;
  314.     }
  316.     /**
  317.      * @param string $module
  318.      *
  319.      * @return $this
  320.      */
  321.     public function setModule($module)
  322.     {
  323.         $this->module = $module;
  325.         return $this;
  326.     }
  328.     /**
  329.      * @param string $controller
  330.      *
  331.      * @return $this
  332.      */
  333.     public function setController($controller)
  334.     {
  335.         $this->controller = $controller;
  337.         return $this;
  338.     }
  340.     /**
  341.      * @param string $action
  342.      *
  343.      * @return $this
  344.      */
  345.     public function setAction($action)
  346.     {
  347.         $this->action = $action;
  349.         return $this;
  350.     }
  352.     /**
  353.      * @param string $variables
  354.      *
  355.      * @return $this
  356.      */
  357.     public function setVariables($variables)
  358.     {
  359.         $this->variables = $variables;
  361.         return $this;
  362.     }
  364.     /**
  365.      * @param string $defaults
  366.      *
  367.      * @return $this
  368.      */
  369.     public function setDefaults($defaults)
  370.     {
  371.         $this->defaults = $defaults;
  373.         return $this;
  374.     }
  376.     /**
  377.      * @param int $priority
  378.      *
  379.      * @return $this
  380.      */
  381.     public function setPriority($priority)
  382.     {
  383.         $this->priority = (int) $priority;
  385.         return $this;
  386.     }
  388.     /**
  389.      * @return int
  390.      */
  391.     public function getPriority()
  392.     {
  393.         return $this->priority;
  394.     }
  396.     /**
  397.      * @param string $name
  398.      *
  399.      * @return $this
  400.      */
  401.     public function setName($name)
  402.     {
  403.         $this->name = $name;
  405.         return $this;
  406.     }
  408.     /**
  409.      * @return string
  410.      */
  411.     public function getName()
  412.     {
  413.         return $this->name;
  414.     }
  416.     /**
  417.      * @param string $reverse
  418.      *
  419.      * @return $this
  420.      */
  421.     public function setReverse($reverse)
  422.     {
  423.         $this->reverse = $reverse;
  425.         return $this;
  426.     }
  428.     /**
  429.      * @return string
  430.      */
  431.     public function getReverse()
  432.     {
  433.         return $this->reverse;
  434.     }
  436.     /**
  437.      * @param int|array $siteId
  438.      *
  439.      * @return $this
  440.      */
  441.     public function setSiteId($siteId)
  442.     {
  443.         $result = [];
  445.         if (!is_array($siteId)) {
  446.             // backwards compatibility
  447.             $siteIds = strlen($siteId) ? explode(',', $siteId) : [];
  448.         } else {
  449.             $siteIds = $siteId;
  450.         }
  452.         foreach ($siteIds as $siteId) {
  453.             $siteId = (int)$siteId;
  454.             if ($siteId < 1) {
  455.                 continue;
  456.             }
  458.             if ($site = Site::getById($siteId)) {
  459.                 $result[] = $siteId;
  460.             }
  461.         }
  463.         $this->siteId = $result;
  465.         return $this;
  466.     }
  468.     /**
  469.      * @return array
  470.      */
  471.     public function getSiteId()
  472.     {
  473.         if ($this->siteId && !is_array($this->siteId)) {
  474.             $this->siteId = explode(',', $this->siteId);
  475.         }
  477.         return $this->siteId;
  478.     }
  480.     /**
  481.      * @param array $urlOptions
  482.      * @param bool $reset
  483.      * @param bool $encode
  484.      *
  485.      * @return mixed|string
  486.      */
  487.     public function assemble(array $urlOptions = [], $reset = false, $encode = true)
  488.     {
  489.         // get request parameters
  490.         $blockedRequestParams = ['controller', 'action', 'module', 'document'];
  492.         // allow blocked params if we use it as variables
  493.         $variables = explode(',', $this->getVariables());
  494.         foreach ($variables as $name) {
  495.             $pos = array_search($name, $blockedRequestParams);
  496.             if ($pos !== false) {
  497.                 unset($blockedRequestParams[$pos]);
  498.             }
  499.         }
  501.         if ($reset) {
  502.             $requestParameters = [];
  503.         } else {
  504.             $requestParameters = \Pimcore::getContainer()->get('pimcore.routing.router.request_context')->getParameters();
  506.             // merge route params from static routes here
  507.             $request = \Pimcore::getContainer()->get('request_stack')->getCurrentRequest();
  508.             if (null !== $request && $request->attributes->get('_route_params')) {
  509.                 $requestParameters = array_merge($requestParameters, $request->attributes->get('_route_params'));
  510.             }
  512.             // remove blocked parameters from request
  513.             foreach ($blockedRequestParams as $key) {
  514.                 if (array_key_exists($key, $requestParameters)) {
  515.                     unset($requestParameters[$key]);
  516.                 }
  517.             }
  518.         }
  520.         $defaultValues = $this->getDefaultsArray();
  522.         // apply values (controller,action,module, ... ) from previous match if applicable (only when )
  523.         if ($reset) {
  524.             if (self::$_currentRoute && (self::$_currentRoute->getName() == $this->getName())) {
  525.                 $defaultValues = array_merge($defaultValues, self::$_currentRoute->_values);
  526.             }
  527.         }
  529.         // merge with defaults
  530.         $urlParams = array_merge($defaultValues, $requestParameters, $urlOptions);
  532.         $parametersInReversePattern = [];
  533.         $parametersGet = [];
  534.         $url = $this->getReverse();
  535.         $forbiddenCharacters = ['#', ':', '?'];
  537.         // check for named variables
  538.         uksort($urlParams, function ($a, $b) {
  539.             // order by key length, longer key have priority
  540.             // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  541.             return strlen($b) - strlen($a);
  542.         });
  544.         $tmpReversePattern = $this->getReverse();
  545.         foreach ($urlParams as $key => $param) {
  546.             if (strpos($tmpReversePattern, '%' . $key) !== false) {
  547.                 $parametersInReversePattern[$key] = $param;
  549.                 // we need to replace the found variable to that it cannot match again a placeholder
  550.                 // eg. %abcd prior %ab if %abcd matches already %ab shouldn't match again on the same placeholder
  551.                 $tmpReversePattern = str_replace('%' . $key, '---', $tmpReversePattern);
  552.             } else {
  553.                 // only append the get parameters if there are defined in $urlOptions
  554.                 // or if they are defined in $_GET an $reset is false
  555.                 if (array_key_exists($key, $urlOptions) || (!$reset && array_key_exists($key, $_GET))) {
  556.                     $parametersGet[$key] = $param;
  557.                 }
  558.             }
  559.         }
  561.         $urlEncodeEscapeCharacters = '~|urlen' . md5(microtime()) . 'code|~';
  563.         // replace named variables
  564.         uksort($parametersInReversePattern, function ($a, $b) {
  565.             // order by key length, longer key have priority
  566.             // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  567.             return strlen($b) - strlen($a);
  568.         });
  570.         foreach ($parametersInReversePattern as $key => $value) {
  571.             $value = str_replace($forbiddenCharacters, '', $value);
  572.             if (strlen($value) > 0) {
  573.                 if ($encode) {
  574.                     $value = urlencode_ignore_slash($value);
  575.                 }
  576.                 $value = str_replace('%', $urlEncodeEscapeCharacters, $value);
  577.                 $url = str_replace('%' . $key, $value, $url);
  578.             }
  579.         }
  581.         // remove optional parts
  582.         $url = preg_replace("/\{([^\}]+)?%[^\}]+\}/", '', $url);
  583.         $url = str_replace(['{', '}'], '', $url);
  585.         // optional get parameters
  586.         if (!empty($parametersGet)) {
  587.             if ($encode) {
  588.                 $getParams = array_urlencode($parametersGet);
  589.             } else {
  590.                 $getParams = array_toquerystring($parametersGet);
  591.             }
  592.             $url .= '?' . $getParams;
  593.         }
  595.         // convert tmp urlencode escape char back to real escape char
  596.         $url = str_replace($urlEncodeEscapeCharacters, '%', $url);
  598.         $event = new GenericEvent($this, [
  599.             'frontendPath' => $url,
  600.             'params' => $urlParams,
  601.             'reset' => $reset,
  602.             'encode' => $encode
  603.         ]);
  604.         \Pimcore::getEventDispatcher()->dispatch(FrontendEvents::STATICROUTE_PATH, $event);
  605.         $url = $event->getArgument('frontendPath');
  607.         return $url;
  608.     }
  610.     /**
  611.      * @param string $path
  612.      * @param array $params
  613.      *
  614.      * @return array|bool
  615.      *
  616.      * @throws \Exception
  617.      */
  618.     public function match($path, $params = [])
  619.     {
  620.         if (@preg_match($this->getPattern(), $path)) {
  622.             // check for site
  623.             if ($this->getSiteId()) {
  624.                 if (!Site::isSiteRequest()) {
  625.                     return false;
  626.                 }
  628.                 $siteMatched = false;
  629.                 $siteIds = $this->getSiteId();
  630.                 foreach ($siteIds as $siteId) {
  631.                     if ($siteId == Site::getCurrentSite()->getId()) {
  632.                         $siteMatched = true;
  633.                         break;
  634.                     }
  635.                 }
  636.                 if (!$siteMatched) {
  637.                     return false;
  638.                 }
  639.             }
  641.             // we need to unset this 3 params here, because otherwise the defaults wouldn't have an effect if used
  642.             // in combination with dynamic action/controller/module configurations
  643.             unset($params['controller'], $params['action'], $params['module']);
  645.             $params = array_merge($this->getDefaultsArray(), $params);
  647.             $variables = explode(',', $this->getVariables());
  649.             preg_match_all($this->getPattern(), $path, $matches);
  651.             if (is_array($matches) && count($matches) > 1) {
  652.                 foreach ($matches as $index => $match) {
  653.                     if (isset($variables[$index - 1]) && $variables[$index - 1]) {
  654.                         $paramValue = urldecode($match[0]);
  655.                         if (!empty($paramValue) || !array_key_exists($variables[$index - 1], $params)) {
  656.                             $params[$variables[$index - 1]] = $paramValue;
  657.                         }
  658.                     }
  659.                 }
  660.             }
  662.             $controller = $this->getController();
  663.             $action = $this->getAction();
  664.             $module = trim($this->getModule());
  666.             // check for dynamic controller / action / module
  667.             $dynamicRouteReplace = function ($item, $params) {
  668.                 if (strpos($item, '%') !== false) {
  669.                     uksort($params, function ($a, $b) {
  670.                         // order by key length, longer key have priority
  671.                         // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  672.                         return strlen($b) - strlen($a);
  673.                     });
  675.                     foreach ($params as $key => $value) {
  676.                         $dynKey = '%' . $key;
  677.                         if (strpos($item, $dynKey) !== false) {
  678.                             return str_replace($dynKey, $value, $item);
  679.                         }
  680.                     }
  681.                 }
  683.                 return $item;
  684.             };
  686.             $controller = $dynamicRouteReplace($controller, $params);
  687.             $action = $dynamicRouteReplace($action, $params);
  688.             $module = $dynamicRouteReplace($module, $params);
  690.             $params['controller'] = $controller;
  691.             $params['action'] = $action;
  692.             if (!empty($module)) {
  693.                 $params['module'] = $module;
  694.             }
  695.             // remember for reverse assemble
  696.             $this->_values = $params;
  698.             return $params;
  699.         }
  701.         return [];
  702.     }
  704.     /**
  705.      * @return array
  706.      */
  707.     public function getMethods()
  708.     {
  709.         if ($this->methods && !is_array($this->methods)) {
  710.             $this->methods = explode(',', $this->methods);
  711.         }
  713.         return $this->methods;
  714.     }
  716.     /**
  717.      * @param array $methods
  718.      *
  719.      * @return $this
  720.      */
  721.     public function setMethods($methods)
  722.     {
  723.         if (!is_array($methods)) {
  724.             $methods = strlen($methods) ? explode(',', $methods) : [];
  725.             $methods = array_map('trim', $methods);
  726.         }
  728.         $this->methods = $methods;
  730.         return $this;
  731.     }
  733.     /**
  734.      * @param int $modificationDate
  735.      *
  736.      * @return $this
  737.      */
  738.     public function setModificationDate($modificationDate)
  739.     {
  740.         $this->modificationDate = (int) $modificationDate;
  742.         return $this;
  743.     }
  745.     /**
  746.      * @return int
  747.      */
  748.     public function getModificationDate()
  749.     {
  750.         return $this->modificationDate;
  751.     }
  753.     /**
  754.      * @param int $creationDate
  755.      *
  756.      * @return $this
  757.      */
  758.     public function setCreationDate($creationDate)
  759.     {
  760.         $this->creationDate = (int) $creationDate;
  762.         return $this;
  763.     }
  765.     /**
  766.      * @return int
  767.      */
  768.     public function getCreationDate()
  769.     {
  770.         return $this->creationDate;
  771.     }
  772. }