src/Service/Content/ImagesetService.php line 116

Open in your IDE?
  1. <?php
  3. namespace App\Service\Content;
  5. use App\Dictionary\ContentStatus;
  6. use App\Dictionary\ContentType;
  7. use App\Dictionary\ImageFilter;
  8. use App\Entity\Category;
  9. use App\Entity\Content;
  10. use App\Entity\ContentImageset;
  11. use App\Entity\ContentImagesetImage;
  12. use App\Entity\Member;
  13. use App\Entity\MemberContent;
  14. use App\Event\Content\ImagesetImageDeleteEvent;
  15. use App\Exception\Content\ContentStatusException;
  16. use App\Lib\Content\Imagine\PixelateFilter;
  17. use App\Lib\Content\PreviewPhoto;
  18. use App\Repository\ContentImagesetImageRepository;
  19. use App\Repository\ContentImagesetRepository;
  20. use App\Response\EntityRemoved;
  21. use App\Service\Media\FileUploader\ImagesetImageUploader;
  22. use App\Service\Media\StorageLayer;
  23. use Doctrine\ORM\Tools\Pagination\Paginator;
  24. use Imagine\Image\Box;
  25. use Imagine\Image\ImageInterface;
  26. use Imagine\Image\ImagineInterface;
  27. use Imagine\Image\ManipulatorInterface;
  28. use League\Flysystem\FileExistsException;
  29. use League\Flysystem\FileNotFoundException;
  30. use Liip\ImagineBundle\Service\FilterService;
  31. use Psr\Log\LoggerInterface;
  32. use Symfony\Component\HttpFoundation\FileBag;
  33. use Symfony\Component\HttpFoundation\ParameterBag;
  34. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  36. class ImagesetService extends AbstractContentService
  37. {
  38.     /**
  39.      * @var string
  40.      */
  41.     public const SECRET_KEY = 'KdkjFdZj3oijiejopJWjp93jIJouh34KPol3B';
  43.     /**
  44.      * @var ContentImagesetRepository
  45.      */
  46.     protected $repo;
  47.     protected ContentImagesetImageRepository $imageRepo;
  48.     protected ImagesetImageUploader $uploader;
  49.     protected ContentService $contentService;
  50.     protected FilterService $filterService;
  51.     protected ImagineInterface $imagine;
  52.     protected LoggerInterface $logger;
  53.     protected StorageLayer $storageLayer;
  54.     protected PixelateFilter $pixelateFilter;
  56.     /**
  57.      * ImagesetService constructor.
  58.      */
  59.     public function __construct(ContentImagesetRepository $repo, ContentImagesetImageRepository $imageRepository,
  60.         ImagesetImageUploader $uploader,
  61.         ContentService $contentService, FilterService $filterService,
  62.         EventDispatcherInterface $dispatcher, ImagineInterface $imagine,
  63.         LoggerInterface $logger, StorageLayer $storageLayer)
  64.     {
  65.         parent::__construct($repo, $dispatcher);
  67.         $this->logger = $logger;
  68.         $this->contentService = $contentService;
  69.         $this->filterService = $filterService;
  70.         $this->imagine = $imagine;
  71.         $this->imageRepo = $imageRepository;
  72.         $this->storageLayer = $storageLayer;
  74.         $this->setUploader($uploader);
  75.         $this->pixelateFilter = new PixelateFilter($this->imagine);
  76.     }
  78.     public function getImagesetRepo(): ContentImagesetRepository
  79.     {
  80.         return $this->repo;
  81.     }
  83.     public function getUploader(): ImagesetImageUploader
  84.     {
  85.         return $this->uploader;
  86.     }
  88.     public function setUploader(ImagesetImageUploader $uploader): self
  89.     {
  90.         $this->uploader = $uploader;
  92.         return $this;
  93.     }
  95.     /**
  96.      * @throws \Doctrine\ORM\ORMException
  97.      * @throws \Doctrine\ORM\OptimisticLockException
  98.      */
  99.     public function storeContentImageset(ContentImageset $entity): ContentImageset
  100.     {
  101.         $entity->setPics($entity->getImages()->count());
  103.         return $this->storeEntity($entity);
  104.     }
  106.     public function findBySlug(string $slug, bool $ignoreContentStatus = false): ?ContentImageset
  107.     {
  108.         if ($ignoreContentStatus) {
  109.             return $this->getRepository()->findOneBy(['slug' => $slug]);
  110.         }
  112.         $qb = $this->getRepository()->getBaseImagesetQueryBuilder([]);
  113.         $qb->andWhere('i.slug = :slug');
  114.         $qb->setParameter(':slug', $slug);
  116.         return $qb->getQuery()->getOneOrNullResult();
  117.     }
  119.     public function findByPublicPath(string $publicPath): ?ContentImageset
  120.     {
  121.         return $this->getRepository()->findOneBy(['public_path' => $publicPath]);
  122.     }
  124.     public function mayAddImagesToContentImageset(ContentImageset $imageset): bool
  125.     {
  126.         $content = $imageset->getContent();
  127.         if (ContentType::IMAGESET !== $content->getType()) {
  128.             return false;
  129.         }
  131.         return ContentStatus::ACTIVE !== $content->getStatus();
  132.     }
  134.     public function createImagesetImageForSet(ContentImageset $contentImageset): ContentImagesetImage
  135.     {
  136.         if (!$this->mayAddImagesToContentImageset($contentImageset)) {
  137.             throw new ContentStatusException('Content already published.');
  138.         }
  139.         $image = new ContentImagesetImage();
  140.         $contentImageset->addImagesetImage($image);
  142.         return $image;
  143.     }
  145.     public function applyValuesToImageEntity(ParameterBag $bag, FileBag $fileBag, ContentImagesetImage $entity): ContentImagesetImage
  146.     {
  147.         try {
  148.             $defaultPriority = $entity->getContentImageset()->getImages()->count() + 1;
  149.         } catch (\Throwable $t) {
  150.             $defaultPriority = 1;
  151.         }
  153.         $entity->setPriority($bag->getInt('priority', $defaultPriority));
  154.         if ($fileBag->has('file')) {
  155.             $fileName = $this->getUploader()->upload($fileBag->get('file'));
  156.             if (null === $fileName) {
  157.                 throw new \Exception('writing file failed');
  158.             }
  159.         }
  161.         return $entity;
  162.     }
  164.     /**
  165.      * @throws \Doctrine\ORM\ORMException
  166.      * @throws \Doctrine\ORM\OptimisticLockException
  167.      */
  168.     public function deleteImagesetImage(ContentImagesetImage $image): EntityRemoved
  169.     {
  170.         // deletes files
  171.         $this->getEventDispatcher()->dispatch(new ImagesetImageDeleteEvent($image));
  173.         return new EntityRemoved($this->imageRepo->deleteEntity($image->getId(), true), $image->getId());
  174.     }
  176.     public function deleteImageFiltersInStorage(ContentImagesetImage $image, array $filters = [], ?bool $blur = null): void
  177.     {
  178.         if (empty($filters)) {
  179.             $filters = [ImageFilter::PREVIMG_SMALL, ImageFilter::PREVIMG_BIG, ImageFilter::PHOTOS, ImageFilter::THUMBS];
  180.         }
  181.         $filesToDelete = [];
  182.         foreach ($filters as $filter) {
  183.             if (null === $blur) {
  184.                 $url = $this->getUrlForImagesetImage($image, false, $filter);
  185.                 $filesToDelete[] = substr($url, strpos($url, '/media/'));
  186.                 $url = $this->getUrlForImagesetImage($image, true, $filter);
  187.                 $filesToDelete[] = substr($url, strpos($url, '/media/'));
  188.             } else {
  189.                 $url = $this->getUrlForImagesetImage($image, $blur, $filter);
  190.                 $filesToDelete[] = substr($url, strpos($url, '/media/'));
  191.             }
  192.         }
  194.         foreach ($filesToDelete as $filepath) {
  195.             if (empty($filepath)) {
  196.                 continue;
  197.             }
  198.             try {
  199.                 $this->storageLayer->getMediacacheStorage()->delete($filepath);
  200.             } catch (FileNotFoundException $e) {
  201.                 $this->logger->warning('Not found when deleting imageset image: '.$e->getMessage().PHP_EOL.$e->getTraceAsString());
  202.             }
  203.         }
  204.     }
  206.     public function getImagesetImageById(int $id): ?ContentImagesetImage
  207.     {
  208.         return $this->imageRepo->find($id);
  209.     }
  211.     /**
  212.      * @return ContentImagesetImage[]
  213.      */
  214.     public function getImagesetImagesById(array $ids): array
  215.     {
  216.         return $this->imageRepo->findBy(['id' => $ids]);
  217.     }
  219.     public function getImagesetImagesByMemberContent(array $memberContents): array
  220.     {
  221.         $finalImages = [];
  222.         $imagesetImageIds = [];
  223.         /** @var MemberContent $mc */
  224.         foreach ($memberContents as $mc) {
  225.             $imageId = $mc->getImagesetImageId();
  226.             // Add all images for old memberContent where imagesetImageId is null
  227.             if (null === $imageId) {
  228.                 $allImages = $mc->getContent()->getImageset()->getImages();
  229.                 foreach ($allImages as $image) {
  230.                     $finalImages[$image->getId()] = $image;
  231.                 }
  233.                 continue;
  234.             }
  236.             // Add single image purchase
  237.             if (!isset($finalImages[$imageId])) {
  238.                 $imagesetImageIds[$mc->getImagesetImageId()] = $mc->getImagesetImageId();
  239.             }
  240.         }
  242.         return array_merge($finalImages, $this->getImagesetImagesById($imagesetImageIds));
  243.     }
  245.     public function getImagesetImageByPosition(ContentImageset $imageset, int $position): ?ContentImagesetImage
  246.     {
  247.         return $this->imageRepo->findOneBy([
  248.             'content_imageset' => $imageset,
  249.             'priority' => $position,
  250.         ]);
  251.     }
  253.     public function getActiveImagesetsByCategory(Category $category, int $page, int $limit): Paginator
  254.     {
  255.         $qb = $this->repo->getActiveImagesetsByCategoryQueryBuilder($category);
  257.         $qb->setMaxResults($limit);
  258.         $qb->setFirstResult($page * $limit - $limit);
  260.         return new Paginator($qb->getQuery());
  261.     }
  263.     public function getImagesetsByMember(Member $member, int $page, array $statuses, int $limit): Paginator
  264.     {
  265.         return $this->repo->getImagesetsByMember($member, $page, $statuses, $limit);
  266.     }
  268.     public function getFilenameHash(Content $content, ContentImagesetImage $image, bool $blur = false): string
  269.     {
  270.         $secret = $this->getSecret($content);
  271.         $hash2 = md5($content->getId().'/'.$image->getId().$secret.($blur ? 'A' : 'B'));
  273.         return substr($hash2, 0, 8);
  274.     }
  276.     protected function getSecret(Content $content): string
  277.     {
  278.         return self::SECRET_KEY.$content->getCreatedAt()->format('Ym');
  279.     }
  281.     public function getFoldernameHash(Content $content): string
  282.     {
  283.         $hash = md5($content->getId().$this->getSecret($content));
  285.         return substr($hash, -2).'/'.substr($hash, -4, 2).'/'.$content->getId();
  286.     }
  288.     /**
  289.      * @return string
  290.      */
  291.     public function getFullHash(Content $content, ContentImagesetImage $image, bool $blur)
  292.     {
  293.         return $this->getFoldernameHash($content).'/'.$image->getId().'.'.$this->getFilenameHash($content, $image, $blur);
  294.     }
  296.     public function getSourceFile(int $content, int $image): string
  297.     {
  298.         return $this->getSourceFilepath($content).'/'.$this->getSourceFilename($image);
  299.     }
  301.     public function getSourceFilename(int $imageId): string
  302.     {
  303.         return $imageId.'.large.jpg';
  304.     }
  306.     public function getSourceFilepath(int $content): string
  307.     {
  308.         $paddedId = str_pad($content, 7, '0', STR_PAD_LEFT);
  309.         $parts = [
  310.             substr($paddedId, 0, 2),
  311.             substr($paddedId, 2, 2),
  312.             substr($paddedId, 4, 2),
  313.             $paddedId,
  314.         ];
  316.         return implode('/', $parts);
  317.     }
  319.     public function makeHash(Content $content, ContentImagesetImage $image, bool $blur = false)
  320.     {
  321.         $secret = $this->getSecret($content);
  322.         $hash2 = md5($content->getId().'/'.$image->getId().$secret.($blur ? 'A' : 'B'));
  324.         return substr($hash2, 0, 8);
  325.     }
  327.     public function getUrlForImagesetImage(ContentImagesetImage $image, bool $blur, string $filter = 'previmg_big'): ?string
  328.     {
  329.         $path = $this->getPathForUrl($image, $blur);
  330.         if (null === $path || ($blur && ImageFilter::PHOTOS === $filter)) {
  331.             return null;
  332.         }
  334.         return sprintf('%s/mediacache/media/%s/%s', $_ENV['APP_HOST_ASSETS'], $filter, $path);
  335.     }
  337.     /**
  338.      * Will always overwrite blurred file.
  339.      */
  340.     public function getUrlForImagesetImageWithProcessing(ContentImagesetImage $imagesetImage, bool $blur, string $filter, bool $deleteBeforeGenerate = false): ?string
  341.     {
  342.         $path = $this->getPathForUrl($imagesetImage, $blur);
  343.         if (null === $path || ($blur && ImageFilter::PHOTOS === $filter)) {
  344.             return null;
  345.         }
  347.         try {
  348.             if ($deleteBeforeGenerate) {
  349.                 try {
  350.                     $this->storageLayer->getMediacacheStorage()->delete('/media/'.$filter.'/'.$path);
  351.                 } catch (FileNotFoundException $fee) {
  352.                     $this->logger->debug('info: '.$fee->getMessage().PHP_EOL.$fee->getTraceAsString());
  353.                 }
  354.             }
  355.             \Imagick::setResourceLimit(\Imagick::RESOURCETYPE_THREAD, 8);
  356.             // getUrlOfFilteredImage() triggers liip-imagine filters
  357.             $url = $this->filterService->getUrlOfFilteredImage($path, $filter);
  359.             // Photos-filter does not need blurring and thumbs is already done by ImagesetThumbnailDataLoader.
  360.             if ($blur && in_array($filter, [ImageFilter::PREVIMG_SMALL, ImageFilter::PREVIMG_BIG], true)) {
  361.                 $readPath = sprintf('/media/%s/%s', $filter, $path);
  362.                 $resource = $this->storageLayer->getMediacacheStorage()->readStream($readPath);
  363.                 $image = $this->imagine->read($resource);
  364.                 $image = $this->pixelateImagesetImage($image);
  366.                 // Always overwrite blurred file
  367.                 try {
  368.                     $this->storageLayer->getMediacacheStorage()->write($readPath, $image->get('webp'));
  369.                 } catch (FileExistsException $fee) {
  370.                     $this->storageLayer->getMediacacheStorage()->update($readPath, $image->get('webp'));
  371.                 }
  372.             }
  374.             return $url;
  375.         } catch (\Exception $e) {
  376.             $this->logger->error('1st msg: '.$e->getMessage().' 2nd code: '.$e->getCode().PHP_EOL.$e->getTraceAsString());
  377.             $this->logger->error('2nd msg: '.$e->getPrevious()?->getMessage().' 2nd code: '.$e->getPrevious()?->getCode().PHP_EOL);
  378.         }
  380.         return null;
  381.     }
  383.     private function pixelateImagesetImage(ImageInterface $image): ImageInterface
  384.     {
  385.         return $this->pixelateFilter->applyForImagesetImage($image);
  386.     }
  388.     private function getPathForUrl(ContentImagesetImage $image, bool $blur): ?string
  389.     {
  390.         $set = $image->getContentImageset();
  391.         $hash = $this->makeHash($set->getContent(), $image, $blur);
  392.         $path = $set->getPublicPath();
  394.         if (empty($path)) {
  395.             return null;
  396.         }
  398.         return $path.'/'.$image->getId().'.'.$hash.'.jpg';
  399.     }
  401.     public function bustCacheForImagesetImage(ContentImagesetImage $image, string $filter): bool
  402.     {
  403.         $set = $image->getContentImageset();
  404.         $path = $this->getFoldernameHash($set->getContent());
  406.         // blurred
  407.         $hash = $this->getFilenameHash($set->getContent(), $image, true);
  408.         $filename = $image->getId().'.'.$hash.'.jpg';
  409.         $this->filterService->bustCache($path.'/'.$filename, $filter);
  411.         // original
  412.         $hash = $this->getFilenameHash($set->getContent(), $image, false);
  413.         $filename = $image->getId().'.'.$hash.'.jpg';
  414.         $this->filterService->bustCache($path.'/'.$filename, $filter);
  416.         return true;
  417.     }
  419.     /**
  420.      * @throws FileExistsException
  421.      * @throws FileNotFoundException
  422.      */
  423.     public function resizePreviewPhoto(PreviewPhoto $photo): bool
  424.     {
  425.         $path = $photo->getStoragePath();
  426.         if (!$this->storageLayer->hasPublicFile($path)) {
  427.             return false;
  428.         }
  429.         $input = $this->storageLayer->readPublicFileStream($path);
  430.         $image = $this->imagine->read($input);
  432.         if ($image->getSize()->getWidth() <= 640 && $image->getSize()->getHeight() < 360) {
  433.             return false;
  434.         }
  435.         $size = new Box(640, 360);
  436.         $thumb = $image->thumbnail($size, ManipulatorInterface::THUMBNAIL_OUTBOUND);
  438.         $this->storageLayer->overwritePublicFile($path, $thumb->get('png'));
  440.         return true;
  441.     }
  443.     public function getImagesetImageIdByWebPath(string $path): int
  444.     {
  445.         return (int) explode('.', basename($path))[0];
  446.     }
  448.     public function getImagesetByWebpath(string $path): ContentImageset
  449.     {
  450.         if (in_array(substr($path, -4), ['.jpg', '.png']) || in_array(substr($path, -5), ['.jpeg', '.webp'])) {
  451.             $path = dirname($path);
  452.         }
  454.         return $this->findByPublicPath($path);
  455.     }
  456. }