vendor/pimcore/pimcore/models/Document/Editable/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\Editable;
  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\Editable\Dao getDao()
  27.  */
  28. class Image extends Model\Document\Editable
  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|null
  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 EditableInterface::getType
  88.      *
  89.      * @return string
  90.      */
  91.     public function getType()
  92.     {
  93.         return 'image';
  94.     }
  96.     /**
  97.      * @see EditableInterface::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|null
  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->getConfig()['predefinedDataTemplates'] ?? null,
  180.             ];
  181.         }
  183.         return null;
  184.     }
  186.     /**
  187.      * @return array
  188.      */
  189.     public function getConfig()
  190.     {
  191.         $config = parent::getConfig();
  192.         if (isset($config['thumbnail']) && !isset($config['focal_point_context_menu_item'])) {
  193.             $thumbConfig = Asset\Image\Thumbnail\Config::getByAutoDetect($config['thumbnail']);
  194.             if ($thumbConfig) {
  195.                 foreach ($thumbConfig->getItems() as $item) {
  196.                     if ($item['method'] == 'cover') {
  197.                         $config['focal_point_context_menu_item'] = true;
  198.                         $this->config['focal_point_context_menu_item'] = true;
  199.                         break;
  200.                     }
  201.                 }
  202.             }
  203.         }
  205.         return $config;
  206.     }
  208.     /**
  209.      * @see EditableInterface::frontend
  210.      *
  211.      * @return string
  212.      */
  213.     public function frontend()
  214.     {
  215.         if (!is_array($this->config)) {
  216.             $this->config = [];
  217.         }
  219.         $image = $this->getImage();
  221.         if ($image instanceof Asset) {
  222.             $thumbnailName = $this->config['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->config['highResolution']) && $this->config['highResolution'] > 1) {
  238.                     $thumbConfig->setHighResolution($this->config['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->config['deferred'])) {
  249.                     $deferred = $this->config['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->config, [
  259.                 'alt' => $this->alt,
  260.                 'title' => $this->alt,
  261.             ]);
  263.             $removeAttributes = [];
  264.             if (isset($this->config['removeAttributes']) && is_array($this->config['removeAttributes'])) {
  265.                 $removeAttributes = $this->config['removeAttributes'];
  266.             }
  268.             // thumbnail's HTML is always generated by the thumbnail itself
  269.             return $thumbnail->getHtml($attributes, $removeAttributes);
  270.         }
  272.         return '';
  273.     }
  275.     /**
  276.      * @param mixed $data
  277.      *
  278.      * @return $this
  279.      */
  280.     public function setDataFromResource($data)
  281.     {
  282.         if (strlen($data) > 2) {
  283.             $data = Serialize::unserialize($data);
  284.         }
  286.         $rewritePath = function ($data) {
  287.             if (!is_array($data)) {
  288.                 return [];
  289.             }
  291.             foreach ($data as &$element) {
  292.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  293.                     foreach ($element['data'] as &$metaData) {
  294.                         // this is for backward compatibility (Array vs. MarkerHotspotItem)
  295.                         if (is_array($metaData)) {
  296.                             $metaData = new Element\Data\MarkerHotspotItem($metaData);
  297.                         }
  298.                     }
  299.                 }
  300.             }
  302.             return $data;
  303.         };
  305.         if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  306.             $data['marker'] = $rewritePath($data['marker']);
  307.         }
  309.         if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  310.             $data['hotspots'] = $rewritePath($data['hotspots']);
  311.         }
  313.         $this->id = $data['id'] ?? null;
  314.         $this->alt = $data['alt'] ?? null;
  315.         $this->cropPercent = $data['cropPercent'] ?? null;
  316.         $this->cropWidth = $data['cropWidth'] ?? null;
  317.         $this->cropHeight = $data['cropHeight'] ?? null;
  318.         $this->cropTop = $data['cropTop'] ?? null;
  319.         $this->cropLeft = $data['cropLeft'] ?? null;
  320.         $this->marker = $data['marker'] ?? null;
  321.         $this->hotspots = $data['hotspots'] ?? null;
  323.         return $this;
  324.     }
  326.     /**
  327.      * @param mixed $data
  328.      *
  329.      * @return $this
  330.      */
  331.     public function setDataFromEditmode($data)
  332.     {
  333.         $rewritePath = function ($data) {
  334.             if (!is_array($data)) {
  335.                 return [];
  336.             }
  338.             foreach ($data as &$element) {
  339.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  340.                     foreach ($element['data'] as &$metaData) {
  341.                         $metaData = new Element\Data\MarkerHotspotItem($metaData);
  342.                         if (in_array($metaData['type'], ['object', 'asset', 'document'])) {
  343.                             $el = Element\Service::getElementByPath($metaData['type'], $metaData->getValue());
  344.                             $metaData['value'] = $el;
  345.                         }
  346.                     }
  347.                 }
  348.             }
  350.             return $data;
  351.         };
  353.         if (is_array($data)) {
  354.             if (array_key_exists('marker', $data) && is_array($data['marker']) && count($data['marker']) > 0) {
  355.                 $data['marker'] = $rewritePath($data['marker']);
  356.             }
  358.             if (array_key_exists('hotspots', $data) && is_array($data['hotspots']) && count($data['hotspots']) > 0) {
  359.                 $data['hotspots'] = $rewritePath($data['hotspots']);
  360.             }
  362.             $this->id = $data['id'] ?? null;
  363.             $this->alt = $data['alt'] ?? null;
  364.             $this->cropPercent = $data['cropPercent'] ?? null;
  365.             $this->cropWidth = $data['cropWidth'] ?? null;
  366.             $this->cropHeight = $data['cropHeight'] ?? null;
  367.             $this->cropTop = $data['cropTop'] ?? null;
  368.             $this->cropLeft = $data['cropLeft'] ?? null;
  369.             $this->marker = $data['marker'] ?? null;
  370.             $this->hotspots = $data['hotspots'] ?? null;
  371.         }
  373.         return $this;
  374.     }
  376.     /**
  377.      * @return string
  378.      */
  379.     public function getText()
  380.     {
  381.         return $this->alt;
  382.     }
  384.     /**
  385.      * @param string $text
  386.      */
  387.     public function setText($text)
  388.     {
  389.         $this->alt = $text;
  390.     }
  392.     /**
  393.      * @return string
  394.      */
  395.     public function getAlt()
  396.     {
  397.         return $this->getText();
  398.     }
  400.     /**
  401.      * @return string
  402.      */
  403.     public function getSrc()
  404.     {
  405.         $image = $this->getImage();
  406.         if ($image instanceof Asset) {
  407.             return $image->getFullPath();
  408.         }
  410.         return '';
  411.     }
  413.     /**
  414.      * @return Asset\Image|null
  415.      */
  416.     public function getImage()
  417.     {
  418.         if (!$this->image) {
  419.             $this->image = Asset\Image::getById($this->getId());
  420.         }
  422.         return $this->image;
  423.     }
  425.     /**
  426.      * @param Asset\Image|null $image
  427.      *
  428.      * @return Model\Document\Editable\Image
  429.      */
  430.     public function setImage($image)
  431.     {
  432.         $this->image = $image;
  434.         if ($image instanceof Asset) {
  435.             $this->setId($image->getId());
  436.         }
  438.         return $this;
  439.     }
  441.     /**
  442.      * @param int $id
  443.      *
  444.      * @return Model\Document\Editable\Image
  445.      */
  446.     public function setId($id)
  447.     {
  448.         $this->id = $id;
  450.         return $this;
  451.     }
  453.     /**
  454.      * @return int
  455.      */
  456.     public function getId()
  457.     {
  458.         return (int) $this->id;
  459.     }
  461.     /**
  462.      * @param string|array|Asset\Image\Thumbnail\Config $conf
  463.      * @param bool $deferred
  464.      *
  465.      * @return Asset\Image\Thumbnail|string
  466.      */
  467.     public function getThumbnail($conf, $deferred = true)
  468.     {
  469.         $image = $this->getImage();
  470.         if ($image instanceof Asset) {
  471.             $thumbConfig = $image->getThumbnailConfig($conf);
  472.             if ($thumbConfig && $this->cropPercent) {
  473.                 $this->applyCustomCropping($thumbConfig);
  474.                 $hash = md5(Serialize::serialize($thumbConfig->getItems()));
  475.                 $thumbConfig->setName($thumbConfig->getName() . '_auto_' . $hash);
  476.             }
  478.             return $image->getThumbnail($thumbConfig, $deferred);
  479.         }
  481.         return '';
  482.     }
  484.     /**
  485.      * @param Asset\Image\Thumbnail\Config $thumbConfig
  486.      */
  487.     protected function applyCustomCropping($thumbConfig)
  488.     {
  489.         $cropConfig = [
  490.             'width' => $this->cropWidth,
  491.             'height' => $this->cropHeight,
  492.             'y' => $this->cropTop,
  493.             'x' => $this->cropLeft,
  494.         ];
  496.         $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig);
  498.         // also crop media query specific configs
  499.         if ($thumbConfig->hasMedias()) {
  500.             foreach ($thumbConfig->getMedias() as $mediaName => $mediaItems) {
  501.                 $thumbConfig->addItemAt(0, 'cropPercent', $cropConfig, $mediaName);
  502.             }
  503.         }
  504.     }
  506.     /**
  507.      * @return bool
  508.      */
  509.     public function isEmpty()
  510.     {
  511.         $image = $this->getImage();
  512.         if ($image instanceof Asset\Image) {
  513.             return false;
  514.         }
  516.         return true;
  517.     }
  519.     /**
  520.      * @param Model\Document\PageSnippet $ownerDocument
  521.      * @param array $tags
  522.      *
  523.      * @return array|mixed
  524.      *
  525.      * @internal param array $blockedTags
  526.      */
  527.     public function getCacheTags($ownerDocument, $tags = [])
  528.     {
  529.         $tags = is_array($tags) ? $tags : [];
  531.         $image = $this->getImage();
  533.         if ($image instanceof Asset) {
  534.             if (!array_key_exists($image->getCacheTag(), $tags)) {
  535.                 $tags = $image->getCacheTags($tags);
  536.             }
  537.         }
  539.         $getMetaDataCacheTags = function ($data, $tags) {
  540.             if (!is_array($data)) {
  541.                 return $tags;
  542.             }
  544.             foreach ($data as $element) {
  545.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  546.                     foreach ($element['data'] as $metaData) {
  547.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  548.                             if (!array_key_exists($metaData['value']->getCacheTag(), $tags)) {
  549.                                 $tags = $metaData['value']->getCacheTags($tags);
  550.                             }
  551.                         }
  552.                     }
  553.                 }
  554.             }
  556.             return $tags;
  557.         };
  559.         $tags = $getMetaDataCacheTags($this->marker, $tags);
  560.         $tags = $getMetaDataCacheTags($this->hotspots, $tags);
  562.         return $tags;
  563.     }
  565.     /**
  566.      * @return array
  567.      */
  568.     public function resolveDependencies()
  569.     {
  570.         $dependencies = [];
  571.         $image = $this->getImage();
  573.         if ($image instanceof Asset\Image) {
  574.             $key = 'asset_' . $image->getId();
  576.             $dependencies[$key] = [
  577.                 'id' => $image->getId(),
  578.                 'type' => 'asset',
  579.             ];
  580.         }
  582.         $getMetaDataDependencies = function ($data, $dependencies) {
  583.             if (!is_array($data)) {
  584.                 return $dependencies;
  585.             }
  587.             foreach ($data as $element) {
  588.                 if (array_key_exists('data', $element) && is_array($element['data']) && count($element['data']) > 0) {
  589.                     foreach ($element['data'] as $metaData) {
  590.                         if ($metaData['value'] instanceof Element\ElementInterface) {
  591.                             $dependencies[$metaData['type'] . '_' . $metaData['value']->getId()] = [
  592.                                 'id' => $metaData['value']->getId(),
  593.                                 'type' => $metaData['type'],
  594.                             ];
  595.                         }
  596.                     }
  597.                 }
  598.             }
  600.             return $dependencies;
  601.         };
  603.         $dependencies = $getMetaDataDependencies($this->marker, $dependencies);
  604.         $dependencies = $getMetaDataDependencies($this->hotspots, $dependencies);
  606.         return $dependencies;
  607.     }
  609.     /**
  610.      * @deprecated
  611.      *
  612.      * @param Model\Webservice\Data\Document\Element $wsElement
  613.      * @param Model\Document\PageSnippet $document
  614.      * @param array $params
  615.      * @param Model\Webservice\IdMapperInterface|null $idMapper
  616.      *
  617.      * @throws \Exception
  618.      */
  619.     public function getFromWebserviceImport($wsElement, $document = null, $params = [], $idMapper = null)
  620.     {
  621.         $data = $this->sanitizeWebserviceData($wsElement->value);
  622.         if ($data->id !== null) {
  623.             $this->alt = $data->alt;
  624.             $this->id = $data->id;
  626.             if ($idMapper) {
  627.                 $this->id = $idMapper->getMappedId('asset', $data->id);
  628.             }
  630.             if (is_numeric($this->id)) {
  631.                 $image = $this->getImage();
  632.                 if (!$image instanceof Asset\Image) {
  633.                     if ($idMapper && $idMapper->ignoreMappingFailures()) {
  634.                         $idMapper->recordMappingFailure('document', $this->getDocumentId(), 'asset', $data->id);
  635.                     } else {
  636.                         throw new \Exception('cannot get values from web service import - referenced image with id [ ' . $this->id . ' ] is unknown');
  637.                     }
  638.                 }
  639.             } else {
  640.                 if ($idMapper && $idMapper->ignoreMappingFailures()) {
  641.                     $idMapper->recordMappingFailure('document', $this->getDocumentId(), 'asset', $data->id);
  642.                 } else {
  643.                     throw new \Exception('cannot get values from web service import - id is not valid');
  644.                 }
  645.             }
  646.         }
  647.     }
  649.     /**
  650.      * @param float $cropHeight
  651.      *
  652.      * @return $this
  653.      */
  654.     public function setCropHeight($cropHeight)
  655.     {
  656.         $this->cropHeight = $cropHeight;
  658.         return $this;
  659.     }
  661.     /**
  662.      * @return float
  663.      */
  664.     public function getCropHeight()
  665.     {
  666.         return $this->cropHeight;
  667.     }
  669.     /**
  670.      * @param float $cropLeft
  671.      *
  672.      * @return $this
  673.      */
  674.     public function setCropLeft($cropLeft)
  675.     {
  676.         $this->cropLeft = $cropLeft;
  678.         return $this;
  679.     }
  681.     /**
  682.      * @return float
  683.      */
  684.     public function getCropLeft()
  685.     {
  686.         return $this->cropLeft;
  687.     }
  689.     /**
  690.      * @param bool $cropPercent
  691.      *
  692.      * @return $this
  693.      */
  694.     public function setCropPercent($cropPercent)
  695.     {
  696.         $this->cropPercent = $cropPercent;
  698.         return $this;
  699.     }
  701.     /**
  702.      * @return bool
  703.      */
  704.     public function getCropPercent()
  705.     {
  706.         return $this->cropPercent;
  707.     }
  709.     /**
  710.      * @param float $cropTop
  711.      *
  712.      * @return $this
  713.      */
  714.     public function setCropTop($cropTop)
  715.     {
  716.         $this->cropTop = $cropTop;
  718.         return $this;
  719.     }
  721.     /**
  722.      * @return float
  723.      */
  724.     public function getCropTop()
  725.     {
  726.         return $this->cropTop;
  727.     }
  729.     /**
  730.      * @param float $cropWidth
  731.      *
  732.      * @return $this
  733.      */
  734.     public function setCropWidth($cropWidth)
  735.     {
  736.         $this->cropWidth = $cropWidth;
  738.         return $this;
  739.     }
  741.     /**
  742.      * @return float
  743.      */
  744.     public function getCropWidth()
  745.     {
  746.         return $this->cropWidth;
  747.     }
  749.     /**
  750.      * @param array $hotspots
  751.      */
  752.     public function setHotspots($hotspots)
  753.     {
  754.         $this->hotspots = $hotspots;
  755.     }
  757.     /**
  758.      * @return array
  759.      */
  760.     public function getHotspots()
  761.     {
  762.         return $this->hotspots;
  763.     }
  765.     /**
  766.      * @param array $marker
  767.      */
  768.     public function setMarker($marker)
  769.     {
  770.         $this->marker = $marker;
  771.     }
  773.     /**
  774.      * @return array
  775.      */
  776.     public function getMarker()
  777.     {
  778.         return $this->marker;
  779.     }
  781.     /**
  782.      * Rewrites id from source to target, $idMapping contains
  783.      * array(
  784.      *  "document" => array(
  785.      *      SOURCE_ID => TARGET_ID,
  786.      *      SOURCE_ID => TARGET_ID
  787.      *  ),
  788.      *  "object" => array(...),
  789.      *  "asset" => array(...)
  790.      * )
  791.      *
  792.      * @param array $idMapping
  793.      */
  794.     public function rewriteIds($idMapping)
  795.     {
  796.         if (array_key_exists('asset', $idMapping) and array_key_exists($this->getId(), $idMapping['asset'])) {
  797.             $this->setId($idMapping['asset'][$this->getId()]);
  799.             // reset marker & hotspot information
  800.             $this->setHotspots([]);
  801.             $this->setMarker([]);
  802.             $this->setCropPercent(false);
  803.             $this->setImage(null);
  804.         }
  805.     }
  807.     public function __sleep()
  808.     {
  809.         $finalVars = [];
  810.         $parentVars = parent::__sleep();
  812.         $blockedVars = ['image'];
  814.         foreach ($parentVars as $key) {
  815.             if (!in_array($key, $blockedVars)) {
  816.                 $finalVars[] = $key;
  817.             }
  818.         }
  820.         return $finalVars;
  821.     }
  822. }
  824. class_alias(Image::class, 'Pimcore\Model\Document\Tag\Image');