vendor/pimcore/pimcore/models/Document/Tag/Image.php line 28

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @category   Pimcore
  12.  * @package    Document
  13.  *
  14.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  16.  */
  18. namespace Pimcore\Model\Document\Tag;
  20. use Pimcore\Model;
  21. use Pimcore\Model\Asset;
  22. use Pimcore\Model\Element;
  23. use Pimcore\Tool\Serialize;
  25. /**
  26.  * @method \Pimcore\Model\Document\Tag\Dao getDao()
  27.  */
  28. class Image extends Model\Document\Tag
  29. {
  30.     /**
  31.      * ID of the referenced image
  32.      *
  33.      * @var int
  34.      */
  35.     public $id;
  37.     /**
  38.      * The ALT text of the image
  39.      *
  40.      * @var string
  41.      */
  42.     public $alt;
  44.     /**
  45.      * Contains the imageobject itself
  46.      *
  47.      * @var Asset\Image
  48.      */
  49.     public $image;
  51.     /**
  52.      * @var bool
  53.      */
  54.     public $cropPercent = false;
  56.     /**
  57.      * @var float
  58.      */
  59.     public $cropWidth;
  61.     /**
  62.      * @var float
  63.      */
  64.     public $cropHeight;
  66.     /**
  67.      * @var float
  68.      */
  69.     public $cropTop;
  71.     /**
  72.      * @var float
  73.      */
  74.     public $cropLeft;
  76.     /**
  77.      * @var array
  78.      */
  79.     public $hotspots = [];
  81.     /**
  82.      * @var array
  83.      */
  84.     public $marker = [];
  86.     /**
  87.      * @see TagInterface::getType
  88.      *
  89.      * @return string
  90.      */
  91.     public function getType()
  92.     {
  93.         return 'image';
  94.     }
  96.     /**
  97.      * @see TagInterface::getData
  98.      *
  99.      * @return array
  100.      */
  101.     public function getData()
  102.     {
  103.         return [
  104.             'id' => $this->id,
  105.             'alt' => $this->alt,
  106.             'cropPercent' => $this->cropPercent,
  107.             'cropWidth' => $this->cropWidth,
  108.             'cropHeight' => $this->cropHeight,
  109.             'cropTop' => $this->cropTop,
  110.             'cropLeft' => $this->cropLeft,
  111.             'hotspots' => $this->hotspots,
  112.             'marker' => $this->marker
  113.         ];
  114.     }
  116.     /**
  117.      * @return array
  118.      */
  119.     public function getDataForResource()
  120.     {
  121.         return [
  122.             'id' => $this->id,
  123.             'alt' => $this->alt,
  124.             'cropPercent' => $this->cropPercent,
  125.             'cropWidth' => $this->cropWidth,
  126.             'cropHeight' => $this->cropHeight,
  127.             'cropTop' => $this->cropTop,
  128.             'cropLeft' => $this->cropLeft,
  129.             'hotspots' => $this->hotspots,
  130.             'marker' => $this->marker
  131.         ];
  132.     }
  134.     /**
  135.      * Converts the data so it's suitable for the editmode
  136.      *
  137.      * @return array
  138.      */
  139.     public function getDataEditmode()
  140.     {
  141.         $image = $this->getImage();
  143.         if ($image instanceof Asset\Image) {
  144.             $rewritePath = function ($data) {
  145.                 if (!is_array($data)) {
  146.                     return [];
  147.                 }
  149.                 foreach ($data as &$element) {
  150.                     if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  151.                         foreach ($element['data'] as &$metaData) {
  152.                             if ($metaData['value'] instanceof Element\ElementInterface) {
  153.                                 $metaData['value'] = $metaData['value']->getRealFullPath();
  154.                             }
  155.                         }
  156.                     }
  157.                 }
  159.                 return $data;
  160.             };
  162.             $marker = $rewritePath($this->marker);
  163.             $hotspots = $rewritePath($this->hotspots);
  165.             $marker = object2array($marker);
  166.             $hotspots = object2array($hotspots);
  168.             return [
  169.                 'id' => $this->id,
  170.                 'path' => $image->getFullPath(),
  171.                 'alt' => $this->alt,
  172.                 'cropPercent' => $this->cropPercent,
  173.                 'cropWidth' => $this->cropWidth,
  174.                 'cropHeight' => $this->cropHeight,
  175.                 'cropTop' => $this->cropTop,
  176.                 'cropLeft' => $this->cropLeft,
  177.                 'hotspots' => $hotspots,
  178.                 'marker' => $marker,
  179.                 'predefinedDataTemplates' => $this->getOptions()['predefinedDataTemplates'] ?? null,
  180.             ];
  181.         }
  183.         return null;
  184.     }
  186.     /**
  187.      * @return array
  188.      */
  189.     public function getOptions()
  190.     {
  191.         $options = parent::getOptions();
  192.         if (isset($options['thumbnail']) && !isset($options['focal_point_context_menu_item'])) {
  193.             $thumbConfig = Asset\Image\Thumbnail\Config::getByAutoDetect($options['thumbnail']);
  194.             if ($thumbConfig) {
  195.                 foreach ($thumbConfig->getItems() as $item) {
  196.                     if ($item['method'] == 'cover') {
  197.                         $options['focal_point_context_menu_item'] = true;
  198.                         $this->options['focal_point_context_menu_item'] = true;
  199.                         break;
  200.                     }
  201.                 }
  202.             }
  203.         }
  205.         return $options;
  206.     }
  208.     /**
  209.      * @see TagInterface::frontend
  210.      *
  211.      * @return string
  212.      */
  213.     public function frontend()
  214.     {
  215.         if (!is_array($this->options)) {
  216.             $this->options = [];
  217.         }
  219.         $image = $this->getImage();
  221.         if ($image instanceof Asset) {
  222.             $thumbnailName = $this->options['thumbnail'] ?? null;
  223.             if ($thumbnailName || $this->cropPercent) {
  224.                 // create a thumbnail first
  225.                 $autoName = false;
  227.                 $thumbConfig = $image->getThumbnailConfig($thumbnailName);
  228.                 if (!$thumbConfig && $this->cropPercent) {
  229.                     $thumbConfig = new Asset\Image\Thumbnail\Config();
  230.                 }
  232.                 if ($this->cropPercent) {
  233.                     $this->applyCustomCropping($thumbConfig);
  234.                     $autoName = true;
  235.                 }
  237.                 if (isset($this->options['highResolution']) && $this->options['highResolution'] > 1) {
  238.                     $thumbConfig->setHighResolution($this->options['highResolution']);
  239.                 }
  241.                 // autogenerate a name for the thumbnail because it's different from the original
  242.                 if ($autoName) {
  243.                     $hash = md5(Serialize::serialize($thumbConfig->getItems()));
  244.                     $thumbConfig->setName($thumbConfig->getName() . '_auto_' . $hash);
  245.                 }
  247.                 $deferred = true;
  248.                 if (isset($this->options['deferred'])) {
  249.                     $deferred = $this->options['deferred'];
  250.                 }
  252.                 $thumbnail = $image->getThumbnail($thumbConfig, $deferred);
  253.             } else {
  254.                 // we're using the thumbnail class only to generate the HTML
  255.                 $thumbnail = $image->getThumbnail();
  256.             }
  258.             $attributes = array_merge($this->options, [
  259.                 'alt' => $this->alt,
  260.                 'title' => $this->alt
  261.             ]);
  263.             $removeAttributes = [];
  264.             if (isset($this->options['removeAttributes']) && is_array($this->options['removeAttributes'])) {
  265.                 $removeAttributes = $this->options['removeAttributes'];
  266.             }
  268.             // thumbnail's HTML is always generated by the thumbnail itself
  269.             return $thumbnail->getHtml($attributes, $removeAttributes);
  270.         }
  271.     }
  273.     /**
  274.      * @param mixed $data
  275.      *
  276.      * @return $this
  277.      */
  278.     public function setDataFromResource($data)
  279.     {
  280.         if (strlen($data) > 2) {
  281.             $data = Serialize::unserialize($data);
  282.         }
  284.         $rewritePath = function ($data) {
  285.             if (!is_array($data)) {
  286.                 return [];
  287.             }
  289.             foreach ($data as &$element) {
  290.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  291.                     foreach ($element['data'] as &$metaData) {
  292.                         // this is for backward compatibility (Array vs. MarkerHotspotItem)
  293.                         if (is_array($metaData)) {
  294.                             $metaData = new Element\Data\MarkerHotspotItem($metaData);
  295.                         }
  296.                     }
  297.                 }
  298.             }
  300.             return $data;
  301.         };
  303.         if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  304.             $data['marker'] = $rewritePath($data['marker']);
  305.         }
  307.         if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  308.             $data['hotspots'] = $rewritePath($data['hotspots']);
  309.         }
  311.         $this->id = $data['id'] ?? null;
  312.         $this->alt = $data['alt'] ?? null;
  313.         $this->cropPercent = $data['cropPercent'] ?? null;
  314.         $this->cropWidth = $data['cropWidth'] ?? null;
  315.         $this->cropHeight = $data['cropHeight'] ?? null;
  316.         $this->cropTop = $data['cropTop'] ?? null;
  317.         $this->cropLeft = $data['cropLeft'] ?? null;
  318.         $this->marker = $data['marker'] ?? null;
  319.         $this->hotspots = $data['hotspots'] ?? null;
  321.         return $this;
  322.     }
  324.     /**
  325.      * @param mixed $data
  326.      *
  327.      * @return $this
  328.      */
  329.     public function setDataFromEditmode($data)
  330.     {
  331.         $rewritePath = function ($data) {
  332.             if (!is_array($data)) {
  333.                 return [];
  334.             }
  336.             foreach ($data as &$element) {
  337.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  338.                     foreach ($element['data'] as &$metaData) {
  339.                         $metaData = new Element\Data\MarkerHotspotItem($metaData);
  340.                         if (in_array($metaData['type'], ['object', 'asset', 'document'])) {
  341.                             $el = Element\Service::getElementByPath($metaData['type'], $metaData->getValue());
  342.                             $metaData['value'] = $el;
  343.                         }
  344.                     }
  345.                 }
  346.             }
  348.             return $data;
  349.         };
  351.         if (is_array($data)) {
  352.             if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  353.                 $data['marker'] = $rewritePath($data['marker']);
  354.             }
  356.             if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  357.                 $data['hotspots'] = $rewritePath($data['hotspots']);
  358.             }
  360.             $this->id = $data['id'] ?? null;
  361.             $this->alt = $data['alt'] ?? null;
  362.             $this->cropPercent = $data['cropPercent'] ?? null;
  363.             $this->cropWidth = $data['cropWidth'] ?? null;
  364.             $this->cropHeight = $data['cropHeight'] ?? null;
  365.             $this->cropTop = $data['cropTop'] ?? null;
  366.             $this->cropLeft = $data['cropLeft'] ?? null;
  367.             $this->marker = $data['marker'] ?? null;
  368.             $this->hotspots = $data['hotspots'] ?? null;
  369.         }
  371.         return $this;
  372.     }
  374.     /**
  375.      * @return string
  376.      */
  377.     public function getText()
  378.     {
  379.         return $this->alt;
  380.     }
  382.     /**
  383.      * @param string $text
  384.      */
  385.     public function setText($text)
  386.     {
  387.         $this->alt = $text;
  388.     }
  390.     /**
  391.      * @return string
  392.      */
  393.     public function getAlt()
  394.     {
  395.         return $this->getText();
  396.     }
  398.     /**
  399.      * @return string
  400.      */
  401.     public function getSrc()
  402.     {
  403.         $image = $this->getImage();
  404.         if ($image instanceof Asset) {
  405.             return $image->getFullPath();
  406.         }
  408.         return '';
  409.     }
  411.     /**
  412.      * @return Asset\Image
  413.      */
  414.     public function getImage()
  415.     {
  416.         if (!$this->image) {
  417.             $this->image = Asset\Image::getById($this->getId());
  418.         }
  420.         return $this->image;
  421.     }
  423.     /**
  424.      * @param Asset\Image $image
  425.      *
  426.      * @return Model\Document\Tag\Image
  427.      */
  428.     public function setImage($image)
  429.     {
  430.         $this->image = $image;
  432.         if ($image instanceof Asset) {
  433.             $this->setId($image->getId());
  434.         }
  436.         return $this;
  437.     }
  439.     /**
  440.      * @param int $id
  441.      *
  442.      * @return Model\Document\Tag\Image
  443.      */
  444.     public function setId($id)
  445.     {
  446.         $this->id = $id;
  448.         return $this;
  449.     }
  451.     /**
  452.      * @return int
  453.      */
  454.     public function getId()
  455.     {
  456.         return (int) $this->id;
  457.     }
  459.     /**
  460.      * @param string|array|Asset\Image\Thumbnail\Config $conf
  461.      * @param bool $deferred
  462.      *
  463.      * @return Asset\Image\Thumbnail|string
  464.      */
  465.     public function getThumbnail($conf, $deferred = true)
  466.     {
  467.         $image = $this->getImage();
  468.         if ($image instanceof Asset) {
  469.             $thumbConfig = $image->getThumbnailConfig($conf);
  470.             if ($thumbConfig && $this->cropPercent) {
  471.                 $this->applyCustomCropping($thumbConfig);
  472.                 $hash = md5(Serialize::serialize($thumbConfig->getItems()));
  473.                 $thumbConfig->setName($thumbConfig->getName() . '_auto_' . $hash);
  474.             }
  476.             return $image->getThumbnail($thumbConfig, $deferred);
  477.         }
  479.         return '';
  480.     }
  482.     /**
  483.      * @param Asset\Image\Thumbnail\Config $thumbConfig
  484.      */
  485.     protected function applyCustomCropping($thumbConfig)
  486.     {
  487.         $cropConfig = [
  488.             'width' => $this->cropWidth,
  489.             'height' => $this->cropHeight,
  490.             'y' => $this->cropTop,
  491.             'x' => $this->cropLeft
  492.         ];
  494.         $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig);
  496.         // also crop media query specific configs
  497.         if ($thumbConfig->hasMedias()) {
  498.             foreach ($thumbConfig->getMedias() as $mediaName => $mediaItems) {
  499.                 $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig, $mediaName);
  500.             }
  501.         }
  502.     }
  504.     /**
  505.      * @return bool
  506.      */
  507.     public function isEmpty()
  508.     {
  509.         $image = $this->getImage();
  510.         if ($image instanceof Asset\Image) {
  511.             return false;
  512.         }
  514.         return true;
  515.     }
  517.     /**
  518.      * @param Model\Document\PageSnippet $ownerDocument
  519.      * @param array $tags
  520.      *
  521.      * @return array|mixed
  522.      *
  523.      * @internal param array $blockedTags
  524.      */
  525.     public function getCacheTags($ownerDocument, $tags = [])
  526.     {
  527.         $tags = is_array($tags) ? $tags : [];
  529.         $image = $this->getImage();
  531.         if ($image instanceof Asset) {
  532.             if (!array_key_exists($image->getCacheTag(), $tags)) {
  533.                 $tags = $image->getCacheTags($tags);
  534.             }
  535.         }
  537.         $getMetaDataCacheTags = function ($data, $tags) {
  538.             if (!is_array($data)) {
  539.                 return $tags;
  540.             }
  542.             foreach ($data as $element) {
  543.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  544.                     foreach ($element['data'] as $metaData) {
  545.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  546.                             if (!array_key_exists($metaData['value']->getCacheTag(), $tags)) {
  547.                                 $tags = $metaData['value']->getCacheTags($tags);
  548.                             }
  549.                         }
  550.                     }
  551.                 }
  552.             }
  554.             return $tags;
  555.         };
  557.         $tags = $getMetaDataCacheTags($this->marker, $tags);
  558.         $tags = $getMetaDataCacheTags($this->hotspots, $tags);
  560.         return $tags;
  561.     }
  563.     /**
  564.      * @return array
  565.      */
  566.     public function resolveDependencies()
  567.     {
  568.         $dependencies = [];
  569.         $image = $this->getImage();
  571.         if ($image instanceof Asset\Image) {
  572.             $key = 'asset_' . $image->getId();
  574.             $dependencies[$key] = [
  575.                 'id' => $image->getId(),
  576.                 'type' => 'asset'
  577.             ];
  578.         }
  580.         $getMetaDataDependencies = function ($data, $dependencies) {
  581.             if (!is_array($data)) {
  582.                 return $dependencies;
  583.             }
  585.             foreach ($data as $element) {
  586.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  587.                     foreach ($element['data'] as $metaData) {
  588.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  589.                             $dependencies[$metaData['type'] . '_' . $metaData['value']->getId()] = [
  590.                                 'id' => $metaData['value']->getId(),
  591.                                 'type' => $metaData['type']
  592.                             ];
  593.                         }
  594.                     }
  595.                 }
  596.             }
  598.             return $dependencies;
  599.         };
  601.         $dependencies = $getMetaDataDependencies($this->marker, $dependencies);
  602.         $dependencies = $getMetaDataDependencies($this->hotspots, $dependencies);
  604.         return $dependencies;
  605.     }
  607.     /**
  608.      * @deprecated
  609.      *
  610.      * @param Model\Webservice\Data\Document\Element $wsElement
  611.      * @param Model\Document\PageSnippet $document
  612.      * @param array $params
  613.      * @param Model\Webservice\IdMapperInterface|null $idMapper
  614.      *
  615.      * @throws \Exception
  616.      */
  617.     public function getFromWebserviceImport($wsElement, $document = null, $params = [], $idMapper = null)
  618.     {
  619.         $data = $this->sanitizeWebserviceData($wsElement->value);
  620.         if ($data->id !== null) {
  621.             $this->alt = $data->alt;
  622.             $this->id = $data->id;
  624.             if ($idMapper) {
  625.                 $this->id = $idMapper->getMappedId('asset', $data->id);
  626.             }
  628.             if (is_numeric($this->id)) {
  629.                 $image = $this->getImage();
  630.                 if (!$image instanceof Asset\Image) {
  631.                     if ($idMapper && $idMapper->ignoreMappingFailures()) {
  632.                         $idMapper->recordMappingFailure('document', $this->getDocumentId(), 'asset', $data->id);
  633.                     } else {
  634.                         throw new \Exception('cannot get values from web service import - referenced image with id [ ' . $this->id . ' ] is unknown');
  635.                     }
  636.                 }
  637.             } else {
  638.                 if ($idMapper && $idMapper->ignoreMappingFailures()) {
  639.                     $idMapper->recordMappingFailure('document', $this->getDocumentId(), 'asset', $data->id);
  640.                 } else {
  641.                     throw new \Exception('cannot get values from web service import - id is not valid');
  642.                 }
  643.             }
  644.         }
  645.     }
  647.     /**
  648.      * @param float $cropHeight
  649.      *
  650.      * @return $this
  651.      */
  652.     public function setCropHeight($cropHeight)
  653.     {
  654.         $this->cropHeight = $cropHeight;
  656.         return $this;
  657.     }
  659.     /**
  660.      * @return float
  661.      */
  662.     public function getCropHeight()
  663.     {
  664.         return $this->cropHeight;
  665.     }
  667.     /**
  668.      * @param float $cropLeft
  669.      *
  670.      * @return $this
  671.      */
  672.     public function setCropLeft($cropLeft)
  673.     {
  674.         $this->cropLeft = $cropLeft;
  676.         return $this;
  677.     }
  679.     /**
  680.      * @return float
  681.      */
  682.     public function getCropLeft()
  683.     {
  684.         return $this->cropLeft;
  685.     }
  687.     /**
  688.      * @param bool $cropPercent
  689.      *
  690.      * @return $this
  691.      */
  692.     public function setCropPercent($cropPercent)
  693.     {
  694.         $this->cropPercent = $cropPercent;
  696.         return $this;
  697.     }
  699.     /**
  700.      * @return bool
  701.      */
  702.     public function getCropPercent()
  703.     {
  704.         return $this->cropPercent;
  705.     }
  707.     /**
  708.      * @param float $cropTop
  709.      *
  710.      * @return $this
  711.      */
  712.     public function setCropTop($cropTop)
  713.     {
  714.         $this->cropTop = $cropTop;
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return float
  721.      */
  722.     public function getCropTop()
  723.     {
  724.         return $this->cropTop;
  725.     }
  727.     /**
  728.      * @param float $cropWidth
  729.      *
  730.      * @return $this
  731.      */
  732.     public function setCropWidth($cropWidth)
  733.     {
  734.         $this->cropWidth = $cropWidth;
  736.         return $this;
  737.     }
  739.     /**
  740.      * @return float
  741.      */
  742.     public function getCropWidth()
  743.     {
  744.         return $this->cropWidth;
  745.     }
  747.     /**
  748.      * @param array $hotspots
  749.      */
  750.     public function setHotspots($hotspots)
  751.     {
  752.         $this->hotspots = $hotspots;
  753.     }
  755.     /**
  756.      * @return array
  757.      */
  758.     public function getHotspots()
  759.     {
  760.         return $this->hotspots;
  761.     }
  763.     /**
  764.      * @param array $marker
  765.      */
  766.     public function setMarker($marker)
  767.     {
  768.         $this->marker = $marker;
  769.     }
  771.     /**
  772.      * @return array
  773.      */
  774.     public function getMarker()
  775.     {
  776.         return $this->marker;
  777.     }
  779.     /**
  780.      * Rewrites id from source to target, $idMapping contains
  781.      * array(
  782.      *  "document" => array(
  783.      *      SOURCE_ID => TARGET_ID,
  784.      *      SOURCE_ID => TARGET_ID
  785.      *  ),
  786.      *  "object" => array(...),
  787.      *  "asset" => array(...)
  788.      * )
  789.      *
  790.      * @param array $idMapping
  791.      */
  792.     public function rewriteIds($idMapping)
  793.     {
  794.         if (array_key_exists('asset', $idMapping) and array_key_exists($this->getId(), $idMapping['asset'])) {
  795.             $this->setId($idMapping['asset'][$this->getId()]);
  797.             // reset marker & hotspot information
  798.             $this->setHotspots([]);
  799.             $this->setMarker([]);
  800.             $this->setCropPercent(false);
  801.             $this->setImage(null);
  802.         }
  803.     }
  805.     public function __sleep()
  806.     {
  807.         $finalVars = [];
  808.         $parentVars = parent::__sleep();
  810.         $blockedVars = ['image'];
  812.         foreach ($parentVars as $key) {
  813.             if (!in_array($key, $blockedVars)) {
  814.                 $finalVars[] = $key;
  815.             }
  816.         }
  818.         return $finalVars;
  819.     }
  820. }