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

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 int
  82.      */
  83.     public $priority = 1;
  85.     /**
  86.      * @var int
  87.      */
  88.     public $creationDate;
  90.     /**
  91.      * @var int
  92.      */
  93.     public $modificationDate;
  95.     /**
  96.      * Associative array filled on match() that holds matched path values
  97.      * for given variable names.
  98.      *
  99.      * @var array
  100.      */
  101.     public $_values = [];
  103.     /**
  104.      * this is a small per request cache to know which route is which is, this info is used in self::getByName()
  105.      *
  106.      * @var array
  107.      */
  108.     protected static $nameIdMappingCache = [];
  110.     /**
  111.      * contains the static route which the current request matches (it he does), this is used in the view to get the current route
  112.      *
  113.      * @var Staticroute
  114.      */
  115.     protected static $_currentRoute;
  117.     /**
  118.      * @static
  119.      *
  120.      * @param $route
  121.      */
  122.     public static function setCurrentRoute($route)
  123.     {
  124.         self::$_currentRoute = $route;
  125.     }
  127.     /**
  128.      * @static
  129.      *
  130.      * @return Staticroute
  131.      */
  132.     public static function getCurrentRoute()
  133.     {
  134.         return self::$_currentRoute;
  135.     }
  137.     /**
  138.      * @param int $id
  139.      *
  140.      * @return Staticroute
  141.      */
  142.     public static function getById($id)
  143.     {
  144.         $cacheKey = 'staticroute_' . $id;
  146.         try {
  147.             $route = \Pimcore\Cache\Runtime::get($cacheKey);
  148.             if (!$route) {
  149.                 throw new \Exception('Route in registry is null');
  150.             }
  151.         } catch (\Exception $e) {
  152.             try {
  153.                 $route = new self();
  154.                 $route->setId(intval($id));
  155.                 $route->getDao()->getById();
  156.                 \Pimcore\Cache\Runtime::set($cacheKey, $route);
  157.             } catch (\Exception $e) {
  158.                 return null;
  159.             }
  160.         }
  162.         return $route;
  163.     }
  165.     /**
  166.      * @param string $name
  167.      * @param null $siteId
  168.      *
  169.      * @return Staticroute
  170.      */
  171.     public static function getByName($name, $siteId = null)
  172.     {
  173.         $cacheKey = $name . '~~~' . $siteId;
  175.         // check if pimcore already knows the id for this $name, if yes just return it
  176.         if (array_key_exists($cacheKey, self::$nameIdMappingCache)) {
  177.             return self::getById(self::$nameIdMappingCache[$cacheKey]);
  178.         }
  180.         // create a tmp object to obtain the id
  181.         $route = new self();
  183.         try {
  184.             $route->getDao()->getByName($name, $siteId);
  185.         } catch (\Exception $e) {
  186.             return null;
  187.         }
  189.         // to have a singleton in a way. like all instances of Element\ElementInterface do also, like DataObject\AbstractObject
  190.         if ($route->getId() > 0) {
  191.             // add it to the mini-per request cache
  192.             self::$nameIdMappingCache[$cacheKey] = $route->getId();
  194.             return self::getById($route->getId());
  195.         }
  196.     }
  198.     /**
  199.      * @return Staticroute
  200.      */
  201.     public static function create()
  202.     {
  203.         $route = new self();
  204.         $route->save();
  206.         return $route;
  207.     }
  209.     /**
  210.      * Get the defaults defined in a string as array
  211.      *
  212.      * @return array
  213.      */
  214.     public function getDefaultsArray()
  215.     {
  216.         $defaults = [];
  218.         $t = explode('|', $this->getDefaults());
  219.         foreach ($t as $v) {
  220.             $d = explode('=', $v);
  221.             if (strlen($d[0]) > 0 && strlen($d[1]) > 0) {
  222.                 $defaults[$d[0]] = $d[1];
  223.             }
  224.         }
  226.         return $defaults;
  227.     }
  229.     /**
  230.      * @return int
  231.      */
  232.     public function getId()
  233.     {
  234.         return $this->id;
  235.     }
  237.     /**
  238.      * @return string
  239.      */
  240.     public function getPattern()
  241.     {
  242.         return $this->pattern;
  243.     }
  245.     /**
  246.      * @return string
  247.      */
  248.     public function getModule()
  249.     {
  250.         return $this->module;
  251.     }
  253.     /**
  254.      * @return string
  255.      */
  256.     public function getController()
  257.     {
  258.         return $this->controller;
  259.     }
  261.     /**
  262.      * @return string
  263.      */
  264.     public function getAction()
  265.     {
  266.         return $this->action;
  267.     }
  269.     /**
  270.      * @return string
  271.      */
  272.     public function getVariables()
  273.     {
  274.         return $this->variables;
  275.     }
  277.     /**
  278.      * @return string
  279.      */
  280.     public function getDefaults()
  281.     {
  282.         return $this->defaults;
  283.     }
  285.     /**
  286.      * @param int $id
  287.      *
  288.      * @return $this
  289.      */
  290.     public function setId($id)
  291.     {
  292.         $this->id = (int) $id;
  294.         return $this;
  295.     }
  297.     /**
  298.      * @param string $pattern
  299.      *
  300.      * @return $this
  301.      */
  302.     public function setPattern($pattern)
  303.     {
  304.         $this->pattern = $pattern;
  306.         return $this;
  307.     }
  309.     /**
  310.      * @param string $module
  311.      *
  312.      * @return $this
  313.      */
  314.     public function setModule($module)
  315.     {
  316.         $this->module = $module;
  318.         return $this;
  319.     }
  321.     /**
  322.      * @param string $controller
  323.      *
  324.      * @return $this
  325.      */
  326.     public function setController($controller)
  327.     {
  328.         $this->controller = $controller;
  330.         return $this;
  331.     }
  333.     /**
  334.      * @param string $action
  335.      *
  336.      * @return $this
  337.      */
  338.     public function setAction($action)
  339.     {
  340.         $this->action = $action;
  342.         return $this;
  343.     }
  345.     /**
  346.      * @param string $variables
  347.      *
  348.      * @return $this
  349.      */
  350.     public function setVariables($variables)
  351.     {
  352.         $this->variables = $variables;
  354.         return $this;
  355.     }
  357.     /**
  358.      * @param string $defaults
  359.      *
  360.      * @return $this
  361.      */
  362.     public function setDefaults($defaults)
  363.     {
  364.         $this->defaults = $defaults;
  366.         return $this;
  367.     }
  369.     /**
  370.      * @param int $priority
  371.      *
  372.      * @return $this
  373.      */
  374.     public function setPriority($priority)
  375.     {
  376.         $this->priority = (int) $priority;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return int
  383.      */
  384.     public function getPriority()
  385.     {
  386.         return $this->priority;
  387.     }
  389.     /**
  390.      * @param string $name
  391.      *
  392.      * @return $this
  393.      */
  394.     public function setName($name)
  395.     {
  396.         $this->name = $name;
  398.         return $this;
  399.     }
  401.     /**
  402.      * @return string
  403.      */
  404.     public function getName()
  405.     {
  406.         return $this->name;
  407.     }
  409.     /**
  410.      * @param string $reverse
  411.      *
  412.      * @return $this
  413.      */
  414.     public function setReverse($reverse)
  415.     {
  416.         $this->reverse = $reverse;
  418.         return $this;
  419.     }
  421.     /**
  422.      * @return string
  423.      */
  424.     public function getReverse()
  425.     {
  426.         return $this->reverse;
  427.     }
  429.     /**
  430.      * @param int|array $siteId
  431.      *
  432.      * @return $this
  433.      */
  434.     public function setSiteId($siteId)
  435.     {
  436.         $result = [];
  438.         if (!is_array($siteId)) {
  439.             // backwards compatibility
  440.             $siteIds = strlen($siteId) ? explode(',', $siteId) : [];
  441.         } else {
  442.             $siteIds = $siteId;
  443.         }
  445.         foreach ($siteIds as $siteId) {
  446.             $siteId = (int)$siteId;
  447.             if ($siteId < 1) {
  448.                 continue;
  449.             }
  451.             if ($site = Site::getById($siteId)) {
  452.                 $result[] = $siteId;
  453.             }
  454.         }
  456.         $this->siteId = $result;
  458.         return $this;
  459.     }
  461.     /**
  462.      * @return array
  463.      */
  464.     public function getSiteId()
  465.     {
  466.         if ($this->siteId && !is_array($this->siteId)) {
  467.             $this->siteId = explode(',', $this->siteId);
  468.         }
  470.         return $this->siteId;
  471.     }
  473.     /**
  474.      * @param array $urlOptions
  475.      * @param bool $reset
  476.      * @param bool $encode
  477.      *
  478.      * @return mixed|string
  479.      */
  480.     public function assemble(array $urlOptions = [], $reset = false, $encode = true)
  481.     {
  482.         // get request parameters
  483.         $blockedRequestParams = ['controller', 'action', 'module', 'document'];
  485.         // allow blocked params if we use it as variables
  486.         $variables = explode(',', $this->getVariables());
  487.         foreach ($variables as $name) {
  488.             $pos = array_search($name, $blockedRequestParams);
  489.             if ($pos !== false) {
  490.                 unset($blockedRequestParams[$pos]);
  491.             }
  492.         }
  494.         if ($reset) {
  495.             $requestParameters = [];
  496.         } else {
  497.             $requestParameters = \Pimcore::getContainer()->get('pimcore.routing.router.request_context')->getParameters();
  499.             // merge route params from static routes here
  500.             $request = \Pimcore::getContainer()->get('request_stack')->getCurrentRequest();
  501.             if (null !== $request && $request->attributes->get('_route_params')) {
  502.                 $requestParameters = array_merge($requestParameters, $request->attributes->get('_route_params'));
  503.             }
  505.             // remove blocked parameters from request
  506.             foreach ($blockedRequestParams as $key) {
  507.                 if (array_key_exists($key, $requestParameters)) {
  508.                     unset($requestParameters[$key]);
  509.                 }
  510.             }
  511.         }
  513.         $defaultValues = $this->getDefaultsArray();
  515.         // apply values (controller,action,module, ... ) from previous match if applicable (only when )
  516.         if ($reset) {
  517.             if (self::$_currentRoute && (self::$_currentRoute->getName() == $this->getName())) {
  518.                 $defaultValues = array_merge($defaultValues, self::$_currentRoute->_values);
  519.             }
  520.         }
  522.         // merge with defaults
  523.         $urlParams = array_merge($defaultValues, $requestParameters, $urlOptions);
  525.         $parametersInReversePattern = [];
  526.         $parametersGet = [];
  527.         $url = $this->getReverse();
  528.         $forbiddenCharacters = ['#', ':', '?'];
  530.         // check for named variables
  531.         uksort($urlParams, function ($a, $b) {
  532.             // order by key length, longer key have priority
  533.             // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  534.             return strlen($b) - strlen($a);
  535.         });
  537.         $tmpReversePattern = $this->getReverse();
  538.         foreach ($urlParams as $key => $param) {
  539.             if (strpos($tmpReversePattern, '%' . $key) !== false) {
  540.                 $parametersInReversePattern[$key] = $param;
  542.                 // we need to replace the found variable to that it cannot match again a placeholder
  543.                 // eg. %abcd prior %ab if %abcd matches already %ab shouldn't match again on the same placeholder
  544.                 $tmpReversePattern = str_replace('%' . $key, '---', $tmpReversePattern);
  545.             } else {
  546.                 // only append the get parameters if there are defined in $urlOptions
  547.                 // or if they are defined in $_GET an $reset is false
  548.                 if (array_key_exists($key, $urlOptions) || (!$reset && array_key_exists($key, $_GET))) {
  549.                     $parametersGet[$key] = $param;
  550.                 }
  551.             }
  552.         }
  554.         $urlEncodeEscapeCharacters = '~|urlen' . md5(microtime()) . 'code|~';
  556.         // replace named variables
  557.         uksort($parametersInReversePattern, function ($a, $b) {
  558.             // order by key length, longer key have priority
  559.             // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  560.             return strlen($b) - strlen($a);
  561.         });
  563.         foreach ($parametersInReversePattern as $key => $value) {
  564.             $value = str_replace($forbiddenCharacters, '', $value);
  565.             if (strlen($value) > 0) {
  566.                 if ($encode) {
  567.                     $value = urlencode_ignore_slash($value);
  568.                 }
  569.                 $value = str_replace('%', $urlEncodeEscapeCharacters, $value);
  570.                 $url = str_replace('%' . $key, $value, $url);
  571.             }
  572.         }
  574.         // remove optional parts
  575.         $url = preg_replace("/\{([^\}]+)?%[^\}]+\}/", '', $url);
  576.         $url = str_replace(['{', '}'], '', $url);
  578.         // optional get parameters
  579.         if (!empty($parametersGet)) {
  580.             if ($encode) {
  581.                 $getParams = array_urlencode($parametersGet);
  582.             } else {
  583.                 $getParams = array_toquerystring($parametersGet);
  584.             }
  585.             $url .= '?' . $getParams;
  586.         }
  588.         // convert tmp urlencode escape char back to real escape char
  589.         $url = str_replace($urlEncodeEscapeCharacters, '%', $url);
  591.         $event = new GenericEvent($this, [
  592.             'frontendPath' => $url,
  593.             'params' => $urlParams,
  594.             'reset' => $reset,
  595.             'encode' => $encode
  596.         ]);
  597.         \Pimcore::getEventDispatcher()->dispatch(FrontendEvents::STATICROUTE_PATH, $event);
  598.         $url = $event->getArgument('frontendPath');
  600.         return $url;
  601.     }
  603.     /**
  604.      * @param string $path
  605.      * @param array $params
  606.      *
  607.      * @return array|bool
  608.      *
  609.      * @throws \Exception
  610.      */
  611.     public function match($path, $params = [])
  612.     {
  613.         if (@preg_match($this->getPattern(), $path)) {
  615.             // check for site
  616.             if ($this->getSiteId()) {
  617.                 if (!Site::isSiteRequest()) {
  618.                     return false;
  619.                 }
  621.                 $siteMatched = false;
  622.                 $siteIds = $this->getSiteId();
  623.                 foreach ($siteIds as $siteId) {
  624.                     if ($siteId == Site::getCurrentSite()->getId()) {
  625.                         $siteMatched = true;
  626.                         break;
  627.                     }
  628.                 }
  629.                 if (!$siteMatched) {
  630.                     return false;
  631.                 }
  632.             }
  634.             // we need to unset this 3 params here, because otherwise the defaults wouldn't have an effect if used
  635.             // in combination with dynamic action/controller/module configurations
  636.             unset($params['controller'], $params['action'], $params['module']);
  638.             $params = array_merge($this->getDefaultsArray(), $params);
  640.             $variables = explode(',', $this->getVariables());
  642.             preg_match_all($this->getPattern(), $path, $matches);
  644.             if (is_array($matches) && count($matches) > 1) {
  645.                 foreach ($matches as $index => $match) {
  646.                     if (isset($variables[$index - 1]) && $variables[$index - 1]) {
  647.                         $paramValue = urldecode($match[0]);
  648.                         if (!empty($paramValue) || !array_key_exists($variables[$index - 1], $params)) {
  649.                             $params[$variables[$index - 1]] = $paramValue;
  650.                         }
  651.                     }
  652.                 }
  653.             }
  655.             $controller = $this->getController();
  656.             $action = $this->getAction();
  657.             $module = trim($this->getModule());
  659.             // check for dynamic controller / action / module
  660.             $dynamicRouteReplace = function ($item, $params) {
  661.                 if (strpos($item, '%') !== false) {
  662.                     uksort($params, function ($a, $b) {
  663.                         // order by key length, longer key have priority
  664.                         // (%abcd prior %ab, so that %ab doesn't replace %ab in [%ab]cd)
  665.                         return strlen($b) - strlen($a);
  666.                     });
  668.                     foreach ($params as $key => $value) {
  669.                         $dynKey = '%' . $key;
  670.                         if (strpos($item, $dynKey) !== false) {
  671.                             return str_replace($dynKey, $value, $item);
  672.                         }
  673.                     }
  674.                 }
  676.                 return $item;
  677.             };
  679.             $controller = $dynamicRouteReplace($controller, $params);
  680.             $action = $dynamicRouteReplace($action, $params);
  681.             $module = $dynamicRouteReplace($module, $params);
  683.             $params['controller'] = $controller;
  684.             $params['action'] = $action;
  685.             if (!empty($module)) {
  686.                 $params['module'] = $module;
  687.             }
  688.             // remember for reverse assemble
  689.             $this->_values = $params;
  691.             return $params;
  692.         }
  694.         return [];
  695.     }
  697.     /**
  698.      * @param $modificationDate
  699.      *
  700.      * @return $this
  701.      */
  702.     public function setModificationDate($modificationDate)
  703.     {
  704.         $this->modificationDate = (int) $modificationDate;
  706.         return $this;
  707.     }
  709.     /**
  710.      * @return int
  711.      */
  712.     public function getModificationDate()
  713.     {
  714.         return $this->modificationDate;
  715.     }
  717.     /**
  718.      * @param $creationDate
  719.      *
  720.      * @return $this
  721.      */
  722.     public function setCreationDate($creationDate)
  723.     {
  724.         $this->creationDate = (int) $creationDate;
  726.         return $this;
  727.     }
  729.     /**
  730.      * @return int
  731.      */
  732.     public function getCreationDate()
  733.     {
  734.         return $this->creationDate;
  735.     }
  736. }