lib/composer/RoutingBundle/src/VisualMedia/RoutingBundle/Service/Router.php line 119

Open in your IDE?
  1. <?php
  2. /**
  3.  * Router
  4.  *
  5.  * @author Vincent van Waasbergen <v.vanwaasbergen@visualmedia.nl>
  6.  */
  7. namespace VisualMedia\RoutingBundle\Service;
  9. use Exception;
  11. use Doctrine\ORM\EntityManagerInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\RequestStack;
  15. use Symfony\Component\HttpKernel\CacheWarmer\WarmableInterface;
  16. use Symfony\Component\Routing\RequestContext;
  17. use Symfony\Component\Routing\Router as SymfonyRouter;
  18. use Symfony\Component\Routing\RouterInterface;
  19. use Symfony\Component\Routing\RouteCollection;
  21. use VisualMedia\LisaBundle\Component\ManagerData;
  22. use VisualMedia\RoutingBundle\Controller\RedirectController;
  23. use VisualMedia\RoutingBundle\Entity\BaseRedirect;
  24. use VisualMedia\RoutingBundle\Entity\BaseRoute;
  25. use VisualMedia\TranslationBundle\Service\ChannelProvider;
  28. /**
  29.  * Router
  30.  */
  31. class Router implements RouterInterface, WarmableInterface
  32. {
  33.     /**
  34.      * @var RequestStack
  35.      */
  36.     protected $requestStack;
  38.     /**
  39.      * @var RouterInterface
  40.      */
  41.     protected $router;
  43.     /**
  44.      * @var EntityManagerInterface
  45.      */
  46.     protected $manager;
  48.     /**
  49.      * @var ChannelProvider
  50.      */
  51.     protected $channelProvider;
  53.     /**
  54.      * {@inheritdoc}
  55.      */
  56.     public function __construct(RequestStack $requestStack, RouterInterface $router, EntityManagerInterface $manager)
  57.     {
  58.         $this->requestStack = $requestStack;
  59.         $this->router = $router;
  60.         $this->manager = $manager;
  61.     }
  63.     /**
  64.      * {@inheritdoc}
  65.      */
  66.     public function initialize(ChannelProvider $channelProvider)
  67.     {
  68.         $this->channelProvider = $channelProvider;
  69.     }
  71.     /**
  72.      * {@inheritdoc}
  73.      */
  74.     public function warmup(string $cacheDir)
  75.     {
  76.         // ...
  77.     }
  79.     /**
  80.      * {@inheritdoc}
  81.      */
  82.     public function getRouteCollection()
  83.     {
  84.         return $this->router->getRouteCollection();
  85.     }
  87.     /**
  88.      * {@inheritdoc}
  89.      */
  90.     public function getContext()
  91.     {
  92.         return $this->router->getContext();
  93.     }
  95.     /**
  96.      * {@inheritdoc}
  97.      */
  98.     public function setContext(RequestContext $context)
  99.     {
  100.         $this->router->setContext($context);
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      */
  106.     public function generate(string $name, array $parameters = [], int $referenceType = self::ABSOLUTE_PATH)
  107.     {
  108.         try {
  109.             return $this->router->generate($name, $parameters, $referenceType);
  110.         }
  111.         catch (Exception $exception) {
  112.             return '#';
  113.         }
  114.     }
  116.     /**
  117.      * {@inheritdoc}
  118.      */
  119.     public function match($pathinfo)
  120.     {
  121.         // Match non-fallback system routes.
  122.         try {
  123.             if (is_array($match = $this->router->match($pathinfo))) {
  124.                 $collection = $this->router->getRouteCollection();
  125.                 if (null !== $route = $collection->get($match['_route'])) {
  126.                     if (!$route->getOption('fallback')) {
  127.                         return $match;
  128.                     }
  129.                 }
  130.             }
  131.         } catch (Exception $exception) {}
  133.         // Match database routes.
  134.         $locales = [];
  135.         if (null !== $domain = $this->channelProvider->getCurrentDomain()) {
  136.             foreach ($domain->locales as $locale) {
  137.                 $locales[] = $locale->code;
  138.             }
  140.             if (!empty($locales)) {
  141.                 $request = $this->requestStack->getMasterRequest();
  142.                 $manager = $this->manager->getRepository(BaseRoute::class);
  143.                 $route = $manager->getFirst(new ManagerData([
  144.                     'url' => $pathinfo,
  145.                     'locales' => $locales,
  146.                     'active' => true,
  147.                 ]));
  149.                 if ($route) {
  150.                     if ($request->getLocale() !== $locale = $route->locale->code) {
  151.                         $request->setLocale($locale);
  152.                     }
  154.                     $data = array_merge([
  155.                         '_route' => $route->name,
  156.                         '_controller' => $route->getController(),
  157.                     ], $route->getParameters());
  159.                     return $data;
  160.                 }
  161.             }
  162.         }
  164.         // Match redirects.
  165.         $manager = $this->manager->getRepository(BaseRedirect::class);
  166.         $redirect = $manager->getFirst(new ManagerData([
  167.             'urlFrom' => $pathinfo,
  168.             'active' => true,
  169.         ]));
  171.         if ($redirect) {
  172.             return [
  173.                 '_route' => 'redirect',
  174.                 '_controller' => sprintf('%s::%s', RedirectController::class, 'redirectAction'),
  175.                 'url' => $redirect->urlTo,
  176.                 'code' => $redirect->type,
  177.             ];
  178.         }
  180.         // Match fallback system routes.
  181.         return $this->router->match($pathinfo);
  182.     }
  184.     /**
  185.      * {@inheritdoc}
  186.      */
  187.     public function getOption($option)
  188.     {
  189.         return $this->router->getOption($option);
  190.     }
  191. }