src/Core/Content/ImportExport/DataAbstractionLayer/Serializer/Entity/MediaSerializer.php line 129

  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Content\ImportExport\DataAbstractionLayer\Serializer\Entity;
  5. use Shopware\Core\Content\ImportExport\Exception\InvalidMediaUrlException;
  6. use Shopware\Core\Content\ImportExport\Exception\MediaDownloadException;
  7. use Shopware\Core\Content\ImportExport\Struct\Config;
  8. use Shopware\Core\Content\Media\Aggregate\MediaFolder\MediaFolderEntity;
  9. use Shopware\Core\Content\Media\File\FileSaver;
  10. use Shopware\Core\Content\Media\File\MediaFile;
  11. use Shopware\Core\Content\Media\MediaEvents;
  12. use Shopware\Core\Content\Media\MediaService;
  13. use Shopware\Core\Framework\Context;
  14. use Shopware\Core\Framework\DataAbstractionLayer\EntityDefinition;
  15. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepository;
  16. use Shopware\Core\Framework\DataAbstractionLayer\Event\EntityWrittenEvent;
  17. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  18. use Shopware\Core\Framework\DataAbstractionLayer\Search\Filter\EqualsFilter;
  19. use Shopware\Core\Framework\Log\Package;
  20. use Shopware\Core\Framework\Uuid\Uuid;
  21. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  22. use Symfony\Component\HttpFoundation\Request;
  23. use Symfony\Contracts\Service\ResetInterface;
  25. /**
  26.  * @internal
  27.  */
  28. #[Package('core')]
  29. class MediaSerializer extends EntitySerializer implements EventSubscriberInterface, ResetInterface
  30. {
  31.     /**
  32.      * @var array<string, array{media: MediaFile, destination: string}>
  33.      */
  34.     private array $cacheMediaFiles = [];
  36.     /**
  37.      * @internal
  38.      */
  39.     public function __construct(
  40.         private readonly MediaService $mediaService,
  41.         private readonly FileSaver $fileSaver,
  42.         private readonly EntityRepository $mediaFolderRepository,
  43.         private readonly EntityRepository $mediaRepository
  44.     ) {
  45.     }
  47.     /**
  48.      * @param array<mixed>|\Traversable<mixed> $entity
  49.      *
  50.      * @return array<mixed>|\Traversable<mixed>
  51.      */
  52.     public function deserialize(Config $config, EntityDefinition $definition, $entity)
  53.     {
  54.         $entity = \is_array($entity) ? $entity : iterator_to_array($entity);
  55.         $deserialized = parent::deserialize($config, $definition, $entity);
  56.         $deserialized = \is_array($deserialized) ? $deserialized : iterator_to_array($deserialized);
  58.         $url = $entity['url'] ?? null;
  60.         if (empty($url)) {
  61.             return $deserialized;
  62.         }
  64.         if (!filter_var($url, \FILTER_VALIDATE_URL)) {
  65.             $deserialized['_error'] = new InvalidMediaUrlException($url);
  67.             return $deserialized;
  68.         }
  70.         $media = null;
  71.         if (isset($deserialized['id'])) {
  72.             $media = $this->mediaRepository->search(new Criteria([$deserialized['id']]), Context::createDefaultContext())->first();
  73.         }
  75.         $isNew = $media === null;
  77.         if ($isNew || $media->getUrl() !== $url) {
  78.             $entityName = $config->get('sourceEntity') ?? $definition->getEntityName();
  79.             $deserialized['mediaFolderId'] ??= $this->getMediaFolderId($deserialized['id'] ?? null, $entityName);
  81.             $deserialized['id'] ??= Uuid::randomHex();
  83.             $parsed = parse_url((string) $url);
  84.             if (!$parsed) {
  85.                 throw new \RuntimeException('Error parsing media URL: ' . $url);
  86.             }
  88.             $pathInfo = pathinfo($parsed['path'] ?? '');
  90.             $media = $this->fetchFileFromURL((string) $url, $pathInfo['extension'] ?? '');
  92.             if ($media === null) {
  93.                 $deserialized['_error'] = new MediaDownloadException($url);
  95.                 return $deserialized;
  96.             }
  98.             if ($isNew && $media->getHash()) {
  99.                 $deserialized = $this->fetchExistingMediaByHash($deserialized, $media->getHash());
  100.             }
  102.             $this->cacheMediaFiles[(string) $deserialized['id']] = [
  103.                 'media' => $media,
  104.                 'destination' => $pathInfo['filename'],
  105.             ];
  106.         }
  108.         return $deserialized;
  109.     }
  111.     public function supports(string $entity): bool
  112.     {
  113.         return $entity === 'media';
  114.     }
  116.     /**
  117.      * @return array<string, string|array{0: string, 1: int}|list<array{0: string, 1?: int}>>
  118.      */
  119.     public static function getSubscribedEvents(): array
  120.     {
  121.         return [
  122.             MediaEvents::MEDIA_WRITTEN_EVENT => 'persistMedia',
  123.         ];
  124.     }
  126.     /**
  127.      * @internal
  128.      */
  129.     public function persistMedia(EntityWrittenEvent $event): void
  130.     {
  131.         if (empty($this->cacheMediaFiles)) {
  132.             return;
  133.         }
  135.         $mediaFiles = $this->cacheMediaFiles;
  136.         // prevent recursion
  137.         $this->cacheMediaFiles = [];
  139.         foreach ($event->getIds() as $id) {
  140.             if (!isset($mediaFiles[$id])) {
  141.                 continue;
  142.             }
  143.             $mediaFile = $mediaFiles[$id];
  145.             $this->fileSaver->persistFileToMedia(
  146.                 $mediaFile['media'],
  147.                 $mediaFile['destination'],
  148.                 $id,
  149.                 $event->getContext()
  150.             );
  151.         }
  152.     }
  154.     public function reset(): void
  155.     {
  156.         $this->cacheMediaFiles = [];
  157.     }
  159.     private function getMediaFolderId(?string $id, string $entity): string
  160.     {
  161.         if ($id !== null) {
  162.             /** @var MediaFolderEntity|null $folder */
  163.             $folder = $this->mediaFolderRepository->search(new Criteria([$id]), Context::createDefaultContext())->first();
  164.             if ($folder !== null) {
  165.                 return $folder->getId();
  166.             }
  167.         }
  169.         $criteria = new Criteria();
  170.         $criteria->addFilter(new EqualsFilter('media_folder.defaultFolder.entity', $entity));
  171.         $criteria->addAssociation('defaultFolder');
  173.         /** @var MediaFolderEntity|null $default */
  174.         $default = $this->mediaFolderRepository->search($criteria, Context::createDefaultContext())->first();
  176.         if ($default !== null) {
  177.             return $default->getId();
  178.         }
  180.         $criteria = new Criteria();
  181.         $criteria->addFilter(new EqualsFilter('media_folder.defaultFolder.entity', 'import_export_profile'));
  182.         $criteria->addAssociation('defaultFolder');
  184.         /** @var MediaFolderEntity|null $fallback */
  185.         $fallback = $this->mediaFolderRepository->search($criteria, Context::createDefaultContext())->first();
  186.         if ($fallback === null) {
  187.             throw new \RuntimeException('Failed to find default media folder for import_export_profile');
  188.         }
  190.         return $fallback->getId();
  191.     }
  193.     private function fetchFileFromURL(string $url, string $extension): ?MediaFile
  194.     {
  195.         $request = new Request();
  196.         $request->query->set('url', $url);
  197.         $request->query->set('extension', $extension);
  198.         $request->request->set('url', $url);
  199.         $request->request->set('extension', $extension);
  200.         $request->headers->set('content-type', 'application/json');
  202.         try {
  203.             $file = $this->mediaService->fetchFile($request);
  204.             if ($file !== null && $file->getFileSize() > 0) {
  205.                 return $file;
  206.             }
  207.         } catch (\Throwable) {
  208.         }
  210.         return null;
  211.     }
  213.     /**
  214.      * @param array<string, mixed> $deserialized
  215.      *
  216.      * @return array<string, mixed>
  217.      */
  218.     private function fetchExistingMediaByHash(array $deserialized, string $hash): array
  219.     {
  220.         $criteria = new Criteria();
  221.         $criteria->addFilter(new EqualsFilter('metaData.hash', $hash));
  223.         $media = $this->mediaRepository->search($criteria, Context::createDefaultContext())->first();
  225.         if ($media) {
  226.             $deserialized['id'] = $media->getId();
  227.         }
  229.         return $deserialized;
  230.     }
  231. }