vendor/sulu/sulu/src/Sulu/Bundle/WebsiteBundle/Controller/SitemapController.php line 183

  1. <?php
  3. /*
  4.  * This file is part of Sulu.
  5.  *
  6.  * (c) Sulu GmbH
  7.  *
  8.  * This source file is subject to the MIT license that is bundled
  9.  * with this source code in the file LICENSE.
  10.  */
  12. namespace Sulu\Bundle\WebsiteBundle\Controller;
  14. use Sulu\Bundle\HttpCacheBundle\Cache\SuluHttpCache;
  15. use Sulu\Bundle\WebsiteBundle\Sitemap\SitemapProviderPoolInterface;
  16. use Sulu\Bundle\WebsiteBundle\Sitemap\XmlSitemapDumperInterface;
  17. use Sulu\Bundle\WebsiteBundle\Sitemap\XmlSitemapRendererInterface;
  18. use Symfony\Component\Filesystem\Filesystem;
  19. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  20. use Symfony\Component\HttpFoundation\RedirectResponse;
  21. use Symfony\Component\HttpFoundation\Request;
  22. use Symfony\Component\HttpFoundation\Response;
  23. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  24. use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
  26. /**
  27.  * Renders a xml sitemap.
  28.  */
  29. class SitemapController
  30. {
  31.     /**
  32.      * @var XmlSitemapRendererInterface
  33.      */
  34.     private $xmlSitemapRenderer;
  36.     /**
  37.      * @var SitemapProviderPoolInterface
  38.      */
  39.     private $sitemapProviderPool;
  41.     /**
  42.      * @var XmlSitemapDumperInterface
  43.      */
  44.     private $xmlSitemapDumper;
  46.     /**
  47.      * @var Filesystem
  48.      */
  49.     private $filesystem;
  51.     /**
  52.      * @var UrlGeneratorInterface
  53.      */
  54.     private $router;
  56.     /**
  57.      * @var int
  58.      */
  59.     private $cacheLifeTime;
  61.     /**
  62.      * @var bool
  63.      */
  64.     private $debug;
  66.     public function __construct(
  67.         XmlSitemapRendererInterface $xmlSitemapRenderer,
  68.         SitemapProviderPoolInterface $sitemapProviderPool,
  69.         XmlSitemapDumperInterface $xmlSitemapDumper,
  70.         Filesystem $filesystem,
  71.         UrlGeneratorInterface $router,
  72.         int $cacheLifeTime,
  73.         bool $debug = false
  74.     ) {
  75.         $this->xmlSitemapRenderer = $xmlSitemapRenderer;
  76.         $this->sitemapProviderPool = $sitemapProviderPool;
  77.         $this->xmlSitemapDumper = $xmlSitemapDumper;
  78.         $this->filesystem = $filesystem;
  79.         $this->router = $router;
  80.         $this->cacheLifeTime = $cacheLifeTime;
  81.         $this->debug = $debug;
  82.     }
  84.     /**
  85.      * Render sitemap-index of all available sitemap.xml files.
  86.      * If only one provider exists this provider will be rendered directly.
  87.      *
  88.      * @return Response
  89.      */
  90.     public function indexAction(Request $request)
  91.     {
  92.         $response = $this->getDumpedIndexResponse($request);
  94.         if (!$response) {
  95.             $sitemap = $this->xmlSitemapRenderer->renderIndex($request->getScheme(), $request->getHost());
  96.             if (!$sitemap) {
  97.                 $sitemapAlias = null;
  99.                 foreach ($this->sitemapProviderPool->getProviders() as $sitemapAlias => $provider) {
  100.                     if ($provider->getMaxPage($request->getScheme(), $request->getHost()) > 0) {
  101.                         $sitemapAlias = $provider->getAlias();
  103.                         break;
  104.                     }
  105.                 }
  107.                 if (!$sitemapAlias) {
  108.                     throw new NotFoundHttpException(\sprintf(
  109.                         'No sitemaps found for "%s".',
  110.                         $request->getHttpHost()
  111.                     ));
  112.                 }
  114.                 return $this->sitemapPaginatedAction($request, $sitemapAlias, 1);
  115.             }
  117.             $response = new Response($sitemap);
  118.         }
  120.         $response->headers->set('Content-Type', 'application/xml');
  122.         return $this->setCacheLifetime($response);
  123.     }
  125.     /**
  126.      * Returns index-response if dumped file exists.
  127.      *
  128.      * @return null|BinaryFileResponse
  129.      */
  130.     private function getDumpedIndexResponse(Request $request)
  131.     {
  132.         $path = $this->xmlSitemapDumper->getIndexDumpPath(
  133.             $request->getScheme(),
  134.             $request->getHost()
  135.         );
  137.         if (!$this->filesystem->exists($path)) {
  138.             return;
  139.         }
  141.         return $this->createBinaryFileResponse($path);
  142.     }
  144.     /**
  145.      * Redirect to the first page of a single sitemap provider.
  146.      *
  147.      * @param string $alias
  148.      *
  149.      * @return Response
  150.      */
  151.     public function sitemapAction($alias)
  152.     {
  153.         if (!$this->sitemapProviderPool->hasProvider($alias)) {
  154.             return new Response(null, 404);
  155.         }
  157.         return new RedirectResponse(
  158.             $this->router->generate(
  159.                 'sulu_website.paginated_sitemap',
  160.                 ['alias' => $alias, 'page' => 1]
  161.             ),
  162.             301
  163.         );
  164.     }
  166.     /**
  167.      * Render a single page for a single sitemap.xml provider.
  168.      *
  169.      * @param string $alias
  170.      * @param int $page
  171.      *
  172.      * @return Response
  173.      */
  174.     public function sitemapPaginatedAction(Request $request, $alias, $page)
  175.     {
  176.         $response = $this->getDumpedSitemapResponse($request, $alias, $page);
  178.         if (!$response) {
  179.             $sitemap = $this->xmlSitemapRenderer->renderSitemap(
  180.                 $alias,
  181.                 $page,
  182.                 $request->getScheme(),
  183.                 $request->getHost()
  184.             );
  186.             if (!$sitemap) {
  187.                 return new Response(null, 404);
  188.             }
  190.             $response = new Response($sitemap);
  191.         }
  193.         $response->headers->set('Content-Type', 'application/xml');
  195.         return $this->setCacheLifetime($response);
  196.     }
  198.     /**
  199.      * Returns index-response if dumped file exists.
  200.      *
  201.      * @param string $alias
  202.      * @param int $page
  203.      *
  204.      * @return null|BinaryFileResponse
  205.      */
  206.     private function getDumpedSitemapResponse(Request $request, $alias, $page)
  207.     {
  208.         $path = $this->xmlSitemapDumper->getDumpPath(
  209.             $request->getScheme(),
  210.             $request->getHttpHost(),
  211.             $alias,
  212.             $page
  213.         );
  215.         if (!$this->filesystem->exists($path)) {
  216.             return;
  217.         }
  219.         return $this->createBinaryFileResponse($path);
  220.     }
  222.     /**
  223.      * Set cache headers.
  224.      *
  225.      * @return Response
  226.      */
  227.     private function setCacheLifetime(Response $response)
  228.     {
  229.         $response->headers->set(
  230.             SuluHttpCache::HEADER_REVERSE_PROXY_TTL,
  231.             $response->getAge() + $this->cacheLifeTime
  232.         );
  234.         if ($this->debug) {
  235.             return $response;
  236.         }
  238.         return $response->setMaxAge(240)
  239.             ->setSharedMaxAge(960);
  240.     }
  242.     /**
  243.      * Create a binary file response.
  244.      *
  245.      * @param string $file
  246.      *
  247.      * @return BinaryFileResponse
  248.      */
  249.     private function createBinaryFileResponse($file)
  250.     {
  251.         $response = new BinaryFileResponse($file);
  252.         $response->headers->addCacheControlDirective('no-store', true);
  254.         return $response;
  255.     }
  256. }