vendor/pimcore/pimcore/models/Asset.php line 231

Open in your IDE?
  1. <?php
  3. /**
  4.  * Pimcore
  5.  *
  6.  * This source file is available under two different licenses:
  7.  * - GNU General Public License version 3 (GPLv3)
  8.  * - Pimcore Commercial License (PCL)
  9.  * Full copyright and license information is available in
  10.  * LICENSE.md which is distributed with this source code.
  11.  *
  12.  *  @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  13.  *  @license    http://www.pimcore.org/license     GPLv3 and PCL
  14.  */
  16. namespace Pimcore\Model;
  18. use Doctrine\DBAL\Exception\DeadlockException;
  19. use Exception;
  20. use function is_array;
  21. use League\Flysystem\FilesystemException;
  22. use League\Flysystem\FilesystemOperator;
  23. use League\Flysystem\UnableToMoveFile;
  24. use Pimcore;
  25. use Pimcore\Cache;
  26. use Pimcore\Cache\RuntimeCache;
  27. use Pimcore\Config;
  28. use Pimcore\Event\AssetEvents;
  29. use Pimcore\Event\FrontendEvents;
  30. use Pimcore\Event\Model\AssetEvent;
  31. use Pimcore\File;
  32. use Pimcore\Helper\TemporaryFileHelperTrait;
  33. use Pimcore\Loader\ImplementationLoader\Exception\UnsupportedException;
  34. use Pimcore\Localization\LocaleServiceInterface;
  35. use Pimcore\Logger;
  36. use Pimcore\Messenger\AssetUpdateTasksMessage;
  37. use Pimcore\Messenger\VersionDeleteMessage;
  38. use Pimcore\Model\Asset\Dao;
  39. use Pimcore\Model\Asset\Folder;
  40. use Pimcore\Model\Asset\Listing;
  41. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\Data;
  42. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\DataDefinitionInterface;
  43. use Pimcore\Model\Element\DuplicateFullPathException;
  44. use Pimcore\Model\Element\ElementInterface;
  45. use Pimcore\Model\Element\Service;
  46. use Pimcore\Model\Element\Traits\ScheduledTasksTrait;
  47. use Pimcore\Model\Element\ValidationException;
  48. use Pimcore\Model\Exception\NotFoundException;
  49. use Pimcore\Tool;
  50. use Pimcore\Tool\Serialize;
  51. use Pimcore\Tool\Storage;
  52. use stdClass;
  53. use Symfony\Component\EventDispatcher\GenericEvent;
  54. use Symfony\Component\Mime\MimeTypes;
  56. /**
  57.  * @method Dao getDao()
  58.  * @method bool __isBasedOnLatestData()
  59.  * @method int getChildAmount($user = null)
  60.  * @method string|null getCurrentFullPath()
  61.  */
  62. class Asset extends Element\AbstractElement
  63. {
  64.     use ScheduledTasksTrait;
  65.     use TemporaryFileHelperTrait;
  67.     /**
  68.      * all possible types of assets
  69.      *
  70.      * @internal
  71.      *
  72.      * @var array
  73.      */
  74.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  76.     /**
  77.      * @internal
  78.      *
  79.      * @var string
  80.      */
  81.     protected $type = '';
  83.     /**
  84.      * @internal
  85.      *
  86.      * @var string|null
  87.      */
  88.     protected $filename;
  90.     /**
  91.      * @internal
  92.      *
  93.      * @var string|null
  94.      */
  95.     protected $mimetype;
  97.     /**
  98.      * @internal
  99.      *
  100.      * @var resource|null
  101.      */
  102.     protected $stream;
  104.     /**
  105.      * @internal
  106.      *
  107.      * @var array|null
  108.      */
  109.     protected $versions = null;
  111.     /**
  112.      * @internal
  113.      *
  114.      * @var array
  115.      */
  116.     protected $metadata = [];
  118.     /**
  119.      * List of some custom settings  [key] => value
  120.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  121.      *
  122.      * @internal
  123.      *
  124.      * @var array
  125.      */
  126.     protected $customSettings = [];
  128.     /**
  129.      * @internal
  130.      *
  131.      * @var bool
  132.      */
  133.     protected $hasMetaData = false;
  135.     /**
  136.      * @internal
  137.      *
  138.      * @var array|null
  139.      */
  140.     protected $siblings;
  142.     /**
  143.      * @internal
  144.      *
  145.      * @var bool|null
  146.      */
  147.     protected $hasSiblings;
  149.     /**
  150.      * @internal
  151.      *
  152.      * @var bool
  153.      */
  154.     protected $dataChanged = false;
  156.     /**
  157.      * {@inheritdoc}
  158.      */
  159.     protected function getBlockedVars(): array
  160.     {
  161.         $blockedVars = ['scheduledTasks', 'hasChildren', 'versions', 'parent', 'stream'];
  163.         if (!$this->isInDumpState()) {
  164.             // for caching asset
  165.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  166.         }
  168.         return $blockedVars;
  169.     }
  171.     /**
  172.      *
  173.      * @return array
  174.      */
  175.     public static function getTypes()
  176.     {
  177.         return self::$types;
  178.     }
  180.     /**
  181.      * Static helper to get an asset by the passed path
  182.      *
  183.      * @param string $path
  184.      * @param array|bool $force
  185.      *
  186.      * @return static|null
  187.      */
  188.     public static function getByPath($path, $force = false)
  189.     {
  190.         if (!$path) {
  191.             return null;
  192.         }
  194.         $path = Element\Service::correctPath($path);
  196.         try {
  197.             $asset = new static();
  198.             $asset->getDao()->getByPath($path);
  200.             return static::getById($asset->getId(), Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1));
  201.         } catch (NotFoundException $e) {
  202.             return null;
  203.         }
  204.     }
  206.     /**
  207.      * @internal
  208.      *
  209.      * @param Asset $asset
  210.      *
  211.      * @return bool
  212.      */
  213.     protected static function typeMatch(Asset $asset)
  214.     {
  215.         $staticType = static::class;
  216.         if ($staticType !== Asset::class) {
  217.             if (!$asset instanceof $staticType) {
  218.                 return false;
  219.             }
  220.         }
  222.         return true;
  223.     }
  225.     /**
  226.      * @param int $id
  227.      * @param array|bool $force
  228.      *
  229.      * @return static|null
  230.      */
  231.     public static function getById($id, $force = false)
  232.     {
  233.         if (!is_numeric($id) || $id < 1) {
  234.             return null;
  235.         }
  237.         $id = (int)$id;
  238.         $cacheKey = self::getCacheKey($id);
  240.         $params = Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  242.         if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  243.             $asset = RuntimeCache::get($cacheKey);
  244.             if ($asset && static::typeMatch($asset)) {
  245.                 return $asset;
  246.             }
  247.         }
  249.         if ($params['force'] || !($asset = Cache::load($cacheKey))) {
  250.             $asset = new static();
  252.             try {
  253.                 $asset->getDao()->getById($id);
  254.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  256.                 if (get_class($asset) !== $className) {
  257.                     /** @var Asset $asset */
  258.                     $asset = self::getModelFactory()->build($className);
  259.                     $asset->getDao()->getById($id);
  260.                 }
  262.                 RuntimeCache::set($cacheKey, $asset);
  263.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  265.                 $asset->resetDirtyMap();
  267.                 Cache::save($asset, $cacheKey);
  268.             } catch (NotFoundException $e) {
  269.                 return null;
  270.             }
  271.         } else {
  272.             RuntimeCache::set($cacheKey, $asset);
  273.         }
  275.         if (!$asset || !static::typeMatch($asset)) {
  276.             return null;
  277.         }
  279.         \Pimcore::getEventDispatcher()->dispatch(
  280.             new AssetEvent($asset, ['params' => $params]),
  281.             AssetEvents::POST_LOAD
  282.         );
  284.         return $asset;
  285.     }
  287.     /**
  288.      * @param int $parentId
  289.      * @param array $data
  290.      * @param bool $save
  291.      *
  292.      * @return Asset
  293.      */
  294.     public static function create($parentId, $data = [], $save = true)
  295.     {
  296.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  297.         // (tree) is generated immediately after creating an image
  298.         $class = Asset::class;
  299.         if (array_key_exists('filename', $data) && (array_key_exists('data', $data) || array_key_exists('sourcePath', $data) || array_key_exists('stream', $data))) {
  300.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  301.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($data['filename']);
  302.                 if (array_key_exists('data', $data)) {
  303.                     File::put($tmpFile, $data['data']);
  304.                     self::checkMaxPixels($tmpFile, $data);
  305.                     $mimeType = MimeTypes::getDefault()->guessMimeType($tmpFile);
  306.                     unlink($tmpFile);
  307.                 } else {
  308.                     $streamMeta = stream_get_meta_data($data['stream']);
  309.                     if (file_exists($streamMeta['uri'])) {
  310.                         // stream is a local file, so we don't have to write a tmp file
  311.                         self::checkMaxPixels($streamMeta['uri'], $data);
  312.                         $mimeType = MimeTypes::getDefault()->guessMimeType($streamMeta['uri']);
  313.                     } else {
  314.                         // write a tmp file because the stream isn't a pointer to the local filesystem
  315.                         $isRewindable = @rewind($data['stream']);
  316.                         $dest = fopen($tmpFile, 'w+', false, File::getContext());
  317.                         stream_copy_to_stream($data['stream'], $dest);
  318.                         self::checkMaxPixels($tmpFile, $data);
  319.                         $mimeType = MimeTypes::getDefault()->guessMimeType($tmpFile);
  321.                         if (!$isRewindable) {
  322.                             $data['stream'] = $dest;
  323.                         } else {
  324.                             fclose($dest);
  325.                             unlink($tmpFile);
  326.                         }
  327.                     }
  328.                 }
  329.             } else {
  330.                 if (is_dir($data['sourcePath'])) {
  331.                     $mimeType = 'directory';
  332.                 } else {
  333.                     self::checkMaxPixels($data['sourcePath'], $data);
  334.                     $mimeType = MimeTypes::getDefault()->guessMimeType($data['sourcePath']);
  335.                     if (is_file($data['sourcePath'])) {
  336.                         $data['stream'] = fopen($data['sourcePath'], 'rb', false, File::getContext());
  337.                     }
  338.                 }
  340.                 unset($data['sourcePath']);
  341.             }
  343.             $type = self::getTypeFromMimeMapping($mimeType, $data['filename']);
  344.             $class = '\\Pimcore\\Model\\Asset\\' . ucfirst($type);
  345.             if (array_key_exists('type', $data)) {
  346.                 unset($data['type']);
  347.             }
  348.         }
  350.         /** @var Asset $asset */
  351.         $asset = self::getModelFactory()->build($class);
  352.         $asset->setParentId($parentId);
  353.         self::checkCreateData($data);
  354.         $asset->setValues($data);
  356.         if ($save) {
  357.             $asset->save();
  358.         }
  360.         return $asset;
  361.     }
  363.     private static function checkMaxPixels(string $localPath, array $data): void
  364.     {
  365.         // this check is intentionally done in Asset::create() because in Asset::update() it would result
  366.         // in an additional download from remote storage if configured, so in terms of performance
  367.         // this is the more efficient way
  368.         $maxPixels = (int) Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['max_pixels'];
  369.         if ($size = @getimagesize($localPath)) {
  370.             $imagePixels = (int) ($size[0] * $size[1]);
  371.             if ($imagePixels > $maxPixels) {
  372.                 Logger::error("Image to be created {$localPath} (temp. path) exceeds max pixel size of {$maxPixels}, you can change the value in config pimcore.assets.image.max_pixels");
  374.                 $diff = sqrt(1 + ($maxPixels / $imagePixels));
  375.                 $suggestion_0 = (int) round($size[0] / $diff, -2, PHP_ROUND_HALF_DOWN);
  376.                 $suggestion_1 = (int) round($size[1] / $diff, -2, PHP_ROUND_HALF_DOWN);
  378.                 $mp = $maxPixels / 1_000_000;
  380.                 throw new ValidationException("<p>Image dimensions of <em>{$data['filename']}</em> are too large.</p>
  381. <p>Max size: <code>{$mp}</code> <abbr title='Million pixels'>Megapixels</abbr></p>
  382. <p>Suggestion: resize to <code>{$suggestion_0}&times;{$suggestion_1}</code> pixels or smaller.</p>");
  383.             }
  384.         }
  385.     }
  387.     /**
  388.      * @param array $config
  389.      *
  390.      * @return Listing
  391.      *
  392.      * @throws Exception
  393.      */
  394.     public static function getList($config = [])
  395.     {
  396.         if (!is_array($config)) {
  397.             throw new Exception('Unable to initiate list class - please provide valid configuration array');
  398.         }
  400.         $listClass = Listing::class;
  402.         /** @var Listing $list */
  403.         $list = self::getModelFactory()->build($listClass);
  404.         $list->setValues($config);
  406.         return $list;
  407.     }
  409.     /**
  410.      * @deprecated will be removed in Pimcore 11
  411.      *
  412.      * @param array $config
  413.      *
  414.      * @return int total count
  415.      */
  416.     public static function getTotalCount($config = [])
  417.     {
  418.         $list = static::getList($config);
  419.         $count = $list->getTotalCount();
  421.         return $count;
  422.     }
  424.     /**
  425.      * @internal
  426.      *
  427.      * @param string $mimeType
  428.      * @param string $filename
  429.      *
  430.      * @return string
  431.      */
  432.     public static function getTypeFromMimeMapping($mimeType, $filename)
  433.     {
  434.         if ($mimeType == 'directory') {
  435.             return 'folder';
  436.         }
  438.         $type = null;
  440.         $mappings = [
  441.             'unknown' => ["/\.stp$/"],
  442.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/", "/\.wmf$/", '/photoshop/'],
  443.             'text' => ['/text/', '/xml$/', '/\.json$/'],
  444.             'audio' => ['/audio/'],
  445.             'video' => ['/video/'],
  446.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  447.             'archive' => ['/zip/', '/tar/'],
  448.         ];
  450.         foreach ($mappings as $assetType => $patterns) {
  451.             foreach ($patterns as $pattern) {
  452.                 if (preg_match($pattern, $mimeType . ' .' . File::getFileExtension($filename))) {
  453.                     $type = $assetType;
  455.                     break;
  456.                 }
  457.             }
  459.             // break at first match
  460.             if ($type) {
  461.                 break;
  462.             }
  463.         }
  465.         if (!$type) {
  466.             $type = 'unknown';
  467.         }
  469.         return $type;
  470.     }
  472.     /**
  473.      * {@inheritdoc}
  474.      */
  475.     public function save()
  476.     {
  477.         // additional parameters (e.g. "versionNote" for the version note)
  478.         $params = [];
  479.         if (func_num_args() && is_array(func_get_arg(0))) {
  480.             $params = func_get_arg(0);
  481.         }
  483.         $isUpdate = false;
  484.         $differentOldPath = null;
  486.         try {
  487.             $preEvent = new AssetEvent($this, $params);
  489.             if ($this->getId()) {
  490.                 $isUpdate = true;
  491.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_UPDATE);
  492.             } else {
  493.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_ADD);
  494.             }
  496.             $params = $preEvent->getArguments();
  498.             $this->correctPath();
  500.             $params['isUpdate'] = $isUpdate; // we need that in $this->update() for certain types (image, video, document)
  502.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  503.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  504.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  505.             $maxRetries = 5;
  506.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  507.                 $this->beginTransaction();
  509.                 try {
  510.                     if (!$isUpdate) {
  511.                         $this->getDao()->create();
  512.                     }
  514.                     // get the old path from the database before the update is done
  515.                     $oldPath = null;
  516.                     if ($isUpdate) {
  517.                         $oldPath = $this->getDao()->getCurrentFullPath();
  518.                     }
  520.                     $this->update($params);
  522.                     $storage = Storage::get('asset');
  523.                     // if the old path is different from the new path, update all children
  524.                     $updatedChildren = [];
  525.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  526.                         $differentOldPath = $oldPath;
  528.                         try {
  529.                             $storage->move($oldPath, $this->getRealFullPath());
  530.                         } catch (UnableToMoveFile $e) {
  531.                             //update children, if unable to move parent
  532.                             $this->updateChildPaths($storage, $oldPath);
  533.                         }
  535.                         $this->getDao()->updateWorkspaces();
  537.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  538.                         $this->relocateThumbnails($oldPath);
  539.                     }
  541.                     // lastly create a new version if necessary
  542.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  543.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  544.                     if ($this->getType() != 'folder') {
  545.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  546.                     }
  548.                     $this->commit();
  550.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  551.                 } catch (Exception $e) {
  552.                     try {
  553.                         $this->rollBack();
  554.                     } catch (Exception $er) {
  555.                         // PDO adapter throws exceptions if rollback fails
  556.                         Logger::error((string) $er);
  557.                     }
  559.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  560.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  561.                         $run = $retries + 1;
  562.                         $waitTime = rand(1, 5) * 100000; // microseconds
  563.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  565.                         usleep($waitTime); // wait specified time until we restart the transaction
  566.                     } else {
  567.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  568.                         throw $e;
  569.                     }
  570.                 }
  571.             }
  573.             $additionalTags = [];
  574.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  575.                 foreach ($updatedChildren as $assetId) {
  576.                     $tag = 'asset_' . $assetId;
  577.                     $additionalTags[] = $tag;
  579.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  580.                     RuntimeCache::set($tag, null);
  581.                 }
  582.             }
  583.             $this->clearDependentCache($additionalTags);
  585.             if ($this->getDataChanged()) {
  586.                 if (in_array($this->getType(), ['image', 'video', 'document'])) {
  587.                     $this->addToUpdateTaskQueue();
  588.                 }
  589.             }
  591.             $this->setDataChanged(false);
  593.             $postEvent = new AssetEvent($this, $params);
  594.             if ($isUpdate) {
  595.                 if ($differentOldPath) {
  596.                     $postEvent->setArgument('oldPath', $differentOldPath);
  597.                 }
  598.                 $this->dispatchEvent($postEvent, AssetEvents::POST_UPDATE);
  599.             } else {
  600.                 $this->dispatchEvent($postEvent, AssetEvents::POST_ADD);
  601.             }
  603.             return $this;
  604.         } catch (Exception $e) {
  605.             $failureEvent = new AssetEvent($this, $params);
  606.             $failureEvent->setArgument('exception', $e);
  607.             if ($isUpdate) {
  608.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_UPDATE_FAILURE);
  609.             } else {
  610.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_ADD_FAILURE);
  611.             }
  613.             throw $e;
  614.         }
  615.     }
  617.     /**
  618.      * @internal
  619.      *
  620.      * @throws Exception|DuplicateFullPathException
  621.      */
  622.     public function correctPath()
  623.     {
  624.         // set path
  625.         if ($this->getId() != 1) { // not for the root node
  626.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  627.                 throw new Exception("invalid filename '" . $this->getKey() . "' for asset with id [ " . $this->getId() . ' ]');
  628.             }
  630.             if ($this->getParentId() == $this->getId()) {
  631.                 throw new Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  632.             }
  634.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  635.                 throw new Exception('Cannot create asset called ".." or "."');
  636.             }
  638.             $parent = Asset::getById($this->getParentId());
  639.             if ($parent) {
  640.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  641.                 // that is currently in the parent asset (in memory), because this might have changed but wasn't not saved
  642.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  643.             } else {
  644.                 trigger_deprecation(
  645.                     'pimcore/pimcore',
  646.                     '10.5',
  647.                     'Fallback for parentId will be removed in Pimcore 11.',
  648.                 );
  649.                 // parent document doesn't exist anymore, set the parent to to root
  650.                 $this->setParentId(1);
  651.                 $this->setPath('/');
  652.             }
  653.         } elseif ($this->getId() == 1) {
  654.             // some data in root node should always be the same
  655.             $this->setParentId(0);
  656.             $this->setPath('/');
  657.             $this->setFilename('');
  658.             $this->setType('folder');
  659.         }
  661.         // do not allow PHP and .htaccess files
  662.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  663.             $this->setFilename($this->getFilename() . '.txt');
  664.         }
  666.         if (mb_strlen($this->getFilename()) > 255) {
  667.             throw new Exception('Filenames longer than 255 characters are not allowed');
  668.         }
  670.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  671.             $duplicate = Asset::getByPath($this->getRealFullPath());
  672.             if ($duplicate instanceof Asset && $duplicate->getId() != $this->getId()) {
  673.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  674.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  676.                 throw $duplicateFullPathException;
  677.             }
  678.         }
  680.         $this->validatePathLength();
  681.     }
  683.     /**
  684.      * @internal
  685.      *
  686.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  687.      *
  688.      * @throws Exception
  689.      */
  690.     protected function update($params = [])
  691.     {
  692.         $storage = Storage::get('asset');
  693.         $this->updateModificationInfos();
  695.         $path = $this->getRealFullPath();
  696.         $typeChanged = false;
  698.         if ($this->getType() != 'folder') {
  699.             if ($this->getDataChanged()) {
  700.                 $src = $this->getStream();
  702.                 if (!$storage->fileExists($path) || !stream_is_local($storage->readStream($path))) {
  703.                     // write stream directly if target file doesn't exist or if target is a remote storage
  704.                     // this is because we don't have hardlinks there, so we don't need to consider them (see below)
  705.                     $storage->writeStream($path, $src);
  706.                 } else {
  707.                     // We don't open a stream on existing files, because they could be possibly used by versions
  708.                     // using hardlinks, so it's safer to write them to a temp file first, so the inode and therefore
  709.                     // also the versioning information persists. Using the stream on the existing file would overwrite the
  710.                     // contents of the inode and therefore leads to wrong version data
  711.                     $pathInfo = pathinfo($this->getFilename());
  712.                     $tempFilePath = $this->getRealPath() . uniqid('temp_');
  713.                     if ($pathInfo['extension'] ?? false) {
  714.                         $tempFilePath .= '.' . $pathInfo['extension'];
  715.                     }
  717.                     $storage->writeStream($tempFilePath, $src);
  718.                     $storage->delete($path);
  719.                     $storage->move($tempFilePath, $path);
  720.                 }
  722.                 // delete old legacy file if exists
  723.                 $dbPath = $this->getDao()->getCurrentFullPath();
  724.                 if ($dbPath !== $path && $storage->fileExists($dbPath)) {
  725.                     $storage->delete($dbPath);
  726.                 }
  728.                 $this->closeStream(); // set stream to null, so that the source stream isn't used anymore after saving
  730.                 $mimeType = $storage->mimeType($path);
  731.                 $this->setMimeType($mimeType);
  733.                 // set type
  734.                 $type = self::getTypeFromMimeMapping($mimeType, $this->getFilename());
  735.                 if ($type != $this->getType()) {
  736.                     $this->setType($type);
  737.                     $typeChanged = true;
  738.                 }
  740.                 // not only check if the type is set but also if the implementation can be found
  741.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  742.                 if (!self::getModelFactory()->supports($className)) {
  743.                     throw new Exception('unable to resolve asset implementation with type: ' . $this->getType());
  744.                 }
  745.             }
  746.         } else {
  747.             $storage->createDirectory($path);
  748.         }
  750.         if (!$this->getType()) {
  751.             $this->setType('unknown');
  752.         }
  754.         $this->postPersistData();
  756.         // save properties
  757.         $this->getProperties();
  758.         $this->getDao()->deleteAllProperties();
  759.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  760.             foreach ($this->getProperties() as $property) {
  761.                 if (!$property->getInherited()) {
  762.                     $property->setDao(null);
  763.                     $property->setCid($this->getId());
  764.                     $property->setCtype('asset');
  765.                     $property->setCpath($this->getRealFullPath());
  766.                     $property->save();
  767.                 }
  768.             }
  769.         }
  771.         // save dependencies
  772.         $d = new Dependency();
  773.         $d->setSourceType('asset');
  774.         $d->setSourceId($this->getId());
  776.         foreach ($this->resolveDependencies() as $requirement) {
  777.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  778.                 // dont't add a reference to yourself
  779.                 continue;
  780.             } else {
  781.                 $d->addRequirement($requirement['id'], $requirement['type']);
  782.             }
  783.         }
  784.         $d->save();
  786.         $this->getDao()->update();
  788.         //set asset to registry
  789.         $cacheKey = self::getCacheKey($this->getId());
  790.         RuntimeCache::set($cacheKey, $this);
  791.         if (static::class === Asset::class || $typeChanged) {
  792.             // get concrete type of asset
  793.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  794.             // the type (image, document, ...) depends on the mime-type
  795.             RuntimeCache::set($cacheKey, null);
  796.             Asset::getById($this->getId()); // call it to load it to the runtime cache again
  797.         }
  799.         $this->closeStream();
  800.     }
  802.     /**
  803.      * @internal
  804.      */
  805.     protected function postPersistData()
  806.     {
  807.         // hook for the save process, can be overwritten in implementations, such as Image
  808.     }
  810.     /**
  811.      * @param bool $setModificationDate
  812.      * @param bool $saveOnlyVersion
  813.      * @param string $versionNote version note
  814.      *
  815.      * @return null|Version
  816.      *
  817.      * @throws Exception
  818.      */
  819.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  820.     {
  821.         try {
  822.             // hook should be also called if "save only new version" is selected
  823.             if ($saveOnlyVersion) {
  824.                 $event = new AssetEvent($this, [
  825.                     'saveVersionOnly' => true,
  826.                 ]);
  827.                 $this->dispatchEvent($event, AssetEvents::PRE_UPDATE);
  828.             }
  830.             // set date
  831.             if ($setModificationDate) {
  832.                 $this->setModificationDate(time());
  833.             }
  835.             // scheduled tasks are saved always, they are not versioned!
  836.             $this->saveScheduledTasks();
  838.             // create version
  839.             $version = null;
  841.             // only create a new version if there is at least 1 allowed
  842.             // or if saveVersion() was called directly (it's a newer version of the asset)
  843.             $assetsConfig = Config::getSystemConfiguration('assets');
  844.             if ((is_null($assetsConfig['versions']['days'] ?? null) && is_null($assetsConfig['versions']['steps'] ?? null))
  845.                 || (!empty($assetsConfig['versions']['steps']))
  846.                 || !empty($assetsConfig['versions']['days'])
  847.                 || $setModificationDate) {
  848.                 $saveStackTrace = !($assetsConfig['versions']['disable_stack_trace'] ?? false);
  849.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion, $saveStackTrace);
  850.             }
  852.             // hook should be also called if "save only new version" is selected
  853.             if ($saveOnlyVersion) {
  854.                 $event = new AssetEvent($this, [
  855.                     'saveVersionOnly' => true,
  856.                 ]);
  857.                 $this->dispatchEvent($event, AssetEvents::POST_UPDATE);
  858.             }
  860.             return $version;
  861.         } catch (Exception $e) {
  862.             $event = new AssetEvent($this, [
  863.                 'saveVersionOnly' => true,
  864.                 'exception' => $e,
  865.             ]);
  866.             $this->dispatchEvent($event, AssetEvents::POST_UPDATE_FAILURE);
  868.             throw $e;
  869.         }
  870.     }
  872.     /**
  873.      * {@inheritdoc}
  874.      */
  875.     public function getFullPath()
  876.     {
  877.         $path = $this->getPath() . $this->getFilename();
  879.         if (Tool::isFrontend()) {
  880.             return $this->getFrontendFullPath();
  881.         }
  883.         return $path;
  884.     }
  886.     /**
  887.      * Returns the full path of the asset (listener aware)
  888.      *
  889.      * @return string
  890.      *
  891.      * @internal
  892.      */
  893.     public function getFrontendFullPath()
  894.     {
  895.         $path = $this->getPath() . $this->getFilename();
  896.         $path = urlencode_ignore_slash($path);
  898.         $prefix = Pimcore::getContainer()->getParameter('pimcore.config')['assets']['frontend_prefixes']['source'];
  899.         $path = $prefix . $path;
  901.         $event = new GenericEvent($this, [
  902.             'frontendPath' => $path,
  903.         ]);
  905.         $this->dispatchEvent($event, FrontendEvents::ASSET_PATH);
  907.         return $event->getArgument('frontendPath');
  908.     }
  910.     /**
  911.      * {@inheritdoc}
  912.      */
  913.     public function getRealPath()
  914.     {
  915.         return $this->path;
  916.     }
  918.     /**
  919.      * {@inheritdoc}
  920.      */
  921.     public function getRealFullPath()
  922.     {
  923.         $path = $this->getRealPath() . $this->getFilename();
  925.         return $path;
  926.     }
  928.     /**
  929.      * @return array
  930.      */
  931.     public function getSiblings()
  932.     {
  933.         if ($this->siblings === null) {
  934.             if ($this->getParentId()) {
  935.                 $list = new Asset\Listing();
  936.                 $list->addConditionParam('parentId = ?', $this->getParentId());
  937.                 if ($this->getId()) {
  938.                     $list->addConditionParam('id != ?', $this->getId());
  939.                 }
  940.                 $list->setOrderKey('filename');
  941.                 $list->setOrder('asc');
  942.                 $this->siblings = $list->getAssets();
  943.             } else {
  944.                 $this->siblings = [];
  945.             }
  946.         }
  948.         return $this->siblings;
  949.     }
  951.     /**
  952.      * @return bool
  953.      */
  954.     public function hasSiblings()
  955.     {
  956.         if (is_bool($this->hasSiblings)) {
  957.             if (($this->hasSiblings && empty($this->siblings)) || (!$this->hasSiblings && !empty($this->siblings))) {
  958.                 return $this->getDao()->hasSiblings();
  959.             } else {
  960.                 return $this->hasSiblings;
  961.             }
  962.         }
  964.         return $this->getDao()->hasSiblings();
  965.     }
  967.     /**
  968.      * @return bool
  969.      */
  970.     public function hasChildren()
  971.     {
  972.         return false;
  973.     }
  975.     /**
  976.      * @return Asset[]
  977.      */
  978.     public function getChildren()
  979.     {
  980.         return [];
  981.     }
  983.     /**
  984.      * @throws FilesystemException
  985.      */
  986.     private function deletePhysicalFile()
  987.     {
  988.         $storage = Storage::get('asset');
  989.         if ($this->getType() != 'folder') {
  990.             $storage->delete($this->getRealFullPath());
  991.         } else {
  992.             $storage->deleteDirectory($this->getRealFullPath());
  993.         }
  994.     }
  996.     /**
  997.      * {@inheritdoc}
  998.      */
  999.     public function delete(bool $isNested = false)
  1000.     {
  1001.         if ($this->getId() == 1) {
  1002.             throw new Exception('root-node cannot be deleted');
  1003.         }
  1005.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::PRE_DELETE);
  1007.         $this->beginTransaction();
  1009.         try {
  1010.             $this->closeStream();
  1012.             // remove children
  1013.             if ($this->hasChildren()) {
  1014.                 foreach ($this->getChildren() as $child) {
  1015.                     $child->delete(true);
  1016.                 }
  1017.             }
  1019.             // Dispatch Symfony Message Bus to delete versions
  1020.             Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1021.                 new VersionDeleteMessage(Service::getElementType($this), $this->getId())
  1022.             );
  1024.             // remove all properties
  1025.             $this->getDao()->deleteAllProperties();
  1027.             // remove all tasks
  1028.             $this->getDao()->deleteAllTasks();
  1030.             // remove dependencies
  1031.             $d = $this->getDependencies();
  1032.             $d->cleanAllForElement($this);
  1034.             // remove from resource
  1035.             $this->getDao()->delete();
  1037.             $this->commit();
  1039.             // remove file on filesystem
  1040.             if (!$isNested) {
  1041.                 $fullPath = $this->getRealFullPath();
  1042.                 if ($fullPath != '/..' && !strpos($fullPath,
  1043.                     '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1044.                     $this->deletePhysicalFile();
  1045.                 }
  1046.             }
  1048.             $this->clearThumbnails(true);
  1050.             //remove target parent folder preview thumbnails
  1051.             $this->clearFolderThumbnails($this);
  1052.         } catch (Exception $e) {
  1053.             try {
  1054.                 $this->rollBack();
  1055.             } catch (Exception $er) {
  1056.                 // PDO adapter throws exceptions if rollback fails
  1057.                 Logger::info((string) $er);
  1058.             }
  1060.             $failureEvent = new AssetEvent($this);
  1061.             $failureEvent->setArgument('exception', $e);
  1062.             $this->dispatchEvent($failureEvent, AssetEvents::POST_DELETE_FAILURE);
  1063.             Logger::crit((string) $e);
  1065.             throw $e;
  1066.         }
  1068.         // empty asset cache
  1069.         $this->clearDependentCache();
  1071.         // clear asset from registry
  1072.         RuntimeCache::set(self::getCacheKey($this->getId()), null);
  1074.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::POST_DELETE);
  1075.     }
  1077.     /**
  1078.      * {@inheritdoc}
  1079.      */
  1080.     public function clearDependentCache($additionalTags = [])
  1081.     {
  1082.         try {
  1083.             $tags = [$this->getCacheTag(), 'asset_properties', 'output'];
  1084.             $tags = array_merge($tags, $additionalTags);
  1086.             Cache::clearTags($tags);
  1087.         } catch (Exception $e) {
  1088.             Logger::crit((string) $e);
  1089.         }
  1090.     }
  1092.     /**
  1093.      * @return string|null
  1094.      */
  1095.     public function getFilename()
  1096.     {
  1097.         return $this->filename;
  1098.     }
  1100.     /**
  1101.      * {@inheritdoc}
  1102.      */
  1103.     public function getKey()
  1104.     {
  1105.         return $this->getFilename();
  1106.     }
  1108.     /**
  1109.      * {@inheritdoc}
  1110.      */
  1111.     public function getType()
  1112.     {
  1113.         return $this->type;
  1114.     }
  1116.     /**
  1117.      * @param string $filename
  1118.      *
  1119.      * @return $this
  1120.      */
  1121.     public function setFilename($filename)
  1122.     {
  1123.         $this->filename = (string)$filename;
  1125.         return $this;
  1126.     }
  1128.     /**
  1129.      * {@inheritdoc}
  1130.      */
  1131.     public function setKey($key)
  1132.     {
  1133.         return $this->setFilename($key);
  1134.     }
  1136.     /**
  1137.      * @param string $type
  1138.      *
  1139.      * @return $this
  1140.      */
  1141.     public function setType($type)
  1142.     {
  1143.         $this->type = (string)$type;
  1145.         return $this;
  1146.     }
  1148.     /**
  1149.      * @return string|false
  1150.      */
  1151.     public function getData()
  1152.     {
  1153.         $stream = $this->getStream();
  1154.         if ($stream) {
  1155.             return stream_get_contents($stream);
  1156.         }
  1158.         return '';
  1159.     }
  1161.     /**
  1162.      * @param mixed $data
  1163.      *
  1164.      * @return $this
  1165.      */
  1166.     public function setData($data)
  1167.     {
  1168.         $handle = tmpfile();
  1169.         fwrite($handle, $data);
  1170.         $this->setStream($handle);
  1172.         return $this;
  1173.     }
  1175.     /**
  1176.      * @return resource|null
  1177.      */
  1178.     public function getStream()
  1179.     {
  1180.         if ($this->stream) {
  1181.             if (get_resource_type($this->stream) !== 'stream') {
  1182.                 $this->stream = null;
  1183.             } elseif (!@rewind($this->stream)) {
  1184.                 $this->stream = null;
  1185.             }
  1186.         }
  1188.         if (!$this->stream && $this->getType() !== 'folder') {
  1189.             try {
  1190.                 $this->stream = Storage::get('asset')->readStream($this->getRealFullPath());
  1191.             } catch (Exception $e) {
  1192.                 $this->stream = tmpfile();
  1193.             }
  1194.         }
  1196.         return $this->stream;
  1197.     }
  1199.     /**
  1200.      * @param resource|null $stream
  1201.      *
  1202.      * @return $this
  1203.      */
  1204.     public function setStream($stream)
  1205.     {
  1206.         // close existing stream
  1207.         if ($stream !== $this->stream) {
  1208.             $this->closeStream();
  1209.         }
  1211.         if (is_resource($stream)) {
  1212.             $this->setDataChanged(true);
  1213.             $this->stream = $stream;
  1215.             $isRewindable = @rewind($this->stream);
  1217.             if (!$isRewindable) {
  1218.                 $tempFile = $this->getLocalFileFromStream($this->stream);
  1219.                 $dest = fopen($tempFile, 'rb', false, File::getContext());
  1220.                 $this->stream = $dest;
  1221.             }
  1222.         } elseif (is_null($stream)) {
  1223.             $this->stream = null;
  1224.         }
  1226.         return $this;
  1227.     }
  1229.     private function closeStream()
  1230.     {
  1231.         if (is_resource($this->stream)) {
  1232.             @fclose($this->stream);
  1233.             $this->stream = null;
  1234.         }
  1235.     }
  1237.     /**
  1238.      * @return bool
  1239.      */
  1240.     public function getDataChanged()
  1241.     {
  1242.         return $this->dataChanged;
  1243.     }
  1245.     /**
  1246.      * @param bool $changed
  1247.      *
  1248.      * @return $this
  1249.      */
  1250.     public function setDataChanged($changed = true)
  1251.     {
  1252.         $this->dataChanged = $changed;
  1254.         return $this;
  1255.     }
  1257.     /**
  1258.      * {@inheritdoc}
  1259.      */
  1260.     public function getVersions()
  1261.     {
  1262.         if ($this->versions === null) {
  1263.             $this->setVersions($this->getDao()->getVersions());
  1264.         }
  1266.         return $this->versions;
  1267.     }
  1269.     /**
  1270.      * @param Version[] $versions
  1271.      *
  1272.      * @return $this
  1273.      */
  1274.     public function setVersions($versions)
  1275.     {
  1276.         $this->versions = $versions;
  1278.         return $this;
  1279.     }
  1281.     /**
  1282.      * @internal
  1283.      *
  1284.      * @param bool $keep whether to delete this file on shutdown or not
  1285.      *
  1286.      * @return string
  1287.      *
  1288.      * @throws Exception
  1289.      */
  1290.     public function getTemporaryFile(bool $keep = false)
  1291.     {
  1292.         return self::getTemporaryFileFromStream($this->getStream(), $keep);
  1293.     }
  1295.     /**
  1296.      * @internal
  1297.      *
  1298.      * @return string
  1299.      *
  1300.      * @throws Exception
  1301.      */
  1302.     public function getLocalFile()
  1303.     {
  1304.         return self::getLocalFileFromStream($this->getStream());
  1305.     }
  1307.     /**
  1308.      * @param string $key
  1309.      * @param mixed $value
  1310.      *
  1311.      * @return $this
  1312.      */
  1313.     public function setCustomSetting($key, $value)
  1314.     {
  1315.         $this->customSettings[$key] = $value;
  1317.         return $this;
  1318.     }
  1320.     /**
  1321.      * @param string $key
  1322.      *
  1323.      * @return mixed
  1324.      */
  1325.     public function getCustomSetting($key)
  1326.     {
  1327.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1328.             return $this->customSettings[$key];
  1329.         }
  1331.         return null;
  1332.     }
  1334.     /**
  1335.      * @param string $key
  1336.      */
  1337.     public function removeCustomSetting($key)
  1338.     {
  1339.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1340.             unset($this->customSettings[$key]);
  1341.         }
  1342.     }
  1344.     /**
  1345.      * @return array
  1346.      */
  1347.     public function getCustomSettings()
  1348.     {
  1349.         return $this->customSettings;
  1350.     }
  1352.     /**
  1353.      * @param mixed $customSettings
  1354.      *
  1355.      * @return $this
  1356.      */
  1357.     public function setCustomSettings($customSettings)
  1358.     {
  1359.         if (is_string($customSettings)) {
  1360.             $customSettings = Serialize::unserialize($customSettings);
  1361.         }
  1363.         if ($customSettings instanceof stdClass) {
  1364.             $customSettings = (array)$customSettings;
  1365.         }
  1367.         if (!is_array($customSettings)) {
  1368.             $customSettings = [];
  1369.         }
  1371.         $this->customSettings = $customSettings;
  1373.         return $this;
  1374.     }
  1376.     /**
  1377.      * @return string|null
  1378.      */
  1379.     public function getMimeType()
  1380.     {
  1381.         return $this->mimetype;
  1382.     }
  1384.     /**
  1385.      * @param string $mimetype
  1386.      *
  1387.      * @return $this
  1388.      */
  1389.     public function setMimeType($mimetype)
  1390.     {
  1391.         $this->mimetype = (string)$mimetype;
  1393.         return $this;
  1394.     }
  1396.     /**
  1397.      * @param array $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1398.      *
  1399.      * @return $this
  1400.      *
  1401.      * @internal
  1402.      *
  1403.      */
  1404.     public function setMetadataRaw($metadata)
  1405.     {
  1406.         $this->metadata = $metadata;
  1407.         if ($this->metadata) {
  1408.             $this->setHasMetaData(true);
  1409.         }
  1411.         return $this;
  1412.     }
  1414.     /**
  1415.      * @param array[]|stdClass[] $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1416.      *
  1417.      * @return $this
  1418.      */
  1419.     public function setMetadata($metadata)
  1420.     {
  1421.         $this->metadata = [];
  1422.         $this->setHasMetaData(false);
  1423.         if (!empty($metadata)) {
  1424.             foreach ((array)$metadata as $metaItem) {
  1425.                 $metaItem = (array)$metaItem; // also allow object with appropriate keys
  1426.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1427.             }
  1428.         }
  1430.         return $this;
  1431.     }
  1433.     /**
  1434.      * @return bool
  1435.      */
  1436.     public function getHasMetaData()
  1437.     {
  1438.         return $this->hasMetaData;
  1439.     }
  1441.     /**
  1442.      * @param bool $hasMetaData
  1443.      *
  1444.      * @return $this
  1445.      */
  1446.     public function setHasMetaData($hasMetaData)
  1447.     {
  1448.         $this->hasMetaData = (bool)$hasMetaData;
  1450.         return $this;
  1451.     }
  1453.     /**
  1454.      * @param string $name
  1455.      * @param string $type can be "asset", "checkbox", "date", "document", "input", "object", "select" or "textarea"
  1456.      * @param mixed $data
  1457.      * @param string|null $language
  1458.      *
  1459.      * @return $this
  1460.      */
  1461.     public function addMetadata($name, $type, $data = null, $language = null)
  1462.     {
  1463.         if ($name && $type) {
  1464.             $tmp = [];
  1465.             $name = str_replace('~', '---', $name);
  1466.             if (!is_array($this->metadata)) {
  1467.                 $this->metadata = [];
  1468.             }
  1470.             foreach ($this->metadata as $item) {
  1471.                 if ($item['name'] != $name || $language != $item['language']) {
  1472.                     $tmp[] = $item;
  1473.                 }
  1474.             }
  1476.             $item = [
  1477.                 'name' => $name,
  1478.                 'type' => $type,
  1479.                 'data' => $data,
  1480.                 'language' => $language,
  1481.             ];
  1483.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1485.             try {
  1486.                 /** @var Data $instance */
  1487.                 $instance = $loader->build($item['type']);
  1488.                 $transformedData = $instance->transformSetterData($data, $item);
  1489.                 $item['data'] = $transformedData;
  1490.             } catch (UnsupportedException $e) {
  1491.             }
  1493.             $tmp[] = $item;
  1494.             $this->metadata = $tmp;
  1496.             $this->setHasMetaData(true);
  1497.         }
  1499.         return $this;
  1500.     }
  1502.     /**
  1503.      * @param string $name
  1504.      * @param string|null $language
  1505.      *
  1506.      * @return $this
  1507.      */
  1508.     public function removeMetadata(string $name, ?string $language = null)
  1509.     {
  1510.         if ($name) {
  1511.             $tmp = [];
  1512.             $name = str_replace('~', '---', $name);
  1513.             if (!is_array($this->metadata)) {
  1514.                 $this->metadata = [];
  1515.             }
  1517.             foreach ($this->metadata as $item) {
  1518.                 if ($item['name'] === $name && ($language == $item['language'] || $language === '*')) {
  1519.                     continue;
  1520.                 }
  1521.                 $tmp[] = $item;
  1522.             }
  1524.             $this->metadata = $tmp;
  1525.             $this->setHasMetaData(!empty($this->metadata));
  1526.         }
  1528.         return $this;
  1529.     }
  1531.     /**
  1532.      * @param string|null $name
  1533.      * @param string|null $language
  1534.      * @param bool $strictMatch
  1535.      * @param bool $raw
  1536.      *
  1537.      * @return array|string|null
  1538.      */
  1539.     public function getMetadata($name = null, $language = null, $strictMatch = false, $raw = false)
  1540.     {
  1541.         $preEvent = new AssetEvent($this);
  1542.         $preEvent->setArgument('metadata', $this->metadata);
  1543.         $this->dispatchEvent($preEvent, AssetEvents::PRE_GET_METADATA);
  1544.         $this->metadata = $preEvent->getArgument('metadata');
  1546.         $convert = function ($metaData) {
  1547.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1548.             $transformedData = $metaData['data'];
  1550.             try {
  1551.                 /** @var Data $instance */
  1552.                 $instance = $loader->build($metaData['type']);
  1553.                 $transformedData = $instance->transformGetterData($metaData['data'], $metaData);
  1554.             } catch (UnsupportedException $e) {
  1555.             }
  1557.             return $transformedData;
  1558.         };
  1560.         if ($name) {
  1561.             if ($language === null) {
  1562.                 $language = Pimcore::getContainer()->get(LocaleServiceInterface::class)->findLocale();
  1563.             }
  1565.             $data = null;
  1566.             foreach ($this->metadata as $md) {
  1567.                 if ($md['name'] == $name) {
  1568.                     if ($language == $md['language']) {
  1569.                         if ($raw) {
  1570.                             return $md;
  1571.                         }
  1573.                         return $convert($md);
  1574.                     }
  1575.                     if (empty($md['language']) && !$strictMatch) {
  1576.                         if ($raw) {
  1577.                             return $md;
  1578.                         }
  1579.                         $data = $md;
  1580.                     }
  1581.                 }
  1582.             }
  1584.             if ($data) {
  1585.                 if ($raw) {
  1586.                     return $data;
  1587.                 }
  1589.                 return $convert($data);
  1590.             }
  1592.             return null;
  1593.         }
  1595.         $metaData = $this->getObjectVar('metadata');
  1596.         $result = [];
  1597.         if (is_array($metaData)) {
  1598.             foreach ($metaData as $md) {
  1599.                 $md = (array)$md;
  1600.                 if (!$raw) {
  1601.                     $md['data'] = $convert($md);
  1602.                 }
  1603.                 $result[] = $md;
  1604.             }
  1605.         }
  1607.         return $result;
  1608.     }
  1610.     /**
  1611.      * @param bool $formatted
  1612.      * @param int $precision
  1613.      *
  1614.      * @return string|int
  1615.      */
  1616.     public function getFileSize($formatted = false, $precision = 2)
  1617.     {
  1618.         try {
  1619.             $bytes = Storage::get('asset')->fileSize($this->getRealFullPath());
  1620.         } catch (Exception $e) {
  1621.             $bytes = 0;
  1622.         }
  1624.         if ($formatted) {
  1625.             return formatBytes($bytes, $precision);
  1626.         }
  1628.         return $bytes;
  1629.     }
  1631.     /**
  1632.      * @return Asset|null
  1633.      */
  1634.     public function getParent() /** : ?Asset */
  1635.     {
  1636.         $parent = parent::getParent();
  1638.         return $parent instanceof Asset ? $parent : null;
  1639.     }
  1641.     /**
  1642.      * @param Asset|null $parent
  1643.      *
  1644.      * @return $this
  1645.      */
  1646.     public function setParent($parent)
  1647.     {
  1648.         $this->parent = $parent;
  1649.         if ($parent instanceof Asset) {
  1650.             $this->parentId = $parent->getId();
  1651.         }
  1653.         return $this;
  1654.     }
  1656.     public function __wakeup()
  1657.     {
  1658.         if ($this->isInDumpState()) {
  1659.             // set current parent and path, this is necessary because the serialized data can have a different path than the original element (element was moved)
  1660.             $originalElement = Asset::getById($this->getId());
  1661.             if ($originalElement) {
  1662.                 $this->setParentId($originalElement->getParentId());
  1663.                 $this->setPath($originalElement->getRealPath());
  1664.             }
  1665.         }
  1667.         if ($this->isInDumpState() && $this->properties !== null) {
  1668.             $this->renewInheritedProperties();
  1669.         }
  1671.         $this->setInDumpState(false);
  1672.     }
  1674.     public function __destruct()
  1675.     {
  1676.         // close open streams
  1677.         $this->closeStream();
  1678.     }
  1680.     /**
  1681.      * {@inheritdoc}
  1682.      */
  1683.     protected function resolveDependencies(): array
  1684.     {
  1685.         $dependencies = [parent::resolveDependencies()];
  1687.         if ($this->hasMetaData) {
  1688.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1690.             foreach ($this->getMetadata() as $metaData) {
  1691.                 if (!empty($metaData['data'])) {
  1692.                     /** @var ElementInterface $elementData */
  1693.                     $elementData = $metaData['data'];
  1694.                     $elementType = $metaData['type'];
  1696.                     try {
  1697.                         /** @var DataDefinitionInterface $implementation */
  1698.                         $implementation = $loader->build($elementType);
  1699.                         $dependencies[] = $implementation->resolveDependencies($elementData, $metaData);
  1700.                     } catch (UnsupportedException $e) {
  1701.                     }
  1702.                 }
  1703.             }
  1704.         }
  1706.         return array_merge(...$dependencies);
  1707.     }
  1709.     public function __clone()
  1710.     {
  1711.         parent::__clone();
  1712.         $this->parent = null;
  1713.         $this->versions = null;
  1714.         $this->hasSiblings = null;
  1715.         $this->siblings = null;
  1716.         $this->scheduledTasks = null;
  1717.         $this->closeStream();
  1718.     }
  1720.     /**
  1721.      * @param bool $force
  1722.      */
  1723.     public function clearThumbnails($force = false)
  1724.     {
  1725.         if ($this->getDataChanged() || $force) {
  1726.             foreach (['thumbnail', 'asset_cache'] as $storageName) {
  1727.                 $storage = Storage::get($storageName);
  1728.                 $storage->deleteDirectory($this->getRealPath() . $this->getId());
  1729.             }
  1731.             $this->getDao()->deleteFromThumbnailCache();
  1732.         }
  1733.     }
  1735.     /**
  1736.      * @param FilesystemOperator $storage
  1737.      * @param string $oldPath
  1738.      * @param string|null $newPath
  1739.      *
  1740.      * @throws FilesystemException
  1741.      */
  1742.     private function updateChildPaths(FilesystemOperator $storage, string $oldPath, string $newPath = null)
  1743.     {
  1744.         if ($newPath === null) {
  1745.             $newPath = $this->getRealFullPath();
  1746.         }
  1748.         try {
  1749.             $children = $storage->listContents($oldPath, true);
  1750.             foreach ($children as $child) {
  1751.                 if ($child['type'] === 'file') {
  1752.                     $src  = $child['path'];
  1753.                     $dest = str_replace($oldPath, $newPath, '/' . $src);
  1754.                     $storage->move($src, $dest);
  1755.                 }
  1756.             }
  1758.             $storage->deleteDirectory($oldPath);
  1759.         } catch (UnableToMoveFile $e) {
  1760.             // noting to do
  1761.         }
  1762.     }
  1764.     /**
  1765.      * @param string $oldPath
  1766.      *
  1767.      * @throws FilesystemException
  1768.      */
  1769.     private function relocateThumbnails(string $oldPath)
  1770.     {
  1771.         if ($this instanceof Folder) {
  1772.             $oldThumbnailsPath = $oldPath;
  1773.             $newThumbnailsPath = $this->getRealFullPath();
  1774.         } else {
  1775.             $oldThumbnailsPath = dirname($oldPath) . '/' . $this->getId();
  1776.             $newThumbnailsPath = $this->getRealPath() . $this->getId();
  1777.         }
  1779.         if ($oldThumbnailsPath === $newThumbnailsPath) {
  1780.             //path is equal, probably file name changed - so clear all thumbnails
  1781.             $this->clearThumbnails(true);
  1782.         } else {
  1783.             //remove source parent folder preview thumbnails
  1784.             $sourceFolder = Asset::getByPath(dirname($oldPath));
  1785.             if ($sourceFolder) {
  1786.                 $this->clearFolderThumbnails($sourceFolder);
  1787.             }
  1789.             //remove target parent folder preview thumbnails
  1790.             $this->clearFolderThumbnails($this);
  1792.             foreach (['thumbnail', 'asset_cache'] as $storageName) {
  1793.                 $storage = Storage::get($storageName);
  1795.                 try {
  1796.                     $storage->move($oldThumbnailsPath, $newThumbnailsPath);
  1797.                 } catch (UnableToMoveFile $e) {
  1798.                     //update children, if unable to move parent
  1799.                     $this->updateChildPaths($storage, $oldPath);
  1800.                 }
  1801.             }
  1802.         }
  1803.     }
  1805.     /**
  1806.      * @param Asset $asset
  1807.      */
  1808.     private function clearFolderThumbnails(Asset $asset): void
  1809.     {
  1810.         do {
  1811.             if ($asset instanceof Folder) {
  1812.                 $asset->clearThumbnails(true);
  1813.             }
  1815.             $asset = $asset->getParent();
  1816.         } while ($asset !== null);
  1817.     }
  1819.     /**
  1820.      * @param string $name
  1821.      */
  1822.     public function clearThumbnail($name)
  1823.     {
  1824.         try {
  1825.             Storage::get('thumbnail')->deleteDirectory($this->getRealPath().'/'.$this->getId().'/image-thumb__'.$this->getId().'__'.$name);
  1826.             $this->getDao()->deleteFromThumbnailCache($name);
  1827.         } catch (Exception $e) {
  1828.             // noting to do
  1829.         }
  1830.     }
  1832.     /**
  1833.      * @internal
  1834.      */
  1835.     protected function addToUpdateTaskQueue(): void
  1836.     {
  1837.         Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1838.             new AssetUpdateTasksMessage($this->getId())
  1839.         );
  1840.     }
  1842.     /**
  1843.      * @return string
  1844.      */
  1845.     public function getFrontendPath(): string
  1846.     {
  1847.         $path = $this->getFullPath();
  1848.         if (!\preg_match('@^(https?|data):@', $path)) {
  1849.             $path = \Pimcore\Tool::getHostUrl() . $path;
  1850.         }
  1852.         return $path;
  1853.     }
  1854. }