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

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 League\Flysystem\UnableToRetrieveMetadata;
  25. use Pimcore;
  26. use Pimcore\Cache;
  27. use Pimcore\Cache\RuntimeCache;
  28. use Pimcore\Config;
  29. use Pimcore\Event\AssetEvents;
  30. use Pimcore\Event\FrontendEvents;
  31. use Pimcore\Event\Model\AssetEvent;
  32. use Pimcore\File;
  33. use Pimcore\Helper\TemporaryFileHelperTrait;
  34. use Pimcore\Loader\ImplementationLoader\Exception\UnsupportedException;
  35. use Pimcore\Localization\LocaleServiceInterface;
  36. use Pimcore\Logger;
  37. use Pimcore\Messenger\AssetUpdateTasksMessage;
  38. use Pimcore\Messenger\VersionDeleteMessage;
  39. use Pimcore\Model\Asset\Dao;
  40. use Pimcore\Model\Asset\Folder;
  41. use Pimcore\Model\Asset\Image\Thumbnail\Config as ThumbnailConfig;
  42. use Pimcore\Model\Asset\Listing;
  43. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\Data;
  44. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\DataDefinitionInterface;
  45. use Pimcore\Model\Element\DuplicateFullPathException;
  46. use Pimcore\Model\Element\ElementInterface;
  47. use Pimcore\Model\Element\Service;
  48. use Pimcore\Model\Element\Traits\ScheduledTasksTrait;
  49. use Pimcore\Model\Element\ValidationException;
  50. use Pimcore\Model\Exception\NotFoundException;
  51. use Pimcore\Tool;
  52. use Pimcore\Tool\Serialize;
  53. use Pimcore\Tool\Storage;
  54. use stdClass;
  55. use Symfony\Component\EventDispatcher\GenericEvent;
  56. use Symfony\Component\Mime\MimeTypes;
  58. /**
  59.  * @method Dao getDao()
  60.  * @method bool __isBasedOnLatestData()
  61.  * @method int getChildAmount($user = null)
  62.  * @method string|null getCurrentFullPath()
  63.  */
  64. class Asset extends Element\AbstractElement
  65. {
  66.     use ScheduledTasksTrait;
  67.     use TemporaryFileHelperTrait;
  69.     /**
  70.      * all possible types of assets
  71.      *
  72.      * @internal
  73.      *
  74.      * @var array
  75.      */
  76.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  78.     /**
  79.      * @internal
  80.      *
  81.      * @var string
  82.      */
  83.     protected $type = '';
  85.     /**
  86.      * @internal
  87.      *
  88.      * @var string|null
  89.      */
  90.     protected $filename;
  92.     /**
  93.      * @internal
  94.      *
  95.      * @var string|null
  96.      */
  97.     protected $mimetype;
  99.     /**
  100.      * @internal
  101.      *
  102.      * @var resource|null
  103.      */
  104.     protected $stream;
  106.     /**
  107.      * @internal
  108.      *
  109.      * @var array|null
  110.      */
  111.     protected $versions = null;
  113.     /**
  114.      * @internal
  115.      *
  116.      * @var array
  117.      */
  118.     protected $metadata = [];
  120.     /**
  121.      * List of some custom settings  [key] => value
  122.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  123.      *
  124.      * @internal
  125.      *
  126.      * @var array
  127.      */
  128.     protected $customSettings = [];
  130.     /**
  131.      * @internal
  132.      *
  133.      * @var bool
  134.      */
  135.     protected $hasMetaData = false;
  137.     /**
  138.      * @internal
  139.      *
  140.      * @var array|null
  141.      */
  142.     protected $siblings;
  144.     /**
  145.      * @internal
  146.      *
  147.      * @var bool|null
  148.      */
  149.     protected $hasSiblings;
  151.     /**
  152.      * @internal
  153.      *
  154.      * @var bool
  155.      */
  156.     protected $dataChanged = false;
  158.     /**
  159.      * @internal
  160.      *
  161.      * @var int|null
  162.      */
  163.     protected ?int $dataModificationDate = null;
  165.     /**
  166.      * @return int|null
  167.      */
  168.     public function getDataModificationDate(): ?int
  169.     {
  170.         return $this->dataModificationDate;
  171.     }
  173.     /**
  174.      * @param int|null $dataModificationDate
  175.      *
  176.      * @return $this
  177.      */
  178.     public function setDataModificationDate(?int $dataModificationDate): static
  179.     {
  180.         $this->dataModificationDate = $dataModificationDate;
  182.         return $this;
  183.     }
  185.     /**
  186.      * {@inheritdoc}
  187.      */
  188.     protected function getBlockedVars(): array
  189.     {
  190.         $blockedVars = ['scheduledTasks', 'hasChildren', 'versions', 'parent', 'stream'];
  192.         if (!$this->isInDumpState()) {
  193.             // for caching asset
  194.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  195.         }
  197.         return $blockedVars;
  198.     }
  200.     /**
  201.      *
  202.      * @return array
  203.      */
  204.     public static function getTypes()
  205.     {
  206.         return self::$types;
  207.     }
  209.     /**
  210.      * Static helper to get an asset by the passed path
  211.      *
  212.      * @param string $path
  213.      * @param array|bool $force
  214.      *
  215.      * @return static|null
  216.      */
  217.     public static function getByPath($path, $force = false)
  218.     {
  219.         if (!$path) {
  220.             return null;
  221.         }
  223.         $path = Element\Service::correctPath($path);
  225.         try {
  226.             $asset = new static();
  227.             $asset->getDao()->getByPath($path);
  229.             return static::getById(
  230.                 $asset->getId(),
  231.                 Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1)
  232.             );
  233.         } catch (NotFoundException $e) {
  234.             return null;
  235.         }
  236.     }
  238.     /**
  239.      * @internal
  240.      *
  241.      * @param Asset $asset
  242.      *
  243.      * @return bool
  244.      */
  245.     protected static function typeMatch(Asset $asset)
  246.     {
  247.         $staticType = static::class;
  248.         if ($staticType !== Asset::class) {
  249.             if (!$asset instanceof $staticType) {
  250.                 return false;
  251.             }
  252.         }
  254.         return true;
  255.     }
  257.     /**
  258.      * @param int|string $id
  259.      * @param array|bool $force
  260.      *
  261.      * @return static|null
  262.      */
  263.     public static function getById($id, $force = false)
  264.     {
  265.         if (!is_numeric($id) || $id < 1) {
  266.             return null;
  267.         }
  269.         $id = (int)$id;
  270.         $cacheKey = self::getCacheKey($id);
  272.         $params = Service::prepareGetByIdParams($force, __METHOD__, func_num_args() > 1);
  274.         if (!$params['force'] && RuntimeCache::isRegistered($cacheKey)) {
  275.             $asset = RuntimeCache::get($cacheKey);
  276.             if ($asset && static::typeMatch($asset)) {
  277.                 return $asset;
  278.             }
  279.         }
  281.         if ($params['force'] || !($asset = Cache::load($cacheKey))) {
  282.             $asset = new static();
  284.             try {
  285.                 $asset->getDao()->getById($id);
  286.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  287.                 /** @var Asset $newAsset */
  288.                 $newAsset = self::getModelFactory()->build($className);
  290.                 if (get_class($asset) !== get_class($newAsset)) {
  291.                     $asset = $newAsset;
  292.                     $asset->getDao()->getById($id);
  293.                 }
  295.                 RuntimeCache::set($cacheKey, $asset);
  296.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  298.                 $asset->resetDirtyMap();
  300.                 Cache::save($asset, $cacheKey);
  301.             } catch (NotFoundException $e) {
  302.                 $asset = null;
  303.             }
  304.         } else {
  305.             RuntimeCache::set($cacheKey, $asset);
  306.         }
  308.         if ($asset && static::typeMatch($asset)) {
  309.             \Pimcore::getEventDispatcher()->dispatch(
  310.                 new AssetEvent($asset, ['params' => $params]),
  311.                 AssetEvents::POST_LOAD
  312.             );
  313.         }
  315.         return $asset;
  316.     }
  318.     /**
  319.      * @param int $parentId
  320.      * @param array $data
  321.      * @param bool $save
  322.      *
  323.      * @return Asset
  324.      */
  325.     public static function create($parentId, $data = [], $save = true)
  326.     {
  327.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  328.         // (tree) is generated immediately after creating an image
  329.         $class = Asset::class;
  330.         if (
  331.             array_key_exists('filename', $data) &&
  332.             (
  333.                 array_key_exists('data', $data) ||
  334.                 array_key_exists('sourcePath', $data) ||
  335.                 array_key_exists('stream', $data)
  336.             )
  337.         ) {
  338.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  339.                 $fileExtension = File::getFileExtension($data['filename']);
  340.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . $fileExtension;
  342.                 if (!str_starts_with($tmpFile, PIMCORE_SYSTEM_TEMP_DIRECTORY)) {
  343.                     throw new \InvalidArgumentException('Invalid filename');
  344.                 }
  346.                 if (array_key_exists('data', $data)) {
  347.                     File::put($tmpFile, $data['data']);
  348.                     self::checkMaxPixels($tmpFile, $data);
  349.                     $mimeType = MimeTypes::getDefault()->guessMimeType($tmpFile);
  350.                     unlink($tmpFile);
  351.                 } else {
  352.                     $streamMeta = stream_get_meta_data($data['stream']);
  353.                     if (file_exists($streamMeta['uri'])) {
  354.                         // stream is a local file, so we don't have to write a tmp file
  355.                         self::checkMaxPixels($streamMeta['uri'], $data);
  356.                         $mimeType = MimeTypes::getDefault()->guessMimeType($streamMeta['uri']);
  357.                     } else {
  358.                         // write a tmp file because the stream isn't a pointer to the local filesystem
  359.                         $isRewindable = @rewind($data['stream']);
  360.                         $dest = fopen($tmpFile, 'w+', false, File::getContext());
  361.                         stream_copy_to_stream($data['stream'], $dest);
  362.                         self::checkMaxPixels($tmpFile, $data);
  363.                         $mimeType = MimeTypes::getDefault()->guessMimeType($tmpFile);
  365.                         if (!$isRewindable) {
  366.                             $data['stream'] = $dest;
  367.                         } else {
  368.                             fclose($dest);
  369.                             unlink($tmpFile);
  370.                         }
  371.                     }
  372.                 }
  373.             } else {
  374.                 if (is_dir($data['sourcePath'])) {
  375.                     $mimeType = 'directory';
  376.                 } else {
  377.                     self::checkMaxPixels($data['sourcePath'], $data);
  378.                     $mimeType = MimeTypes::getDefault()->guessMimeType($data['sourcePath']);
  379.                     if (is_file($data['sourcePath'])) {
  380.                         $data['stream'] = fopen($data['sourcePath'], 'rb', false, File::getContext());
  381.                     }
  382.                 }
  384.                 unset($data['sourcePath']);
  385.             }
  387.             $type = self::getTypeFromMimeMapping($mimeType, $data['filename']);
  388.             $class = '\\Pimcore\\Model\\Asset\\' . ucfirst($type);
  389.             if (array_key_exists('type', $data)) {
  390.                 unset($data['type']);
  391.             }
  392.         }
  394.         /** @var Asset $asset */
  395.         $asset = self::getModelFactory()->build($class);
  396.         $asset->setParentId($parentId);
  397.         self::checkCreateData($data);
  398.         $asset->setValues($data);
  400.         if ($save) {
  401.             $asset->save();
  402.         }
  404.         return $asset;
  405.     }
  407.     private static function checkMaxPixels(string $localPath, array $data): void
  408.     {
  409.         // this check is intentionally done in Asset::create() because in Asset::update() it would result
  410.         // in an additional download from remote storage if configured, so in terms of performance
  411.         // this is the more efficient way
  412.         $maxPixels = (int) Pimcore::getContainer()->getParameter('pimcore.config')['assets']['image']['max_pixels'];
  413.         if ($size = @getimagesize($localPath)) {
  414.             $imagePixels = (int) ($size[0] * $size[1]);
  415.             if ($imagePixels > $maxPixels) {
  416.                 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");
  418.                 $diff = sqrt(1 + ($maxPixels / $imagePixels));
  419.                 $suggestion_0 = (int) round($size[0] / $diff, -2, PHP_ROUND_HALF_DOWN);
  420.                 $suggestion_1 = (int) round($size[1] / $diff, -2, PHP_ROUND_HALF_DOWN);
  422.                 $mp = $maxPixels / 1_000_000;
  423.                 // unlink file before throwing exception
  424.                 unlink($localPath);
  426.                 throw new ValidationException("<p>Image dimensions of <em>{$data['filename']}</em> are too large.</p>
  427. <p>Max size: <code>{$mp}</code> <abbr title='Million pixels'>Megapixels</abbr></p>
  428. <p>Suggestion: resize to <code>{$suggestion_0}&times;{$suggestion_1}</code> pixels or smaller.</p>");
  429.             }
  430.         }
  431.     }
  433.     /**
  434.      * @param array $config
  435.      *
  436.      * @return Listing
  437.      *
  438.      * @throws Exception
  439.      */
  440.     public static function getList($config = [])
  441.     {
  442.         if (!is_array($config)) {
  443.             throw new \RuntimeException('Unable to initiate list class - please provide valid configuration array');
  444.         }
  446.         $listClass = Listing::class;
  448.         /** @var Listing $list */
  449.         $list = self::getModelFactory()->build($listClass);
  450.         $list->setValues($config);
  452.         return $list;
  453.     }
  455.     /**
  456.      * @deprecated will be removed in Pimcore 11
  457.      *
  458.      * @param array $config
  459.      *
  460.      * @return int total count
  461.      */
  462.     public static function getTotalCount($config = [])
  463.     {
  464.         $list = static::getList($config);
  465.         $count = $list->getTotalCount();
  467.         return $count;
  468.     }
  470.     /**
  471.      * @internal
  472.      *
  473.      * @param string $mimeType
  474.      * @param string $filename
  475.      *
  476.      * @return string
  477.      */
  478.     public static function getTypeFromMimeMapping($mimeType, $filename)
  479.     {
  480.         if ($mimeType == 'directory') {
  481.             return 'folder';
  482.         }
  484.         $type = null;
  486.         $mappings = [
  487.             'unknown' => ["/\.stp$/"],
  488.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/",
  489.                 "/\.wmf$/", '/photoshop/'],
  490.             'text' => ['/text\//', '/xml$/', '/\.json$/'],
  491.             'audio' => ['/audio/'],
  492.             'video' => ['/video/'],
  493.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  494.             'archive' => ['/zip/', '/tar/'],
  495.         ];
  497.         foreach ($mappings as $assetType => $patterns) {
  498.             foreach ($patterns as $pattern) {
  499.                 if (preg_match($pattern, $mimeType . ' .' . File::getFileExtension($filename))) {
  500.                     $type = $assetType;
  502.                     break;
  503.                 }
  504.             }
  506.             // break at first match
  507.             if ($type) {
  508.                 break;
  509.             }
  510.         }
  512.         if (!$type) {
  513.             $type = 'unknown';
  514.         }
  516.         return $type;
  517.     }
  519.     /**
  520.      * {@inheritdoc}
  521.      */
  522.     public function save()
  523.     {
  524.         // additional parameters (e.g. "versionNote" for the version note)
  525.         $params = [];
  526.         if (func_num_args() && is_array(func_get_arg(0))) {
  527.             $params = func_get_arg(0);
  528.         }
  530.         $isUpdate = false;
  531.         $differentOldPath = null;
  533.         try {
  534.             $preEvent = new AssetEvent($this, $params);
  536.             if ($this->getId()) {
  537.                 $isUpdate = true;
  538.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_UPDATE);
  539.             } else {
  540.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_ADD);
  541.             }
  543.             $params = $preEvent->getArguments();
  545.             $this->correctPath();
  547.             $params['isUpdate'] = $isUpdate; // need for $this->update() for certain types (image, video, document)
  549.             // we wrap the save actions in a loop here, to restart the database transactions in the case it fails
  550.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  551.             // especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  552.             $maxRetries = 5;
  553.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  554.                 $this->beginTransaction();
  556.                 try {
  557.                     if (!$isUpdate) {
  558.                         $this->getDao()->create();
  559.                     }
  561.                     // get the old path from the database before the update is done
  562.                     $oldPath = null;
  563.                     if ($isUpdate) {
  564.                         $oldPath = $this->getDao()->getCurrentFullPath();
  565.                     }
  567.                     $this->update($params);
  569.                     $storage = Storage::get('asset');
  570.                     // if the old path is different from the new path, update all children
  571.                     $updatedChildren = [];
  572.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  573.                         $differentOldPath = $oldPath;
  575.                         try {
  576.                             $storage->move($oldPath, $this->getRealFullPath());
  577.                         } catch (UnableToMoveFile $e) {
  578.                             //update children, if unable to move parent
  579.                             $this->updateChildPaths($storage, $oldPath);
  580.                         }
  582.                         $this->getDao()->updateWorkspaces();
  584.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  585.                         $this->relocateThumbnails($oldPath);
  586.                     }
  588.                     // lastly create a new version if necessary
  589.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  590.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  591.                     if ($this->getType() != 'folder') {
  592.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  593.                     }
  595.                     $this->commit();
  597.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  598.                 } catch (Exception $e) {
  599.                     try {
  600.                         $this->rollBack();
  601.                     } catch (Exception $er) {
  602.                         // PDO adapter throws exceptions if rollback fails
  603.                         Logger::error((string) $er);
  604.                     }
  606.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  607.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  608.                         $run = $retries + 1;
  609.                         $waitTime = rand(1, 5) * 100000; // microseconds
  610.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  612.                         usleep($waitTime); // wait specified time until we restart the transaction
  613.                     } else {
  614.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  615.                         throw $e;
  616.                     }
  617.                 }
  618.             }
  620.             $additionalTags = [];
  621.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  622.                 foreach ($updatedChildren as $assetId) {
  623.                     $tag = 'asset_' . $assetId;
  624.                     $additionalTags[] = $tag;
  626.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  627.                     RuntimeCache::set($tag, null);
  628.                 }
  629.             }
  630.             $this->clearDependentCache($additionalTags);
  632.             if ($this->getDataChanged()) {
  633.                 if (in_array($this->getType(), ['image', 'video', 'document'])) {
  634.                     $this->addToUpdateTaskQueue();
  635.                 }
  636.             }
  638.             $this->setDataChanged(false);
  640.             $postEvent = new AssetEvent($this, $params);
  641.             if ($isUpdate) {
  642.                 if ($differentOldPath) {
  643.                     $postEvent->setArgument('oldPath', $differentOldPath);
  644.                 }
  645.                 $this->dispatchEvent($postEvent, AssetEvents::POST_UPDATE);
  646.             } else {
  647.                 $this->dispatchEvent($postEvent, AssetEvents::POST_ADD);
  648.             }
  650.             return $this;
  651.         } catch (Exception $e) {
  652.             $failureEvent = new AssetEvent($this, $params);
  653.             $failureEvent->setArgument('exception', $e);
  654.             if ($isUpdate) {
  655.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_UPDATE_FAILURE);
  656.             } else {
  657.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_ADD_FAILURE);
  658.             }
  660.             throw $e;
  661.         }
  662.     }
  664.     /**
  665.      * @internal
  666.      *
  667.      * @throws Exception|DuplicateFullPathException
  668.      */
  669.     public function correctPath()
  670.     {
  671.         // set path
  672.         if ($this->getId() != 1) { // not for the root node
  673.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  674.                 throw new Exception("invalid filename '" . $this->getKey() . "' for asset with id [ " . $this->getId() . ' ]');
  675.             }
  677.             if ($this->getParentId() == $this->getId()) {
  678.                 throw new Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  679.             }
  681.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  682.                 throw new Exception('Cannot create asset called ".." or "."');
  683.             }
  685.             $parent = Asset::getById($this->getParentId());
  686.             if ($parent) {
  687.                 // use the parent's path from the database here (getCurrentFullPath),
  688.                 //to ensure the path really exists and does not rely on the path
  689.                 // that is currently in the parent asset (in memory),
  690.                 //because this might have changed but wasn't not saved
  691.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  692.             } else {
  693.                 trigger_deprecation(
  694.                     'pimcore/pimcore',
  695.                     '10.5',
  696.                     'Fallback for parentId will be removed in Pimcore 11.',
  697.                 );
  698.                 // parent document doesn't exist anymore, set the parent to to root
  699.                 $this->setParentId(1);
  700.                 $this->setPath('/');
  701.             }
  702.         } elseif ($this->getId() == 1) {
  703.             // some data in root node should always be the same
  704.             $this->setParentId(0);
  705.             $this->setPath('/');
  706.             $this->setFilename('');
  707.             $this->setType('folder');
  708.         }
  710.         // do not allow PHP and .htaccess files
  711.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  712.             $this->setFilename($this->getFilename() . '.txt');
  713.         }
  715.         if (mb_strlen($this->getFilename()) > 255) {
  716.             throw new Exception('Filenames longer than 255 characters are not allowed');
  717.         }
  719.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  720.             $duplicate = Asset::getByPath($this->getRealFullPath());
  721.             if ($duplicate instanceof Asset && $duplicate->getId() != $this->getId()) {
  722.                 $duplicateFullPathException = new DuplicateFullPathException('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  723.                 $duplicateFullPathException->setDuplicateElement($duplicate);
  725.                 throw $duplicateFullPathException;
  726.             }
  727.         }
  729.         $this->validatePathLength();
  730.     }
  732.     /**
  733.      * @internal
  734.      *
  735.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  736.      *
  737.      * @throws Exception
  738.      */
  739.     protected function update($params = [])
  740.     {
  741.         $storage = Storage::get('asset');
  742.         $this->updateModificationInfos();
  744.         $path = $this->getRealFullPath();
  745.         $typeChanged = false;
  747.         if ($this->getType() != 'folder') {
  748.             if ($this->getDataChanged()) {
  749.                 $src = $this->getStream();
  751.                 if (!$storage->fileExists($path) || !stream_is_local($storage->readStream($path))) {
  752.                     // write stream directly if target file doesn't exist or if target is a remote storage
  753.                     // this is because we don't have hardlinks there, so we don't need to consider them (see below)
  754.                     $storage->writeStream($path, $src);
  755.                 } else {
  756.                     // We don't open a stream on existing files, because they could be possibly used by versions
  757.                     // using hardlinks, so it's safer to write them to a temp file first, so the inode and therefore
  758.                     // also the versioning information persists. Using the stream on the existing file would overwrite the
  759.                     // contents of the inode and therefore leads to wrong version data
  760.                     $pathInfo = pathinfo($this->getFilename());
  761.                     $tempFilePath = $this->getRealPath() . uniqid('temp_');
  762.                     if ($pathInfo['extension'] ?? false) {
  763.                         $tempFilePath .= '.' . $pathInfo['extension'];
  764.                     }
  766.                     $storage->writeStream($tempFilePath, $src);
  767.                     $storage->delete($path);
  768.                     $storage->move($tempFilePath, $path);
  769.                 }
  771.                 // delete old legacy file if exists
  772.                 $dbPath = $this->getDao()->getCurrentFullPath();
  773.                 if ($dbPath !== $path && $storage->fileExists($dbPath)) {
  774.                     $storage->delete($dbPath);
  775.                 }
  777.                 $this->closeStream(); // set stream to null, so that the source stream isn't used anymore after saving
  779.                 try {
  780.                     $mimeType = $storage->mimeType($path);
  781.                 } catch(UnableToRetrieveMetadata $e) {
  782.                     $mimeType = 'application/octet-stream';
  783.                 }
  784.                 $this->setMimeType($mimeType);
  786.                 // set type
  787.                 $type = self::getTypeFromMimeMapping($mimeType, $this->getFilename());
  788.                 if ($type != $this->getType()) {
  789.                     $this->setType($type);
  790.                     $typeChanged = true;
  791.                 }
  793.                 // not only check if the type is set but also if the implementation can be found
  794.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  795.                 if (!self::getModelFactory()->supports($className)) {
  796.                     throw new Exception('unable to resolve asset implementation with type: ' . $this->getType());
  797.                 }
  798.             }
  799.         } else {
  800.             $storage->createDirectory($path);
  801.         }
  803.         if (!$this->getType()) {
  804.             $this->setType('unknown');
  805.         }
  807.         $this->postPersistData();
  809.         // save properties
  810.         $this->getProperties();
  811.         $this->getDao()->deleteAllProperties();
  812.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  813.             foreach ($this->getProperties() as $property) {
  814.                 if (!$property->getInherited()) {
  815.                     $property->setDao(null);
  816.                     $property->setCid($this->getId());
  817.                     $property->setCtype('asset');
  818.                     $property->setCpath($this->getRealFullPath());
  819.                     $property->save();
  820.                 }
  821.             }
  822.         }
  824.         // save dependencies
  825.         $d = new Dependency();
  826.         $d->setSourceType('asset');
  827.         $d->setSourceId($this->getId());
  829.         foreach ($this->resolveDependencies() as $requirement) {
  830.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  831.                 // dont't add a reference to yourself
  832.                 continue;
  833.             } else {
  834.                 $d->addRequirement($requirement['id'], $requirement['type']);
  835.             }
  836.         }
  837.         $d->save();
  839.         $this->getDao()->update();
  841.         //set asset to registry
  842.         $cacheKey = self::getCacheKey($this->getId());
  843.         RuntimeCache::set($cacheKey, $this);
  844.         if (static::class === Asset::class || $typeChanged) {
  845.             // get concrete type of asset
  846.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  847.             // the type (image, document, ...) depends on the mime-type
  848.             RuntimeCache::set($cacheKey, null);
  849.             Asset::getById($this->getId()); // call it to load it to the runtime cache again
  850.         }
  852.         $this->closeStream();
  853.     }
  855.     /**
  856.      * @internal
  857.      */
  858.     protected function postPersistData()
  859.     {
  860.         // hook for the save process, can be overwritten in implementations, such as Image
  861.     }
  863.     /**
  864.      * @param bool $setModificationDate
  865.      * @param bool $saveOnlyVersion
  866.      * @param string $versionNote version note
  867.      *
  868.      * @return null|Version
  869.      *
  870.      * @throws Exception
  871.      */
  872.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  873.     {
  874.         try {
  875.             // hook should be also called if "save only new version" is selected
  876.             if ($saveOnlyVersion) {
  877.                 $event = new AssetEvent($this, [
  878.                     'saveVersionOnly' => true,
  879.                 ]);
  880.                 $this->dispatchEvent($event, AssetEvents::PRE_UPDATE);
  881.             }
  883.             // set date
  884.             if ($setModificationDate) {
  885.                 $this->setModificationDate(time());
  886.             }
  888.             // scheduled tasks are saved always, they are not versioned!
  889.             $this->saveScheduledTasks();
  891.             // create version
  892.             $version = null;
  894.             // only create a new version if there is at least 1 allowed
  895.             // or if saveVersion() was called directly (it's a newer version of the asset)
  896.             $assetsConfig = Config::getSystemConfiguration('assets');
  897.             if ((is_null($assetsConfig['versions']['days'] ?? null) && is_null($assetsConfig['versions']['steps'] ?? null))
  898.                 || (!empty($assetsConfig['versions']['steps']))
  899.                 || !empty($assetsConfig['versions']['days'])
  900.                 || $setModificationDate) {
  901.                 $saveStackTrace = !($assetsConfig['versions']['disable_stack_trace'] ?? false);
  902.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion, $saveStackTrace);
  903.             }
  905.             // hook should be also called if "save only new version" is selected
  906.             if ($saveOnlyVersion) {
  907.                 $event = new AssetEvent($this, [
  908.                     'saveVersionOnly' => true,
  909.                 ]);
  910.                 $this->dispatchEvent($event, AssetEvents::POST_UPDATE);
  911.             }
  913.             return $version;
  914.         } catch (Exception $e) {
  915.             $event = new AssetEvent($this, [
  916.                 'saveVersionOnly' => true,
  917.                 'exception' => $e,
  918.             ]);
  919.             $this->dispatchEvent($event, AssetEvents::POST_UPDATE_FAILURE);
  921.             throw $e;
  922.         }
  923.     }
  925.     /**
  926.      * {@inheritdoc}
  927.      */
  928.     public function getFullPath()
  929.     {
  930.         $path = $this->getPath() . $this->getFilename();
  932.         if (Tool::isFrontend()) {
  933.             return $this->getFrontendFullPath();
  934.         }
  936.         return $path;
  937.     }
  939.     /**
  940.      * Returns the full path of the asset (listener aware)
  941.      *
  942.      * @return string
  943.      *
  944.      * @internal
  945.      */
  946.     public function getFrontendFullPath()
  947.     {
  948.         $path = $this->getPath() . $this->getFilename();
  949.         $path = urlencode_ignore_slash($path);
  951.         $prefix = Pimcore::getContainer()->getParameter('pimcore.config')['assets']['frontend_prefixes']['source'];
  952.         $path = $prefix . $path;
  954.         $event = new GenericEvent($this, [
  955.             'frontendPath' => $path,
  956.         ]);
  958.         $this->dispatchEvent($event, FrontendEvents::ASSET_PATH);
  960.         return $event->getArgument('frontendPath');
  961.     }
  963.     /**
  964.      * {@inheritdoc}
  965.      */
  966.     public function getRealPath()
  967.     {
  968.         return $this->path;
  969.     }
  971.     /**
  972.      * {@inheritdoc}
  973.      */
  974.     public function getRealFullPath()
  975.     {
  976.         $path = $this->getRealPath() . $this->getFilename();
  978.         return $path;
  979.     }
  981.     /**
  982.      * @return array
  983.      */
  984.     public function getSiblings()
  985.     {
  986.         if ($this->siblings === null) {
  987.             if ($this->getParentId()) {
  988.                 $list = new Asset\Listing();
  989.                 $list->addConditionParam('parentId = ?', $this->getParentId());
  990.                 if ($this->getId()) {
  991.                     $list->addConditionParam('id != ?', $this->getId());
  992.                 }
  993.                 $list->setOrderKey('filename');
  994.                 $list->setOrder('asc');
  995.                 $this->siblings = $list->getAssets();
  996.             } else {
  997.                 $this->siblings = [];
  998.             }
  999.         }
  1001.         return $this->siblings;
  1002.     }
  1004.     /**
  1005.      * @return bool
  1006.      */
  1007.     public function hasSiblings()
  1008.     {
  1009.         if (is_bool($this->hasSiblings)) {
  1010.             if (($this->hasSiblings && empty($this->siblings)) || (!$this->hasSiblings && !empty($this->siblings))) {
  1011.                 return $this->getDao()->hasSiblings();
  1012.             } else {
  1013.                 return $this->hasSiblings;
  1014.             }
  1015.         }
  1017.         return $this->getDao()->hasSiblings();
  1018.     }
  1020.     /**
  1021.      * @return bool
  1022.      */
  1023.     public function hasChildren()
  1024.     {
  1025.         return false;
  1026.     }
  1028.     /**
  1029.      * @return Asset[]
  1030.      */
  1031.     public function getChildren()
  1032.     {
  1033.         return [];
  1034.     }
  1036.     /**
  1037.      * @throws FilesystemException
  1038.      */
  1039.     private function deletePhysicalFile()
  1040.     {
  1041.         $storage = Storage::get('asset');
  1042.         if ($this->getType() != 'folder') {
  1043.             $storage->delete($this->getRealFullPath());
  1044.         } else {
  1045.             $storage->deleteDirectory($this->getRealFullPath());
  1046.         }
  1047.     }
  1049.     /**
  1050.      * {@inheritdoc}
  1051.      */
  1052.     public function delete(bool $isNested = false)
  1053.     {
  1054.         if ($this->getId() == 1) {
  1055.             throw new Exception('root-node cannot be deleted');
  1056.         }
  1058.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::PRE_DELETE);
  1060.         $this->beginTransaction();
  1062.         try {
  1063.             $this->closeStream();
  1065.             // remove children
  1066.             if ($this->hasChildren()) {
  1067.                 foreach ($this->getChildren() as $child) {
  1068.                     $child->delete(true);
  1069.                 }
  1070.             }
  1072.             // Dispatch Symfony Message Bus to delete versions
  1073.             Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1074.                 new VersionDeleteMessage(Service::getElementType($this), $this->getId())
  1075.             );
  1077.             // remove all properties
  1078.             $this->getDao()->deleteAllProperties();
  1080.             // remove all tasks
  1081.             $this->getDao()->deleteAllTasks();
  1083.             // remove dependencies
  1084.             $d = $this->getDependencies();
  1085.             $d->cleanAllForElement($this);
  1087.             // remove from resource
  1088.             $this->getDao()->delete();
  1090.             $this->commit();
  1092.             // remove file on filesystem
  1093.             if (!$isNested) {
  1094.                 $fullPath = $this->getRealFullPath();
  1095.                 if ($fullPath != '/..' && !strpos($fullPath,
  1096.                     '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1097.                     $this->deletePhysicalFile();
  1098.                 }
  1099.             }
  1101.             $this->clearThumbnails(true);
  1103.             //remove target parent folder preview thumbnails
  1104.             $this->clearFolderThumbnails($this);
  1105.         } catch (Exception $e) {
  1106.             try {
  1107.                 $this->rollBack();
  1108.             } catch (Exception $er) {
  1109.                 // PDO adapter throws exceptions if rollback fails
  1110.                 Logger::info((string) $er);
  1111.             }
  1113.             $failureEvent = new AssetEvent($this);
  1114.             $failureEvent->setArgument('exception', $e);
  1115.             $this->dispatchEvent($failureEvent, AssetEvents::POST_DELETE_FAILURE);
  1116.             Logger::crit((string) $e);
  1118.             throw $e;
  1119.         }
  1121.         // empty asset cache
  1122.         $this->clearDependentCache();
  1124.         // clear asset from registry
  1125.         RuntimeCache::set(self::getCacheKey($this->getId()), null);
  1127.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::POST_DELETE);
  1128.     }
  1130.     /**
  1131.      * {@inheritdoc}
  1132.      */
  1133.     public function clearDependentCache($additionalTags = [])
  1134.     {
  1135.         try {
  1136.             $tags = [$this->getCacheTag(), 'asset_properties', 'output'];
  1137.             $tags = array_merge($tags, $additionalTags);
  1139.             Cache::clearTags($tags);
  1140.         } catch (Exception $e) {
  1141.             Logger::crit((string) $e);
  1142.         }
  1143.     }
  1145.     /**
  1146.      * @return string|null
  1147.      */
  1148.     public function getFilename()
  1149.     {
  1150.         return $this->filename;
  1151.     }
  1153.     /**
  1154.      * {@inheritdoc}
  1155.      */
  1156.     public function getKey()
  1157.     {
  1158.         return $this->getFilename();
  1159.     }
  1161.     /**
  1162.      * {@inheritdoc}
  1163.      */
  1164.     public function getType()
  1165.     {
  1166.         return $this->type;
  1167.     }
  1169.     /**
  1170.      * @param string $filename
  1171.      *
  1172.      * @return $this
  1173.      */
  1174.     public function setFilename($filename)
  1175.     {
  1176.         $this->filename = (string)$filename;
  1178.         return $this;
  1179.     }
  1181.     /**
  1182.      * {@inheritdoc}
  1183.      */
  1184.     public function setKey($key)
  1185.     {
  1186.         return $this->setFilename($key);
  1187.     }
  1189.     /**
  1190.      * @param string $type
  1191.      *
  1192.      * @return $this
  1193.      */
  1194.     public function setType($type)
  1195.     {
  1196.         $this->type = (string)$type;
  1198.         return $this;
  1199.     }
  1201.     /**
  1202.      * @return string|false
  1203.      */
  1204.     public function getData()
  1205.     {
  1206.         $stream = $this->getStream();
  1207.         if ($stream) {
  1208.             return stream_get_contents($stream);
  1209.         }
  1211.         return '';
  1212.     }
  1214.     /**
  1215.      * @param mixed $data
  1216.      *
  1217.      * @return $this
  1218.      */
  1219.     public function setData($data)
  1220.     {
  1221.         $handle = tmpfile();
  1222.         fwrite($handle, $data);
  1223.         $this->setStream($handle);
  1225.         return $this;
  1226.     }
  1228.     /**
  1229.      * @return resource|null
  1230.      */
  1231.     public function getStream()
  1232.     {
  1233.         if ($this->stream) {
  1234.             if (get_resource_type($this->stream) !== 'stream') {
  1235.                 $this->stream = null;
  1236.             } elseif (!@rewind($this->stream)) {
  1237.                 $this->stream = null;
  1238.             }
  1239.         }
  1241.         if (!$this->stream && $this->getType() !== 'folder') {
  1242.             try {
  1243.                 $this->stream = Storage::get('asset')->readStream($this->getRealFullPath());
  1244.             } catch (Exception $e) {
  1245.                 $this->stream = tmpfile();
  1246.             }
  1247.         }
  1249.         return $this->stream;
  1250.     }
  1252.     /**
  1253.      * @param resource|null $stream
  1254.      *
  1255.      * @return $this
  1256.      */
  1257.     public function setStream($stream)
  1258.     {
  1259.         // close existing stream
  1260.         if ($stream !== $this->stream) {
  1261.             $this->closeStream();
  1262.         }
  1264.         if (is_resource($stream)) {
  1265.             $this->setDataChanged();
  1266.             $this->setDataModificationDate(time());
  1267.             $this->stream = $stream;
  1269.             $isRewindable = @rewind($this->stream);
  1271.             if (!$isRewindable) {
  1272.                 $tempFile = $this->getLocalFileFromStream($this->stream);
  1273.                 $dest = fopen($tempFile, 'rb', false, File::getContext());
  1274.                 $this->stream = $dest;
  1275.             }
  1276.         } elseif (is_null($stream)) {
  1277.             $this->stream = null;
  1278.         }
  1280.         return $this;
  1281.     }
  1283.     private function closeStream()
  1284.     {
  1285.         if (is_resource($this->stream)) {
  1286.             @fclose($this->stream);
  1287.             $this->stream = null;
  1288.         }
  1289.     }
  1291.     /**
  1292.      * @return bool
  1293.      */
  1294.     public function getDataChanged()
  1295.     {
  1296.         return $this->dataChanged;
  1297.     }
  1299.     /**
  1300.      * @param bool $changed
  1301.      *
  1302.      * @return $this
  1303.      */
  1304.     public function setDataChanged($changed = true)
  1305.     {
  1306.         $this->dataChanged = $changed;
  1308.         return $this;
  1309.     }
  1311.     /**
  1312.      * {@inheritdoc}
  1313.      */
  1314.     public function getVersions()
  1315.     {
  1316.         if ($this->versions === null) {
  1317.             $this->setVersions($this->getDao()->getVersions());
  1318.         }
  1320.         return $this->versions;
  1321.     }
  1323.     /**
  1324.      * @param Version[] $versions
  1325.      *
  1326.      * @return $this
  1327.      */
  1328.     public function setVersions($versions)
  1329.     {
  1330.         $this->versions = $versions;
  1332.         return $this;
  1333.     }
  1335.     /**
  1336.      * @internal
  1337.      *
  1338.      * @param bool $keep whether to delete this file on shutdown or not
  1339.      *
  1340.      * @return string
  1341.      *
  1342.      * @throws Exception
  1343.      */
  1344.     public function getTemporaryFile(bool $keep = false)
  1345.     {
  1346.         return self::getTemporaryFileFromStream($this->getStream(), $keep);
  1347.     }
  1349.     /**
  1350.      * @internal
  1351.      *
  1352.      * @return string
  1353.      *
  1354.      * @throws Exception
  1355.      */
  1356.     public function getLocalFile()
  1357.     {
  1358.         return self::getLocalFileFromStream($this->getStream());
  1359.     }
  1361.     /**
  1362.      * @param string $key
  1363.      * @param mixed $value
  1364.      *
  1365.      * @return $this
  1366.      */
  1367.     public function setCustomSetting($key, $value)
  1368.     {
  1369.         $this->customSettings[$key] = $value;
  1371.         return $this;
  1372.     }
  1374.     /**
  1375.      * @param string $key
  1376.      *
  1377.      * @return mixed
  1378.      */
  1379.     public function getCustomSetting($key)
  1380.     {
  1381.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1382.             return $this->customSettings[$key];
  1383.         }
  1385.         return null;
  1386.     }
  1388.     /**
  1389.      * @param string $key
  1390.      */
  1391.     public function removeCustomSetting($key)
  1392.     {
  1393.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1394.             unset($this->customSettings[$key]);
  1395.         }
  1396.     }
  1398.     /**
  1399.      * @return array
  1400.      */
  1401.     public function getCustomSettings()
  1402.     {
  1403.         return $this->customSettings;
  1404.     }
  1406.     /**
  1407.      * @param mixed $customSettings
  1408.      *
  1409.      * @return $this
  1410.      */
  1411.     public function setCustomSettings($customSettings)
  1412.     {
  1413.         if (is_string($customSettings)) {
  1414.             $customSettings = Serialize::unserialize($customSettings);
  1415.         }
  1417.         if ($customSettings instanceof stdClass) {
  1418.             $customSettings = (array)$customSettings;
  1419.         }
  1421.         if (!is_array($customSettings)) {
  1422.             $customSettings = [];
  1423.         }
  1425.         $this->customSettings = $customSettings;
  1427.         return $this;
  1428.     }
  1430.     /**
  1431.      * @return string|null
  1432.      */
  1433.     public function getMimeType()
  1434.     {
  1435.         return $this->mimetype;
  1436.     }
  1438.     /**
  1439.      * @param string $mimetype
  1440.      *
  1441.      * @return $this
  1442.      */
  1443.     public function setMimeType($mimetype)
  1444.     {
  1445.         $this->mimetype = (string)$mimetype;
  1447.         return $this;
  1448.     }
  1450.     /**
  1451.      * @param array $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1452.      *
  1453.      * @return $this
  1454.      *
  1455.      * @internal
  1456.      *
  1457.      */
  1458.     public function setMetadataRaw($metadata)
  1459.     {
  1460.         $this->metadata = $metadata;
  1461.         if ($this->metadata) {
  1462.             $this->setHasMetaData(true);
  1463.         }
  1465.         return $this;
  1466.     }
  1468.     /**
  1469.      * @param array[]|stdClass[] $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1470.      *
  1471.      * @return $this
  1472.      */
  1473.     public function setMetadata($metadata)
  1474.     {
  1475.         $this->metadata = [];
  1476.         $this->setHasMetaData(false);
  1477.         if (!empty($metadata)) {
  1478.             foreach ((array)$metadata as $metaItem) {
  1479.                 $metaItem = (array)$metaItem; // also allow object with appropriate keys
  1480.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1481.             }
  1482.         }
  1484.         return $this;
  1485.     }
  1487.     /**
  1488.      * @return bool
  1489.      */
  1490.     public function getHasMetaData()
  1491.     {
  1492.         return $this->hasMetaData;
  1493.     }
  1495.     /**
  1496.      * @param bool $hasMetaData
  1497.      *
  1498.      * @return $this
  1499.      */
  1500.     public function setHasMetaData($hasMetaData)
  1501.     {
  1502.         $this->hasMetaData = (bool)$hasMetaData;
  1504.         return $this;
  1505.     }
  1507.     /**
  1508.      * @param string $name
  1509.      * @param string $type can be "asset", "checkbox", "date", "document", "input", "object", "select" or "textarea"
  1510.      * @param mixed $data
  1511.      * @param string|null $language
  1512.      *
  1513.      * @return $this
  1514.      */
  1515.     public function addMetadata($name, $type, $data = null, $language = null)
  1516.     {
  1517.         if ($name && $type) {
  1518.             $tmp = [];
  1519.             $name = str_replace('~', '---', $name);
  1520.             if (!is_array($this->metadata)) {
  1521.                 $this->metadata = [];
  1522.             }
  1524.             foreach ($this->metadata as $item) {
  1525.                 if ($item['name'] != $name || $language != $item['language']) {
  1526.                     $tmp[] = $item;
  1527.                 }
  1528.             }
  1530.             $item = [
  1531.                 'name' => $name,
  1532.                 'type' => $type,
  1533.                 'data' => $data,
  1534.                 'language' => $language,
  1535.             ];
  1537.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1539.             try {
  1540.                 /** @var Data $instance */
  1541.                 $instance = $loader->build($item['type']);
  1542.                 $transformedData = $instance->transformSetterData($data, $item);
  1543.                 $item['data'] = $transformedData;
  1544.             } catch (UnsupportedException $e) {
  1545.             }
  1547.             $tmp[] = $item;
  1548.             $this->metadata = $tmp;
  1550.             $this->setHasMetaData(true);
  1551.         }
  1553.         return $this;
  1554.     }
  1556.     /**
  1557.      * @param string $name
  1558.      * @param string|null $language
  1559.      *
  1560.      * @return $this
  1561.      */
  1562.     public function removeMetadata(string $name, ?string $language = null)
  1563.     {
  1564.         if ($name) {
  1565.             $tmp = [];
  1566.             $name = str_replace('~', '---', $name);
  1567.             if (!is_array($this->metadata)) {
  1568.                 $this->metadata = [];
  1569.             }
  1571.             foreach ($this->metadata as $item) {
  1572.                 if ($item['name'] === $name && ($language == $item['language'] || $language === '*')) {
  1573.                     continue;
  1574.                 }
  1575.                 $tmp[] = $item;
  1576.             }
  1578.             $this->metadata = $tmp;
  1579.             $this->setHasMetaData(!empty($this->metadata));
  1580.         }
  1582.         return $this;
  1583.     }
  1585.     /**
  1586.      * @param string|null $name
  1587.      * @param string|null $language
  1588.      * @param bool $strictMatch
  1589.      * @param bool $raw
  1590.      *
  1591.      * @return array|string|null
  1592.      */
  1593.     public function getMetadata($name = null, $language = null, $strictMatch = false, $raw = false)
  1594.     {
  1595.         $preEvent = new AssetEvent($this);
  1596.         $preEvent->setArgument('metadata', $this->metadata);
  1597.         $this->dispatchEvent($preEvent, AssetEvents::PRE_GET_METADATA);
  1598.         $this->metadata = $preEvent->getArgument('metadata');
  1600.         $convert = function ($metaData) {
  1601.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1602.             $transformedData = $metaData['data'];
  1604.             try {
  1605.                 /** @var Data $instance */
  1606.                 $instance = $loader->build($metaData['type']);
  1607.                 $transformedData = $instance->transformGetterData($metaData['data'], $metaData);
  1608.             } catch (UnsupportedException $e) {
  1609.                 Logger::error((string) $e);
  1610.             }
  1612.             return $transformedData;
  1613.         };
  1615.         if ($name) {
  1616.             $result = null;
  1617.             if ($language === null) {
  1618.                 $language = Pimcore::getContainer()->get(LocaleServiceInterface::class)->findLocale();
  1619.             }
  1621.             $data = null;
  1622.             foreach ($this->metadata as $md) {
  1623.                 if ($md['name'] == $name) {
  1624.                     if ($language == $md['language'] || (empty($md['language']) && !$strictMatch)) {
  1625.                         $data = $md;
  1627.                         break;
  1628.                     }
  1629.                 }
  1630.             }
  1632.             if ($data) {
  1633.                 $result = $raw ? $data : $convert($data);
  1634.             }
  1636.             return $result;
  1637.         }
  1639.         $metaData = $this->getObjectVar('metadata');
  1640.         $result = [];
  1641.         if (is_array($metaData)) {
  1642.             foreach ($metaData as $md) {
  1643.                 $md = (array)$md;
  1644.                 if (!$raw) {
  1645.                     $md['data'] = $convert($md);
  1646.                 }
  1647.                 $result[] = $md;
  1648.             }
  1649.         }
  1651.         return $result;
  1652.     }
  1654.     /**
  1655.      * @param bool $formatted
  1656.      * @param int $precision
  1657.      *
  1658.      * @return string|int
  1659.      */
  1660.     public function getFileSize($formatted = false, $precision = 2)
  1661.     {
  1662.         try {
  1663.             $bytes = Storage::get('asset')->fileSize($this->getRealFullPath());
  1664.         } catch (Exception $e) {
  1665.             $bytes = 0;
  1666.         }
  1668.         if ($formatted) {
  1669.             return formatBytes($bytes, $precision);
  1670.         }
  1672.         return $bytes;
  1673.     }
  1675.     /**
  1676.      * @return Asset|null
  1677.      */
  1678.     public function getParent() /** : ?Asset */
  1679.     {
  1680.         $parent = parent::getParent();
  1682.         return $parent instanceof Asset ? $parent : null;
  1683.     }
  1685.     /**
  1686.      * @param Asset|null $parent
  1687.      *
  1688.      * @return $this
  1689.      */
  1690.     public function setParent($parent)
  1691.     {
  1692.         $this->parent = $parent;
  1693.         if ($parent instanceof Asset) {
  1694.             $this->parentId = $parent->getId();
  1695.         }
  1697.         return $this;
  1698.     }
  1700.     public function __wakeup()
  1701.     {
  1702.         if ($this->isInDumpState()) {
  1703.             // set current parent and path, this is necessary because the serialized data can have a different path than the original element (element was moved)
  1704.             $originalElement = Asset::getById($this->getId());
  1705.             if ($originalElement) {
  1706.                 $this->setParentId($originalElement->getParentId());
  1707.                 $this->setPath($originalElement->getRealPath());
  1708.             }
  1709.         }
  1711.         if ($this->isInDumpState() && $this->properties !== null) {
  1712.             $this->renewInheritedProperties();
  1713.         }
  1715.         $this->setInDumpState(false);
  1716.     }
  1718.     public function __destruct()
  1719.     {
  1720.         // close open streams
  1721.         $this->closeStream();
  1722.     }
  1724.     /**
  1725.      * {@inheritdoc}
  1726.      */
  1727.     protected function resolveDependencies(): array
  1728.     {
  1729.         $dependencies = [parent::resolveDependencies()];
  1731.         if ($this->hasMetaData) {
  1732.             $loader = Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1734.             foreach ($this->getMetadata() as $metaData) {
  1735.                 if (!empty($metaData['data'])) {
  1736.                     /** @var ElementInterface $elementData */
  1737.                     $elementData = $metaData['data'];
  1738.                     $elementType = $metaData['type'];
  1740.                     try {
  1741.                         /** @var DataDefinitionInterface $implementation */
  1742.                         $implementation = $loader->build($elementType);
  1743.                         $dependencies[] = $implementation->resolveDependencies($elementData, $metaData);
  1744.                     } catch (UnsupportedException $e) {
  1745.                     }
  1746.                 }
  1747.             }
  1748.         }
  1750.         return array_merge(...$dependencies);
  1751.     }
  1753.     public function __clone()
  1754.     {
  1755.         parent::__clone();
  1756.         $this->parent = null;
  1757.         $this->versions = null;
  1758.         $this->hasSiblings = null;
  1759.         $this->siblings = null;
  1760.         $this->scheduledTasks = null;
  1761.         $this->closeStream();
  1762.     }
  1764.     /**
  1765.      * @param bool $force
  1766.      */
  1767.     public function clearThumbnails($force = false)
  1768.     {
  1769.         if ($this->getDataChanged() || $force) {
  1770.             foreach (['thumbnail', 'asset_cache'] as $storageName) {
  1771.                 $storage = Storage::get($storageName);
  1772.                 $storage->deleteDirectory($this->getRealPath() . $this->getId());
  1773.             }
  1775.             $this->getDao()->deleteFromThumbnailCache();
  1776.         }
  1777.     }
  1779.     /**
  1780.      * @param FilesystemOperator $storage
  1781.      * @param string $oldPath
  1782.      * @param string|null $newPath
  1783.      *
  1784.      * @throws FilesystemException
  1785.      */
  1786.     private function updateChildPaths(FilesystemOperator $storage, string $oldPath, string $newPath = null)
  1787.     {
  1788.         if ($newPath === null) {
  1789.             $newPath = $this->getRealFullPath();
  1790.         }
  1792.         try {
  1793.             $children = $storage->listContents($oldPath, true);
  1794.             foreach ($children as $child) {
  1795.                 if ($child['type'] === 'file') {
  1796.                     $src  = $child['path'];
  1797.                     $dest = str_replace($oldPath, $newPath, '/' . $src);
  1798.                     $storage->move($src, $dest);
  1799.                 }
  1800.             }
  1802.             $storage->deleteDirectory($oldPath);
  1803.         } catch (UnableToMoveFile $e) {
  1804.             // noting to do
  1805.         }
  1806.     }
  1808.     /**
  1809.      * @param string $oldPath
  1810.      *
  1811.      * @throws FilesystemException
  1812.      */
  1813.     private function relocateThumbnails(string $oldPath)
  1814.     {
  1815.         if ($this instanceof Folder) {
  1816.             $oldThumbnailsPath = $oldPath;
  1817.             $newThumbnailsPath = $this->getRealFullPath();
  1818.         } else {
  1819.             $oldThumbnailsPath = dirname($oldPath) . '/' . $this->getId();
  1820.             $newThumbnailsPath = $this->getRealPath() . $this->getId();
  1821.         }
  1823.         if ($oldThumbnailsPath === $newThumbnailsPath) {
  1824.             //path is equal, probably file name changed - so clear all thumbnails
  1825.             $this->clearThumbnails(true);
  1826.         } else {
  1827.             //remove source parent folder preview thumbnails
  1828.             $sourceFolder = Asset::getByPath(dirname($oldPath));
  1829.             if ($sourceFolder) {
  1830.                 $this->clearFolderThumbnails($sourceFolder);
  1831.             }
  1833.             //remove target parent folder preview thumbnails
  1834.             $this->clearFolderThumbnails($this);
  1836.             foreach (['thumbnail', 'asset_cache'] as $storageName) {
  1837.                 $storage = Storage::get($storageName);
  1839.                 try {
  1840.                     $storage->move($oldThumbnailsPath, $newThumbnailsPath);
  1841.                 } catch (UnableToMoveFile $e) {
  1842.                     //update children, if unable to move parent
  1843.                     $this->updateChildPaths($storage, $oldPath);
  1844.                 }
  1845.             }
  1846.         }
  1847.     }
  1849.     /**
  1850.      * @param Asset $asset
  1851.      */
  1852.     private function clearFolderThumbnails(Asset $asset): void
  1853.     {
  1854.         do {
  1855.             if ($asset instanceof Folder) {
  1856.                 $asset->clearThumbnails(true);
  1857.             }
  1859.             $asset = $asset->getParent();
  1860.         } while ($asset !== null);
  1861.     }
  1863.     /**
  1864.      * @param string $name
  1865.      */
  1866.     public function clearThumbnail($name)
  1867.     {
  1868.         try {
  1869.             Storage::get('thumbnail')->deleteDirectory($this->getRealPath().'/'.$this->getId().'/image-thumb__'.$this->getId().'__'.$name);
  1870.             $this->getDao()->deleteFromThumbnailCache($name);
  1871.         } catch (Exception $e) {
  1872.             // noting to do
  1873.         }
  1874.     }
  1876.     /**
  1877.      * @internal
  1878.      */
  1879.     protected function addToUpdateTaskQueue(): void
  1880.     {
  1881.         Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1882.             new AssetUpdateTasksMessage($this->getId())
  1883.         );
  1884.     }
  1886.     /**
  1887.      * @return string
  1888.      */
  1889.     public function getFrontendPath(): string
  1890.     {
  1891.         $path = $this->getFullPath();
  1892.         if (!\preg_match('@^(https?|data):@', $path)) {
  1893.             $path = \Pimcore\Tool::getHostUrl() . $path;
  1894.         }
  1896.         return $path;
  1897.     }
  1899.     /**
  1900.      * @internal
  1901.      *
  1902.      * @throws Exception
  1903.      */
  1904.     public function addThumbnailFileToCache(string $localFile, string $filename, ThumbnailConfig $config): void
  1905.     {
  1906.         //try to get the dimensions with getimagesize because it is much faster than e.g. the Imagick-Adapter
  1907.         if ($imageSize = @getimagesize($localFile)) {
  1908.             $dimensions = [
  1909.                 'width' => $imageSize[0],
  1910.                 'height' => $imageSize[1],
  1911.             ];
  1912.         } else {
  1913.             //fallback to Default Adapter
  1914.             $image = \Pimcore\Image::getInstance();
  1915.             if ($image->load($localFile)) {
  1916.                 $dimensions = [
  1917.                     'width' => $image->getWidth(),
  1918.                     'height' => $image->getHeight(),
  1919.                 ];
  1920.             }
  1921.         }
  1923.         if (!empty($dimensions)) {
  1924.             $this->getDao()->addToThumbnailCache(
  1925.                 $config->getName(),
  1926.                 $filename,
  1927.                 filesize($localFile),
  1928.                 $dimensions['width'],
  1929.                 $dimensions['height']
  1930.             );
  1931.         }
  1932.     }
  1933. }