vendor/pimcore/pimcore/models/Document/Editable/Image.php line 26

  1. <?php
  2. declare(strict_types=1);
  4. /**
  5.  * Pimcore
  6.  *
  7.  * This source file is available under two different licenses:
  8.  * - GNU General Public License version 3 (GPLv3)
  9.  * - Pimcore Commercial License (PCL)
  10.  * Full copyright and license information is available in
  11.  * LICENSE.md which is distributed with this source code.
  12.  *
  13.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  14.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  15.  */
  17. namespace Pimcore\Model\Document\Editable;
  19. use Pimcore\Model;
  20. use Pimcore\Model\Asset;
  21. use Pimcore\Model\Element;
  22. use Pimcore\Model\Element\ElementDescriptor;
  23. use Pimcore\Tool\Serialize;
  25. /**
  26.  * @method \Pimcore\Model\Document\Editable\Dao getDao()
  27.  */
  28. class Image extends Model\Document\Editable implements IdRewriterInterface, EditmodeDataInterface
  29. {
  30.     /**
  31.      * ID of the referenced image
  32.      *
  33.      * @internal
  34.      */
  35.     protected ?int $id = null;
  37.     /**
  38.      * The ALT text of the image
  39.      *
  40.      * @internal
  41.      */
  42.     protected string $alt = '';
  44.     /**
  45.      * Contains the imageobject itself
  46.      *
  47.      * @internal
  48.      *
  49.      */
  50.     protected Asset\Image|Element\ElementDescriptor|null $image = null;
  52.     /**
  53.      * @internal
  54.      *
  55.      */
  56.     protected bool $cropPercent = false;
  58.     /**
  59.      * @internal
  60.      *
  61.      */
  62.     protected float $cropWidth = 0.0;
  64.     /**
  65.      * @internal
  66.      *
  67.      */
  68.     protected float $cropHeight = 0.0;
  70.     /**
  71.      * @internal
  72.      *
  73.      */
  74.     protected float $cropTop = 0.0;
  76.     /**
  77.      * @internal
  78.      *
  79.      */
  80.     protected float $cropLeft = 0.0;
  82.     /**
  83.      * @internal
  84.      *
  85.      */
  86.     protected array $hotspots = [];
  88.     /**
  89.      * @internal
  90.      *
  91.      */
  92.     protected array $marker = [];
  94.     /**
  95.      * The Thumbnail config of the image
  96.      *
  97.      * @internal
  98.      */
  99.     protected array|string|null $thumbnail = null;
  101.     public function getType(): string
  102.     {
  103.         return 'image';
  104.     }
  106.     public function getData(): mixed
  107.     {
  108.         return [
  109.             'id' => $this->id,
  110.             'alt' => $this->alt,
  111.             'cropPercent' => $this->cropPercent,
  112.             'cropWidth' => $this->cropWidth,
  113.             'cropHeight' => $this->cropHeight,
  114.             'cropTop' => $this->cropTop,
  115.             'cropLeft' => $this->cropLeft,
  116.             'hotspots' => $this->hotspots,
  117.             'marker' => $this->marker,
  118.             'thumbnail' => $this->thumbnail,
  119.         ];
  120.     }
  122.     public function getDataForResource(): array
  123.     {
  124.         return [
  125.             'id' => $this->id,
  126.             'alt' => $this->alt,
  127.             'cropPercent' => $this->cropPercent,
  128.             'cropWidth' => $this->cropWidth,
  129.             'cropHeight' => $this->cropHeight,
  130.             'cropTop' => $this->cropTop,
  131.             'cropLeft' => $this->cropLeft,
  132.             'hotspots' => $this->hotspots,
  133.             'marker' => $this->marker,
  134.             'thumbnail' => $this->thumbnail,
  135.         ];
  136.     }
  138.     public function getDataEditmode(): ?array
  139.     {
  140.         $image = $this->getImage();
  142.         if ($image instanceof Asset\Image) {
  143.             $rewritePath = function ($data) {
  144.                 if (!is_array($data)) {
  145.                     return [];
  146.                 }
  148.                 foreach ($data as &$element) {
  149.                     if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  150.                         foreach ($element['data'] as &$metaData) {
  151.                             if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  152.                                 $metaData = get_object_vars($metaData);
  153.                             }
  155.                             if (in_array($metaData['type'], ['object', 'asset', 'document'])
  156.                             && $el = Element\Service::getElementById($metaData['type'], $metaData['value'])) {
  157.                                 $metaData['value'] = $el;
  158.                             }
  160.                             if ($metaData['value'] instanceof Element\ElementInterface) {
  161.                                 $metaData['value'] = $metaData['value']->getRealFullPath();
  162.                             }
  163.                         }
  164.                     }
  165.                 }
  167.                 return $data;
  168.             };
  170.             $marker = $rewritePath($this->marker);
  171.             $hotspots = $rewritePath($this->hotspots);
  173.             return [
  174.                 'id' => $this->id,
  175.                 'path' => $image->getRealFullPath(),
  176.                 'alt' => $this->alt,
  177.                 'cropPercent' => $this->cropPercent,
  178.                 'cropWidth' => $this->cropWidth,
  179.                 'cropHeight' => $this->cropHeight,
  180.                 'cropTop' => $this->cropTop,
  181.                 'cropLeft' => $this->cropLeft,
  182.                 'hotspots' => $hotspots,
  183.                 'marker' => $marker,
  184.                 'thumbnail' => $this->thumbnail,
  185.                 'predefinedDataTemplates' => $this->getConfig()['predefinedDataTemplates'] ?? null,
  186.             ];
  187.         }
  189.         return null;
  190.     }
  192.     public function getConfig(): array
  193.     {
  194.         $config = parent::getConfig();
  195.         if (isset($config['thumbnail']) && !isset($config['focal_point_context_menu_item'])) {
  196.             $thumbConfig = Asset\Image\Thumbnail\Config::getByAutoDetect($config['thumbnail']);
  197.             if ($thumbConfig) {
  198.                 foreach ($thumbConfig->getItems() as $item) {
  199.                     if ($item['method'] == 'cover') {
  200.                         $config['focal_point_context_menu_item'] = true;
  201.                         $this->config['focal_point_context_menu_item'] = true;
  203.                         break;
  204.                     }
  205.                 }
  206.             }
  207.         }
  209.         return $config;
  210.     }
  212.     public function frontend()
  213.     {
  214.         $image = $this->getImage();
  216.         if ($image instanceof Asset\Image) {
  217.             $thumbnailName = $this->config['thumbnail'] ?? null;
  218.             if ($thumbnailName || $this->cropPercent) {
  219.                 // create a thumbnail first
  220.                 $autoName = false;
  222.                 $thumbConfig = $image->getThumbnail($thumbnailName)->getConfig();
  223.                 if (!$thumbConfig && $this->cropPercent) {
  224.                     $thumbConfig = new Asset\Image\Thumbnail\Config();
  225.                 }
  227.                 if ($this->cropPercent) {
  228.                     $this->applyCustomCropping($thumbConfig);
  229.                     $autoName = true;
  230.                 }
  232.                 if (isset($this->config['highResolution']) && $this->config['highResolution'] > 1) {
  233.                     $thumbConfig->setHighResolution($this->config['highResolution']);
  234.                 }
  236.                 // autogenerate a name for the thumbnail because it's different from the original
  237.                 if ($autoName) {
  238.                     $thumbConfig->generateAutoName();
  239.                 }
  241.                 $deferred = true;
  242.                 if (isset($this->config['deferred'])) {
  243.                     $deferred = $this->config['deferred'];
  244.                 }
  246.                 $thumbnail = $image->getThumbnail($thumbConfig, $deferred);
  247.             } else {
  248.                 // we're using the thumbnail class only to generate the HTML
  249.                 $thumbnail = $image->getThumbnail();
  250.             }
  252.             $attributes = array_merge($this->config, [
  253.                 'alt' => $this->alt,
  254.                 'title' => $this->alt,
  255.             ]);
  257.             $removeAttributes = [];
  258.             if (isset($this->config['removeAttributes']) && is_array($this->config['removeAttributes'])) {
  259.                 $removeAttributes = $this->config['removeAttributes'];
  260.             }
  262.             // thumbnail's HTML is always generated by the thumbnail itself
  263.             return $thumbnail->getHtml($attributes);
  264.         }
  266.         return '';
  267.     }
  269.     public function setDataFromResource(mixed $data): static
  270.     {
  271.         if (strlen($data) > 2) {
  272.             $data = Serialize::unserialize($data);
  273.         }
  275.         $rewritePath = function ($data) {
  276.             if (!is_array($data)) {
  277.                 return [];
  278.             }
  280.             foreach ($data as &$element) {
  281.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  282.                     foreach ($element['data'] as &$metaData) {
  283.                         // this is for backward compatibility (Array vs. MarkerHotspotItem)
  284.                         if (is_array($metaData)) {
  285.                             $metaData = new Element\Data\MarkerHotspotItem($metaData);
  286.                         }
  287.                     }
  288.                 }
  289.             }
  291.             return $data;
  292.         };
  294.         if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  295.             $data['marker'] = $rewritePath($data['marker']);
  296.         }
  298.         if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  299.             $data['hotspots'] = $rewritePath($data['hotspots']);
  300.         }
  302.         $this->setData($data);
  304.         return $this;
  305.     }
  307.     public function setDataFromEditmode(mixed $data): static
  308.     {
  309.         $rewritePath = function ($data) {
  310.             if (!is_array($data)) {
  311.                 return [];
  312.             }
  314.             foreach ($data as &$element) {
  315.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  316.                     foreach ($element['data'] as &$metaData) {
  317.                         $metaData = new Element\Data\MarkerHotspotItem($metaData);
  318.                         if (in_array($metaData['type'], ['object', 'asset', 'document'])) {
  319.                             $el = Element\Service::getElementByPath($metaData['type'], $metaData->getValue());
  320.                             $metaData['value'] = $el;
  321.                         }
  322.                     }
  323.                 }
  324.             }
  326.             return $data;
  327.         };
  329.         if (is_array($data)) {
  330.             if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  331.                 $data['marker'] = $rewritePath($data['marker']);
  332.             }
  334.             if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  335.                 $data['hotspots'] = $rewritePath($data['hotspots']);
  336.             }
  338.             $this->setData($data);
  339.         }
  341.         return $this;
  342.     }
  344.     private function setData(array $data): void
  345.     {
  346.         $this->id = $data['id'] ?? null;
  347.         $this->alt = (string)($data['alt'] ?? '');
  348.         $this->cropPercent = $data['cropPercent'] ?? false;
  349.         $this->cropWidth = $data['cropWidth'] ?? 0;
  350.         $this->cropHeight = $data['cropHeight'] ?? 0;
  351.         $this->cropTop = $data['cropTop'] ?? 0;
  352.         $this->cropLeft = $data['cropLeft'] ?? 0;
  353.         $this->marker = $data['marker'] ?? [];
  354.         $this->hotspots = $data['hotspots'] ?? [];
  355.         $this->thumbnail = $data['thumbnail'] ?? null;
  356.     }
  358.     public function getText(): string
  359.     {
  360.         return $this->alt;
  361.     }
  363.     public function setText(string $text): void
  364.     {
  365.         $this->alt = $text;
  366.     }
  368.     public function getAlt(): string
  369.     {
  370.         return $this->getText();
  371.     }
  373.     public function getThumbnailConfig(): array|string|null
  374.     {
  375.         return $this->thumbnail;
  376.     }
  378.     public function getSrc(): string
  379.     {
  380.         $image = $this->getImage();
  381.         if ($image instanceof Asset) {
  382.             return $image->getFullPath();
  383.         }
  385.         return '';
  386.     }
  388.     public function getImage(): Asset\Image|null
  389.     {
  390.         if (!$this->image instanceof Asset\Image) {
  391.             $this->image = $this->getId() ? Asset\Image::getById($this->getId()) : null;
  392.         }
  394.         return $this->image;
  395.     }
  397.     /**
  398.      * @return $this
  399.      */
  400.     public function setImage(Asset\Image|ElementDescriptor|null $image): static
  401.     {
  402.         $this->image = $image;
  404.         if ($image instanceof Asset\Image) {
  405.             $this->setId($image->getId());
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      *
  413.      * @return $this
  414.      */
  415.     public function setId(?int $id): static
  416.     {
  417.         $this->id = $id;
  419.         return $this;
  420.     }
  422.     public function getId(): ?int
  423.     {
  424.         return $this->id;
  425.     }
  427.     public function getThumbnail(array|string|Asset\Image\Thumbnail\Config $conf, bool $deferred = true): Asset\Image\ThumbnailInterface|string
  428.     {
  429.         $image = $this->getImage();
  430.         if ($image instanceof Asset\Image) {
  431.             $thumbConfig = $image->getThumbnail($conf)->getConfig();
  432.             if ($thumbConfig && $this->cropPercent) {
  433.                 $this->applyCustomCropping($thumbConfig);
  434.                 $thumbConfig->generateAutoName();
  435.             }
  437.             return $image->getThumbnail($thumbConfig, $deferred);
  438.         }
  440.         return '';
  441.     }
  443.     private function applyCustomCropping(Asset\Image\Thumbnail\Config $thumbConfig): void
  444.     {
  445.         $cropConfig = [
  446.             'width' => $this->cropWidth,
  447.             'height' => $this->cropHeight,
  448.             'y' => $this->cropTop,
  449.             'x' => $this->cropLeft,
  450.         ];
  452.         $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig);
  454.         // also crop media query specific configs
  455.         if ($thumbConfig->hasMedias()) {
  456.             foreach ($thumbConfig->getMedias() as $mediaName => $mediaItems) {
  457.                 $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig, $mediaName);
  458.             }
  459.         }
  460.     }
  462.     public function isEmpty(): bool
  463.     {
  464.         $image = $this->getImage();
  465.         if ($image instanceof Asset\Image) {
  466.             return false;
  467.         }
  469.         return true;
  470.     }
  472.     public function getCacheTags(Model\Document\PageSnippet $ownerDocument, array $tags = []): array
  473.     {
  474.         $image = $this->getImage();
  476.         if ($image instanceof Asset) {
  477.             if (!array_key_exists($image->getCacheTag(), $tags)) {
  478.                 $tags = $image->getCacheTags($tags);
  479.             }
  480.         }
  482.         $getMetaDataCacheTags = function ($data, $tags) {
  483.             if (!is_array($data)) {
  484.                 return $tags;
  485.             }
  487.             foreach ($data as $element) {
  488.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  489.                     foreach ($element['data'] as $metaData) {
  490.                         if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  491.                             $metaData = get_object_vars($metaData);
  492.                         }
  494.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  495.                             if (!array_key_exists($metaData['value']->getCacheTag(), $tags)) {
  496.                                 $tags = $metaData['value']->getCacheTags($tags);
  497.                             }
  498.                         }
  499.                     }
  500.                 }
  501.             }
  503.             return $tags;
  504.         };
  506.         $tags = $getMetaDataCacheTags($this->marker, $tags);
  507.         $tags = $getMetaDataCacheTags($this->hotspots, $tags);
  509.         return $tags;
  510.     }
  512.     public function resolveDependencies(): array
  513.     {
  514.         $dependencies = [];
  515.         $image = $this->getImage();
  517.         if ($image instanceof Asset\Image) {
  518.             $key = 'asset_' . $image->getId();
  520.             $dependencies[$key] = [
  521.                 'id' => $image->getId(),
  522.                 'type' => 'asset',
  523.             ];
  524.         }
  526.         $getMetaDataDependencies = function ($data, $dependencies) {
  527.             if (!is_array($data)) {
  528.                 return $dependencies;
  529.             }
  531.             foreach ($data as $element) {
  532.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  533.                     foreach ($element['data'] as $metaData) {
  534.                         if ($metaData instanceof Element\Data\MarkerHotspotItem) {
  535.                             $metaData = get_object_vars($metaData);
  536.                         }
  538.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  539.                             $dependencies[$metaData['type'] . '_' . $metaData['value']->getId()] = [
  540.                                 'id' => $metaData['value']->getId(),
  541.                                 'type' => $metaData['type'],
  542.                             ];
  543.                         }
  544.                     }
  545.                 }
  546.             }
  548.             return $dependencies;
  549.         };
  551.         $dependencies = $getMetaDataDependencies($this->marker, $dependencies);
  552.         $dependencies = $getMetaDataDependencies($this->hotspots, $dependencies);
  554.         return $dependencies;
  555.     }
  557.     /**
  558.      * @return $this
  559.      */
  560.     public function setCropHeight(float $cropHeight): static
  561.     {
  562.         $this->cropHeight = $cropHeight;
  564.         return $this;
  565.     }
  567.     public function getCropHeight(): float
  568.     {
  569.         return $this->cropHeight;
  570.     }
  572.     /**
  573.      * @return $this
  574.      */
  575.     public function setCropLeft(float $cropLeft): static
  576.     {
  577.         $this->cropLeft = $cropLeft;
  579.         return $this;
  580.     }
  582.     public function getCropLeft(): float
  583.     {
  584.         return $this->cropLeft;
  585.     }
  587.     /**
  588.      * @return $this
  589.      */
  590.     public function setCropPercent(bool $cropPercent): static
  591.     {
  592.         $this->cropPercent = $cropPercent;
  594.         return $this;
  595.     }
  597.     public function getCropPercent(): bool
  598.     {
  599.         return $this->cropPercent;
  600.     }
  602.     /**
  603.      * @return $this
  604.      */
  605.     public function setCropTop(float $cropTop): static
  606.     {
  607.         $this->cropTop = $cropTop;
  609.         return $this;
  610.     }
  612.     public function getCropTop(): float
  613.     {
  614.         return $this->cropTop;
  615.     }
  617.     /**
  618.      * @return $this
  619.      */
  620.     public function setCropWidth(float $cropWidth): static
  621.     {
  622.         $this->cropWidth = $cropWidth;
  624.         return $this;
  625.     }
  627.     public function getCropWidth(): float
  628.     {
  629.         return $this->cropWidth;
  630.     }
  632.     /**
  633.      * @return $this
  634.      */
  635.     public function setHotspots(array $hotspots): static
  636.     {
  637.         $this->hotspots = $hotspots;
  639.         return $this;
  640.     }
  642.     public function getHotspots(): array
  643.     {
  644.         return $this->hotspots;
  645.     }
  647.     /**
  648.      * @return $this
  649.      */
  650.     public function setMarker(array $marker): static
  651.     {
  652.         $this->marker = $marker;
  654.         return $this;
  655.     }
  657.     public function getMarker(): array
  658.     {
  659.         return $this->marker;
  660.     }
  662.     public function rewriteIds(array $idMapping): void
  663.     {
  664.         if (array_key_exists('asset', $idMapping) && array_key_exists($this->getId(), $idMapping['asset'])) {
  665.             $this->setId($idMapping['asset'][$this->getId()]);
  667.             // reset marker & hotspot information
  668.             $this->setHotspots([]);
  669.             $this->setMarker([]);
  670.             $this->setCropPercent(false);
  671.             $this->setImage(null);
  672.         }
  673.     }
  675.     public function __sleep(): array
  676.     {
  677.         $finalVars = [];
  678.         $parentVars = parent::__sleep();
  680.         $blockedVars = ['image'];
  682.         foreach ($parentVars as $key) {
  683.             if (!in_array($key, $blockedVars)) {
  684.                 $finalVars[] = $key;
  685.             }
  686.         }
  688.         return $finalVars;
  689.     }
  691.     /**
  692.      * @internal
  693.      *
  694.      * https://github.com/pimcore/pimcore/issues/15932
  695.      * used for non-nullable properties stored with null
  696.      *
  697.      * @TODO: Remove in Pimcore 12
  698.      *
  699.      */
  700.     public function __unserialize(array $data): void
  701.     {
  702.         foreach (get_object_vars($this) as $property => $value) {
  703.             $this->$property = $data["\0*\0".$property] ?? $value;
  704.         }
  705.     }
  706. }