vendor/sulu/sulu/src/Sulu/Bundle/MediaBundle/Media/FormatManager/FormatManager.php line 145

  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\Media\FormatManager;
  14. use Psr\Log\LoggerInterface;
  15. use Psr\Log\NullLogger;
  16. use Sulu\Bundle\MediaBundle\Entity\FileVersion;
  17. use Sulu\Bundle\MediaBundle\Entity\MediaInterface;
  18. use Sulu\Bundle\MediaBundle\Entity\MediaRepository;
  19. use Sulu\Bundle\MediaBundle\Entity\MediaRepositoryInterface;
  20. use Sulu\Bundle\MediaBundle\Media\Exception\FormatNotFoundException;
  21. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyInvalidImageFormat;
  22. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyInvalidUrl;
  23. use Sulu\Bundle\MediaBundle\Media\Exception\ImageProxyMediaNotFoundException;
  24. use Sulu\Bundle\MediaBundle\Media\Exception\InvalidMimeTypeForPreviewException;
  25. use Sulu\Bundle\MediaBundle\Media\Exception\MediaException;
  26. use Sulu\Bundle\MediaBundle\Media\FormatCache\FormatCacheInterface;
  27. use Sulu\Bundle\MediaBundle\Media\ImageConverter\ImageConverterInterface;
  28. use Symfony\Component\Filesystem\Filesystem;
  29. use Symfony\Component\HttpFoundation\ParameterBag;
  30. use Symfony\Component\HttpFoundation\Response;
  32. /**
  33.  * Sulu format manager for media.
  34.  */
  35. class FormatManager implements FormatManagerInterface
  36. {
  37.     /**
  38.      * The repository for communication with the database.
  39.      *
  40.      * @var MediaRepository
  41.      */
  42.     private $mediaRepository;
  44.     /**
  45.      * @var FormatCacheInterface
  46.      */
  47.     private $formatCache;
  49.     /**
  50.      * @var ImageConverterInterface
  51.      */
  52.     private $converter;
  54.     /**
  55.      * @var bool
  56.      */
  57.     private $saveImage = false;
  59.     /**
  60.      * @var array
  61.      */
  62.     private $responseHeaders = [];
  64.     /**
  65.      * @var Filesystem
  66.      */
  67.     private $fileSystem;
  69.     /**
  70.      * @var array
  71.      */
  72.     private $formats;
  74.     /**
  75.      * @var LoggerInterface
  76.      */
  77.     private $logger;
  79.     /**
  80.      * @var ParameterBag|null
  81.      */
  82.     private $supportedImageFormats;
  84.     /**
  85.      * @param string $saveImage
  86.      * @param array $responseHeaders
  87.      * @param array $formats
  88.      * @param LoggerInterface $logger
  89.      */
  90.     public function __construct(
  91.         MediaRepositoryInterface $mediaRepository,
  92.         FormatCacheInterface $formatCache,
  93.         ImageConverterInterface $converter,
  94.         $saveImage,
  95.         $responseHeaders,
  96.         $formats,
  97.         LoggerInterface $logger = null
  98.     ) {
  99.         $this->mediaRepository = $mediaRepository;
  100.         $this->formatCache = $formatCache;
  101.         $this->converter = $converter;
  102.         $this->saveImage = 'true' == $saveImage ? true : false;
  103.         $this->responseHeaders = $responseHeaders;
  104.         $this->fileSystem = new Filesystem();
  105.         $this->formats = $formats;
  106.         $this->logger = $logger ?: new NullLogger();
  107.     }
  109.     public function returnImage($id, $formatKey, $fileName)
  110.     {
  111.         $setExpireHeaders = false;
  113.         try {
  114.             $info = \pathinfo($fileName);
  116.             if (!isset($info['extension'])) {
  117.                 throw new ImageProxyInvalidUrl('No `extension` was found in the url');
  118.             }
  120.             $imageFormat = $info['extension'];
  122.             $media = $this->mediaRepository->findMediaByIdForRendering($id, $formatKey);
  124.             if (!$media) {
  125.                 throw new ImageProxyMediaNotFoundException('Media was not found');
  126.             }
  128.             $fileVersion = $this->getLatestFileVersion($media);
  130.             $supportedImageFormats = $this->converter->getSupportedOutputImageFormats($fileVersion->getMimeType());
  131.             if (empty($supportedImageFormats)) {
  132.                 throw new InvalidMimeTypeForPreviewException($fileVersion->getMimeType());
  133.             }
  135.             if (!\in_array($imageFormat, $supportedImageFormats)) {
  136.                 throw new ImageProxyInvalidImageFormat(
  137.                     \sprintf(
  138.                         'Image format "%s" not supported. Supported image formats are: %s',
  139.                         $imageFormat,
  140.                         \implode(', ', $supportedImageFormats)
  141.                     ));
  142.             }
  144.             // Convert Media to format.
  145.             $responseContent = $this->converter->convert($fileVersion, $formatKey, $imageFormat);
  147.             // HTTP Headers
  148.             $status = 200;
  149.             $setExpireHeaders = true;
  151.             $finfo = new \finfo(\FILEINFO_MIME_TYPE);
  152.             $mimeType = $finfo->buffer($responseContent);
  154.             // Save image.
  155.             if ($this->saveImage) {
  156.                 $this->formatCache->save(
  157.                     $responseContent,
  158.                     $media->getId(),
  159.                     $this->replaceExtension($fileVersion->getName(), $imageFormat),
  160.                     $formatKey
  161.                 );
  162.             }
  163.         } catch (MediaException $e) {
  164.             $this->logger->error($e->getMessage(), ['exception' => $e]);
  165.             $responseContent = null;
  166.             $status = 404;
  167.             $mimeType = null;
  168.         }
  170.         // Set header.
  171.         $headers = $this->getResponseHeaders($mimeType, $setExpireHeaders);
  173.         // Return image.
  174.         return new Response($responseContent, $status, $headers);
  175.     }
  177.     public function getFormats($id, $fileName, $version, $subVersion, $mimeType)
  178.     {
  179.         $formats = [];
  181.         $extensions = $this->converter->getSupportedOutputImageFormats($mimeType);
  183.         if (empty($extensions)) {
  184.             return [];
  185.         }
  187.         $originalExtension = $extensions[0];
  188.         foreach ($this->formats as $format) {
  189.             foreach ($extensions as $extension) {
  190.                 $formatUrl = $this->formatCache->getMediaUrl(
  191.                     $id,
  192.                     $this->replaceExtension($fileName, $extension),
  193.                     $format['key'],
  194.                     $version,
  195.                     $subVersion
  196.                 );
  198.                 if ($extension === $originalExtension) {
  199.                     $formats[$format['key']] = $formatUrl;
  200.                 }
  202.                 $formats[$format['key'] . '.' . $extension] = $formatUrl;
  203.             }
  204.         }
  206.         return $formats;
  207.     }
  209.     public function purge($idMedia, $fileName, $mimeType)
  210.     {
  211.         $extensions = $this->converter->getSupportedOutputImageFormats($mimeType);
  213.         if (empty($extensions)) {
  214.             return true;
  215.         }
  217.         foreach ($this->formats as $format) {
  218.             foreach ($extensions as $extension) {
  219.                 $this->formatCache->purge($idMedia, $this->replaceExtension($fileName, $extension), $format['key']);
  220.             }
  221.         }
  223.         return true;
  224.     }
  226.     public function clearCache()
  227.     {
  228.         $this->formatCache->clear();
  229.     }
  231.     public function getFormatDefinition($formatKey, $locale = null)
  232.     {
  233.         if (!isset($this->formats[$formatKey])) {
  234.             throw new FormatNotFoundException($formatKey);
  235.         }
  237.         $format = $this->formats[$formatKey];
  238.         $title = $format['key'];
  240.         if (\array_key_exists($locale, $format['meta']['title'])) {
  241.             $title = $format['meta']['title'][$locale];
  242.         } elseif (\count($format['meta']['title']) > 0) {
  243.             $title = \array_values($format['meta']['title'])[0];
  244.         }
  246.         $formatArray = [
  247.             'internal' => $format['internal'],
  248.             'key' => $format['key'],
  249.             'title' => $title,
  250.             'scale' => $format['scale'],
  251.         ];
  253.         return $formatArray;
  254.     }
  256.     public function getFormatDefinitions($locale = null)
  257.     {
  258.         $definitionsArray = [];
  260.         foreach ($this->formats as $format) {
  261.             $options = [];
  262.             $definitionsArray[$format['key']] = $this->getFormatDefinition($format['key'], $locale);
  263.         }
  265.         return $definitionsArray;
  266.     }
  268.     /**
  269.      * @param string $mimeType
  270.      * @param bool $setExpireHeaders
  271.      *
  272.      * @return array
  273.      */
  274.     protected function getResponseHeaders($mimeType = '', $setExpireHeaders = false)
  275.     {
  276.         $headers = [];
  278.         if (!empty($mimeType)) {
  279.             $headers['Content-Type'] = $mimeType;
  280.         }
  282.         if (empty($this->responseHeaders)) {
  283.             return $headers;
  284.         }
  286.         $headers = \array_merge(
  287.             $headers,
  288.             $this->responseHeaders
  289.         );
  291.         if (isset($this->responseHeaders['Expires']) && $setExpireHeaders) {
  292.             $date = new \DateTime();
  293.             $date->modify($this->responseHeaders['Expires']);
  294.             $headers['Expires'] = $date->format('D, d M Y H:i:s \G\M\T');
  295.         } else {
  296.             // will remove exist set expire header
  297.             $headers['Expires'] = null;
  298.             $headers['Cache-Control'] = 'no-cache';
  299.             $headers['Pragma'] = null;
  300.         }
  302.         return $headers;
  303.     }
  305.     /**
  306.      * Replace extension.
  307.      *
  308.      * @param string $filename
  309.      * @param string $newExtension
  310.      *
  311.      * @return string
  312.      */
  313.     private function replaceExtension($filename, $newExtension)
  314.     {
  315.         $info = \pathinfo($filename);
  317.         return $info['filename'] . '.' . $newExtension;
  318.     }
  320.     /**
  321.      * @return FileVersion
  322.      *
  323.      * @throws ImageProxyMediaNotFoundException
  324.      */
  325.     private function getLatestFileVersion(MediaInterface $media)
  326.     {
  327.         foreach ($media->getFiles() as $file) {
  328.             $version = $file->getVersion();
  329.             foreach ($file->getFileVersions() as $fileVersion) {
  330.                 if ($fileVersion->getVersion() == $version) {
  331.                     return $fileVersion;
  332.                 }
  333.             }
  334.             break;
  335.         }
  337.         throw new ImageProxyMediaNotFoundException('Media file version was not found');
  338.     }
  339. }