vendor/sulu/sulu/src/Sulu/Bundle/MediaBundle/Controller/MediaStreamController.php line 177

  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\MediaBundle\Controller;
  14. use Sulu\Bundle\MediaBundle\Admin\MediaAdmin;
  15. use Sulu\Bundle\MediaBundle\Entity\Collection;
  16. use Sulu\Bundle\MediaBundle\Entity\FileVersion;
  17. use Sulu\Bundle\MediaBundle\Entity\MediaInterface;
  18. use Sulu\Bundle\MediaBundle\Entity\MediaRepositoryInterface;
  19. use Sulu\Bundle\MediaBundle\Media\DispositionType\DispositionTypeResolver;
  20. use Sulu\Bundle\MediaBundle\Media\Exception\FileVersionNotFoundException;
  21. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyException;
  22. use Sulu\Bundle\MediaBundle\Media\Exception\MediaException;
  23. use Sulu\Bundle\MediaBundle\Media\FormatCache\FormatCacheInterface;
  24. use Sulu\Bundle\MediaBundle\Media\FormatManager\FormatManagerInterface;
  25. use Sulu\Bundle\MediaBundle\Media\Manager\MediaManagerInterface;
  26. use Sulu\Bundle\MediaBundle\Media\Storage\StorageInterface;
  27. use Sulu\Component\PHPCR\PathCleanupInterface;
  28. use Sulu\Component\Security\Authorization\PermissionTypes;
  29. use Sulu\Component\Security\Authorization\SecurityCheckerInterface;
  30. use Sulu\Component\Security\Authorization\SecurityCondition;
  31. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  32. use Symfony\Component\HttpFoundation\RedirectResponse;
  33. use Symfony\Component\HttpFoundation\Request;
  34. use Symfony\Component\HttpFoundation\Response;
  35. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  36. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  38. class MediaStreamController
  39. {
  40.     /**
  41.      * @var FormatManagerInterface
  42.      */
  43.     protected $formatManager;
  45.     /**
  46.      * @var FormatCacheInterface
  47.      */
  48.     protected $formatCache;
  50.     /**
  51.      * @var MediaManagerInterface
  52.      */
  53.     protected $mediaManager;
  55.     /**
  56.      * @var StorageInterface
  57.      */
  58.     protected $storage;
  60.     /**
  61.      * @var DispositionTypeResolver
  62.      */
  63.     protected $dispositionTypeResolver;
  65.     /**
  66.      * @var MediaRepositoryInterface
  67.      */
  68.     protected $mediaRepository;
  70.     /**
  71.      * @var PathCleanupInterface
  72.      */
  73.     protected $pathCleaner;
  75.     /**
  76.      * @var SecurityCheckerInterface|null
  77.      */
  78.     protected $securityChecker;
  80.     public function __construct(
  81.         DispositionTypeResolver $dispositionTypeResolver,
  82.         MediaRepositoryInterface $mediaRepository,
  83.         PathCleanupInterface $pathCleaner,
  84.         FormatManagerInterface $formatManager,
  85.         FormatCacheInterface $formatCache,
  86.         MediaManagerInterface $mediaManager,
  87.         StorageInterface $storage,
  88.         ?SecurityCheckerInterface $securityChecker = null
  89.     ) {
  90.         $this->dispositionTypeResolver = $dispositionTypeResolver;
  91.         $this->mediaRepository = $mediaRepository;
  92.         $this->pathCleaner = $pathCleaner;
  93.         $this->formatManager = $formatManager;
  94.         $this->formatCache = $formatCache;
  95.         $this->mediaManager = $mediaManager;
  96.         $this->storage = $storage;
  97.         $this->securityChecker = $securityChecker;
  98.     }
  100.     /**
  101.      * @return Response
  102.      */
  103.     public function getImageAction(Request $request)
  104.     {
  105.         try {
  106.             if (\ob_get_length()) {
  107.                 \ob_end_clean();
  108.             }
  110.             $url = $request->getPathInfo();
  112.             $mediaProperties = $this->formatCache->analyzedMediaUrl($url);
  114.             return $this->formatManager->returnImage(
  115.                 $mediaProperties['id'],
  116.                 $mediaProperties['format'],
  117.                 $mediaProperties['fileName']
  118.             );
  119.         } catch (ImageProxyException $e) {
  120.             throw new NotFoundHttpException('Image create error. Code: ' . $e->getCode());
  121.         }
  122.     }
  124.     /**
  125.      * @param int $id
  126.      *
  127.      * @return Response
  128.      */
  129.     public function downloadAction(Request $request, $id)
  130.     {
  131.         try {
  132.             if (\ob_get_length()) {
  133.                 \ob_end_clean();
  134.             }
  136.             $version = $request->get('v', null);
  137.             $noCount = $request->get('no-count', false);
  139.             $fileVersion = $this->getFileVersion($id, $version);
  141.             if (!$fileVersion) {
  142.                 return new Response(null, 404);
  143.             }
  145.             if ($this->securityChecker) {
  146.                 $this->securityChecker->checkPermission(
  147.                     new SecurityCondition(
  148.                         MediaAdmin::SECURITY_CONTEXT,
  149.                         null,
  150.                         Collection::class,
  151.                         $fileVersion->getFile()->getMedia()->getCollection()->getId()
  152.                     ),
  153.                     PermissionTypes::VIEW
  154.                 );
  155.             }
  157.             if ($request->query->has('inline')) {
  158.                 $forceInline = (bool) $request->get('inline', false);
  159.                 $dispositionType = $forceInline ? ResponseHeaderBag::DISPOSITION_INLINE : ResponseHeaderBag::DISPOSITION_ATTACHMENT;
  160.             } else {
  161.                 $dispositionType = $this->dispositionTypeResolver
  162.                     ->getByMimeType($fileVersion->getMimeType());
  163.             }
  165.             if (!$noCount) {
  166.                 $this->mediaManager->increaseDownloadCounter($fileVersion->getId());
  167.             }
  169.             $response = $this->getFileResponse($fileVersion, $request->getLocale(), $dispositionType);
  171.             return $response;
  172.         } catch (MediaException $e) {
  173.             throw new NotFoundHttpException('File not found: ' . $e->getCode() . ' ' . $e->getMessage());
  174.         }
  175.     }
  177.     protected function getFileResponse(
  178.         FileVersion $fileVersion,
  179.         string $locale,
  180.         string $dispositionType = ResponseHeaderBag::DISPOSITION_ATTACHMENT
  181.     ): Response {
  182.         $storageOptions = $fileVersion->getStorageOptions();
  184.         $storageType = $this->storage->getType($storageOptions);
  186.         if (StorageInterface::TYPE_REMOTE === $storageType) {
  187.             $response = new RedirectResponse($this->storage->getPath($storageOptions), 302);
  188.             $response->setPrivate();
  190.             return $response;
  191.         } elseif (StorageInterface::TYPE_LOCAL === $storageType) {
  192.             return $this->createBinaryFileResponse($fileVersion, $this->storage, $locale, $dispositionType);
  193.         }
  195.         throw new \RuntimeException(\sprintf('Storage type "%s" not supported.', $storageType));
  196.     }
  198.     private function createBinaryFileResponse(
  199.         FileVersion $fileVersion,
  200.         StorageInterface $storage,
  201.         string $locale,
  202.         string $dispositionType
  203.     ): BinaryFileResponse {
  204.         $fileName = $fileVersion->getName();
  205.         $fileSize = $fileVersion->getSize();
  206.         $storageOptions = $fileVersion->getStorageOptions();
  207.         $mimeType = $fileVersion->getMimeType();
  208.         $lastModified = $fileVersion->getCreated(); // use created as file itself is not changed when entity is changed
  210.         $response = new BinaryFileResponse($storage->getPath($storageOptions));
  212.         // Prepare headers
  213.         $disposition = $response->headers->makeDisposition(
  214.             $dispositionType,
  215.             $fileName,
  216.             $this->cleanUpFileName($fileName, $locale, $fileVersion->getExtension())
  217.         );
  219.         // Set headers for
  220.         $file = $fileVersion->getFile();
  221.         if ($fileVersion->getVersion() !== $file->getVersion()) {
  222.             $latestFileVersion = $file->getLatestFileVersion();
  224.             $response->headers->set(
  225.                 'Link',
  226.                 \sprintf(
  227.                     '<%s>; rel="canonical"',
  228.                     $this->mediaManager->getUrl(
  229.                         $file->getMedia()->getId(),
  230.                         $latestFileVersion->getName(),
  231.                         $latestFileVersion->getVersion()
  232.                     )
  233.                 )
  234.             );
  235.             $response->headers->set('X-Robots-Tag', 'noindex, follow');
  236.         }
  238.         // Set headers
  239.         $response->headers->set('Content-Type', !empty($mimeType) ? $mimeType : 'application/octet-stream');
  240.         $response->headers->set('Content-Disposition', $disposition);
  241.         $response->headers->set('Content-length', $fileSize);
  242.         $response->headers->set('Last-Modified', $lastModified->format('D, d M Y H:i:s \G\M\T'));
  244.         return $response;
  245.     }
  247.     /**
  248.      * @param int $id
  249.      * @param int $version
  250.      *
  251.      * @return FileVersion|null
  252.      *
  253.      * @throws FileVersionNotFoundException
  254.      */
  255.     protected function getFileVersion($id, $version)
  256.     {
  257.         /** @var MediaInterface $mediaEntity */
  258.         $mediaEntity = $this->mediaRepository->findMediaById($id);
  260.         if (!$mediaEntity) {
  261.             return null;
  262.         }
  264.         $file = $mediaEntity->getFiles()[0];
  266.         if (!$file) {
  267.             return null;
  268.         }
  270.         if (!$version) {
  271.             $version = $mediaEntity->getFiles()[0]->getVersion();
  272.         }
  274.         $fileVersion = $file->getFileVersion((int) $version);
  276.         if (!$fileVersion) {
  277.             throw new FileVersionNotFoundException($id, $version);
  278.         }
  280.         return $fileVersion;
  281.     }
  283.     /**
  284.      * Cleaned up filename.
  285.      *
  286.      * @param string $fileName
  287.      * @param string $locale
  288.      * @param string $extension
  289.      *
  290.      * @return string
  291.      */
  292.     private function cleanUpFileName($fileName, $locale, $extension)
  293.     {
  294.         $pathInfo = \pathinfo($fileName);
  295.         $cleanedFileName = $this->pathCleaner->cleanup($pathInfo['filename'], $locale);
  296.         if ($extension) {
  297.             $cleanedFileName .= '.' . $extension;
  298.         }
  300.         return $cleanedFileName;
  301.     }
  302. }