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

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 League\Flysystem\FilesystemOperator;
  20. use League\Flysystem\StorageAttributes;
  21. use League\Flysystem\UnableToMoveFile;
  22. use Pimcore\Event\AssetEvents;
  23. use Pimcore\Event\FrontendEvents;
  24. use Pimcore\Event\Model\AssetEvent;
  25. use Pimcore\File;
  26. use Pimcore\Helper\TemporaryFileHelperTrait;
  27. use Pimcore\Loader\ImplementationLoader\Exception\UnsupportedException;
  28. use Pimcore\Localization\LocaleServiceInterface;
  29. use Pimcore\Logger;
  30. use Pimcore\Messenger\AssetUpdateTasksMessage;
  31. use Pimcore\Messenger\VersionDeleteMessage;
  32. use Pimcore\Model\Asset\Listing;
  33. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\Data;
  34. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\DataDefinitionInterface;
  35. use Pimcore\Model\Element\ElementInterface;
  36. use Pimcore\Model\Element\Service;
  37. use Pimcore\Model\Element\Traits\ScheduledTasksTrait;
  38. use Pimcore\Model\Element\ValidationException;
  39. use Pimcore\Model\Exception\NotFoundException;
  40. use Pimcore\Tool;
  41. use Pimcore\Tool\Storage;
  42. use Symfony\Component\EventDispatcher\GenericEvent;
  43. use Symfony\Component\Mime\MimeTypes;
  45. /**
  46.  * @method \Pimcore\Model\Asset\Dao getDao()
  47.  * @method bool __isBasedOnLatestData()
  48.  * @method int getChildAmount($user = null)
  49.  * @method string|null getCurrentFullPath()
  50.  */
  51. class Asset extends Element\AbstractElement
  52. {
  53.     use ScheduledTasksTrait;
  54.     use TemporaryFileHelperTrait;
  56.     /**
  57.      * all possible types of assets
  58.      *
  59.      * @internal
  60.      *
  61.      * @var array
  62.      */
  63.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  65.     /**
  66.      * @internal
  67.      *
  68.      * @var int|null
  69.      */
  70.     protected $id;
  72.     /**
  73.      * @internal
  74.      *
  75.      * @var int|null
  76.      */
  77.     protected $parentId;
  79.     /**
  80.      * @internal
  81.      *
  82.      * @var self|null
  83.      */
  84.     protected $parent;
  86.     /**
  87.      * @internal
  88.      *
  89.      * @var string
  90.      */
  91.     protected $type = '';
  93.     /**
  94.      * @internal
  95.      *
  96.      * @var string|null
  97.      */
  98.     protected $filename;
  100.     /**
  101.      * @internal
  102.      *
  103.      * @var string|null
  104.      */
  105.     protected $path;
  107.     /**
  108.      * @internal
  109.      *
  110.      * @var string|null
  111.      */
  112.     protected $mimetype;
  114.     /**
  115.      * @internal
  116.      *
  117.      * @var int|null
  118.      */
  119.     protected $creationDate;
  121.     /**
  122.      * @internal
  123.      *
  124.      * @var int|null
  125.      */
  126.     protected $modificationDate;
  128.     /**
  129.      * @internal
  130.      *
  131.      * @var resource|null
  132.      */
  133.     protected $stream;
  135.     /**
  136.      * @internal
  137.      *
  138.      * @var int|null
  139.      */
  140.     protected ?int $userOwner = null;
  142.     /**
  143.      * @internal
  144.      *
  145.      * @var int|null
  146.      */
  147.     protected ?int $userModification = null;
  149.     /**
  150.      * @internal
  151.      *
  152.      * @var array
  153.      */
  154.     protected $properties = null;
  156.     /**
  157.      * @internal
  158.      *
  159.      * @var array|null
  160.      */
  161.     protected $versions = null;
  163.     /**
  164.      * @internal
  165.      *
  166.      * @var array
  167.      */
  168.     protected $metadata = [];
  170.     /**
  171.      * @internal
  172.      *
  173.      * enum('self','propagate') nullable
  174.      *
  175.      * @var string|null
  176.      */
  177.     protected $locked;
  179.     /**
  180.      * List of some custom settings  [key] => value
  181.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  182.      *
  183.      * @internal
  184.      *
  185.      * @var array
  186.      */
  187.     protected $customSettings = [];
  189.     /**
  190.      * @internal
  191.      *
  192.      * @var bool
  193.      */
  194.     protected $hasMetaData = false;
  196.     /**
  197.      * @internal
  198.      *
  199.      * @var array|null
  200.      */
  201.     protected $siblings;
  203.     /**
  204.      * @internal
  205.      *
  206.      * @var bool|null
  207.      */
  208.     protected $hasSiblings;
  210.     /**
  211.      * @internal
  212.      *
  213.      * @var bool
  214.      */
  215.     protected $dataChanged = false;
  217.     /**
  218.      * @internal
  219.      *
  220.      * @var int
  221.      */
  222.     protected $versionCount = 0;
  224.     /**
  225.      *
  226.      * @return array
  227.      */
  228.     public static function getTypes()
  229.     {
  230.         return self::$types;
  231.     }
  233.     /**
  234.      * Static helper to get an asset by the passed path
  235.      *
  236.      * @param string $path
  237.      * @param bool $force
  238.      *
  239.      * @return static|null
  240.      */
  241.     public static function getByPath($path, $force = false)
  242.     {
  243.         if (!$path) {
  244.             return null;
  245.         }
  247.         $path = Element\Service::correctPath($path);
  249.         try {
  250.             $asset = new Asset();
  251.             $asset->getDao()->getByPath($path);
  253.             return static::getById($asset->getId(), $force);
  254.         } catch (NotFoundException $e) {
  255.             return null;
  256.         }
  257.     }
  259.     /**
  260.      * @internal
  261.      *
  262.      * @param Asset $asset
  263.      *
  264.      * @return bool
  265.      */
  266.     protected static function typeMatch(Asset $asset)
  267.     {
  268.         $staticType = static::class;
  269.         if ($staticType !== Asset::class) {
  270.             if (!$asset instanceof $staticType) {
  271.                 return false;
  272.             }
  273.         }
  275.         return true;
  276.     }
  278.     /**
  279.      * @param int $id
  280.      * @param bool $force
  281.      *
  282.      * @return static|null
  283.      */
  284.     public static function getById($id, $force = false)
  285.     {
  286.         if (!is_numeric($id) || $id < 1) {
  287.             return null;
  288.         }
  290.         $id = (int)$id;
  291.         $cacheKey = self::getCacheKey($id);
  293.         if (!$force && \Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  294.             $asset = \Pimcore\Cache\Runtime::get($cacheKey);
  295.             if ($asset && static::typeMatch($asset)) {
  296.                 return $asset;
  297.             }
  298.         }
  300.         if ($force || !($asset = \Pimcore\Cache::load($cacheKey))) {
  301.             $asset = new Asset();
  303.             try {
  304.                 $asset->getDao()->getById($id);
  305.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  307.                 /** @var Asset $asset */
  308.                 $asset = self::getModelFactory()->build($className);
  309.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  310.                 $asset->getDao()->getById($id);
  311.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  313.                 $asset->resetDirtyMap();
  315.                 \Pimcore\Cache::save($asset, $cacheKey);
  316.             } catch (NotFoundException $e) {
  317.                 return null;
  318.             }
  319.         } else {
  320.             \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  321.         }
  323.         if (!$asset || !static::typeMatch($asset)) {
  324.             return null;
  325.         }
  327.         return $asset;
  328.     }
  330.     /**
  331.      * @param int $parentId
  332.      * @param array $data
  333.      * @param bool $save
  334.      *
  335.      * @return Asset
  336.      */
  337.     public static function create($parentId, $data = [], $save = true)
  338.     {
  340.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  341.         // (tree) is generated immediately after creating an image
  342.         $class = Asset::class;
  343.         if (array_key_exists('filename', $data) && (array_key_exists('data', $data) || array_key_exists('sourcePath', $data) || array_key_exists('stream', $data))) {
  344.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  345.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($data['filename']);
  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;
  424.                 throw new ValidationException("<p>Image dimensions of <em>{$data['filename']}</em> are too large.</p>
  425. <p>Max size: <code>{$mp}</code> <abbr title='Million pixels'>Megapixels</abbr></p>
  426. <p>Suggestion: resize to <code>{$suggestion_0}&times;{$suggestion_1}</code> pixels or smaller.</p>");
  427.             }
  428.         }
  429.     }
  431.     /**
  432.      * @param array $config
  433.      *
  434.      * @return mixed
  435.      *
  436.      * @throws \Exception
  437.      */
  438.     public static function getList($config = [])
  439.     {
  440.         if (!\is_array($config)) {
  441.             throw new \Exception('Unable to initiate list class - please provide valid configuration array');
  442.         }
  444.         $listClass = Listing::class;
  446.         $list = self::getModelFactory()->build($listClass);
  447.         $list->setValues($config);
  449.         return $list;
  450.     }
  452.     /**
  453.      * @deprecated will be removed in Pimcore 11
  454.      *
  455.      * @param array $config
  456.      *
  457.      * @return int total count
  458.      */
  459.     public static function getTotalCount($config = [])
  460.     {
  461.         $list = static::getList($config);
  462.         $count = $list->getTotalCount();
  464.         return $count;
  465.     }
  467.     /**
  468.      * @internal
  469.      *
  470.      * @param string $mimeType
  471.      * @param string $filename
  472.      *
  473.      * @return string
  474.      */
  475.     public static function getTypeFromMimeMapping($mimeType, $filename)
  476.     {
  477.         if ($mimeType == 'directory') {
  478.             return 'folder';
  479.         }
  481.         $type = null;
  483.         $mappings = [
  484.             'unknown' => ["/\.stp$/"],
  485.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/", "/\.wmf$/", '/photoshop/'],
  486.             'text' => ['/text/', '/xml$/', '/\.json$/'],
  487.             'audio' => ['/audio/'],
  488.             'video' => ['/video/'],
  489.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  490.             'archive' => ['/zip/', '/tar/'],
  491.         ];
  493.         foreach ($mappings as $assetType => $patterns) {
  494.             foreach ($patterns as $pattern) {
  495.                 if (preg_match($pattern, $mimeType . ' .' . File::getFileExtension($filename))) {
  496.                     $type = $assetType;
  498.                     break;
  499.                 }
  500.             }
  502.             // break at first match
  503.             if ($type) {
  504.                 break;
  505.             }
  506.         }
  508.         if (!$type) {
  509.             $type = 'unknown';
  510.         }
  512.         return $type;
  513.     }
  515.     /**
  516.      * {@inheritdoc}
  517.      */
  518.     public function save()
  519.     {
  520.         // additional parameters (e.g. "versionNote" for the version note)
  521.         $params = [];
  522.         if (func_num_args() && is_array(func_get_arg(0))) {
  523.             $params = func_get_arg(0);
  524.         }
  526.         $isUpdate = false;
  527.         $differentOldPath = null;
  529.         try {
  530.             $preEvent = new AssetEvent($this, $params);
  532.             if ($this->getId()) {
  533.                 $isUpdate = true;
  534.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_UPDATE);
  535.             } else {
  536.                 $this->dispatchEvent($preEvent, AssetEvents::PRE_ADD);
  537.             }
  539.             $params = $preEvent->getArguments();
  541.             $this->correctPath();
  543.             $params['isUpdate'] = $isUpdate; // we need that in $this->update() for certain types (image, video, document)
  545.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  546.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  547.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  548.             $maxRetries = 5;
  549.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  550.                 $this->beginTransaction();
  552.                 try {
  553.                     if (!$isUpdate) {
  554.                         $this->getDao()->create();
  555.                     }
  557.                     // get the old path from the database before the update is done
  558.                     $oldPath = null;
  559.                     if ($isUpdate) {
  560.                         $oldPath = $this->getDao()->getCurrentFullPath();
  561.                     }
  563.                     $this->update($params);
  565.                     $storage = Storage::get('asset');
  566.                     // if the old path is different from the new path, update all children
  567.                     $updatedChildren = [];
  568.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  569.                         $differentOldPath = $oldPath;
  571.                         try {
  572.                             $storage->move($oldPath, $this->getRealFullPath());
  573.                         } catch (UnableToMoveFile $e) {
  574.                             //update children, if unable to move parent
  575.                             $this->updateChildPaths($storage, $oldPath);
  576.                         }
  578.                         $this->getDao()->updateWorkspaces();
  580.                         $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  581.                         $this->relocateThumbnails($oldPath);
  582.                     }
  584.                     // lastly create a new version if necessary
  585.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  586.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  587.                     if ($this->getType() != 'folder') {
  588.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  589.                     }
  591.                     $this->commit();
  593.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  594.                 } catch (\Exception $e) {
  595.                     try {
  596.                         $this->rollBack();
  597.                     } catch (\Exception $er) {
  598.                         // PDO adapter throws exceptions if rollback fails
  599.                         Logger::error($er);
  600.                     }
  602.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  603.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  604.                         $run = $retries + 1;
  605.                         $waitTime = rand(1, 5) * 100000; // microseconds
  606.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  608.                         usleep($waitTime); // wait specified time until we restart the transaction
  609.                     } else {
  610.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  611.                         throw $e;
  612.                     }
  613.                 }
  614.             }
  616.             $additionalTags = [];
  617.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  618.                 foreach ($updatedChildren as $assetId) {
  619.                     $tag = 'asset_' . $assetId;
  620.                     $additionalTags[] = $tag;
  622.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  623.                     \Pimcore\Cache\Runtime::set($tag, null);
  624.                 }
  625.             }
  626.             $this->clearDependentCache($additionalTags);
  628.             if ($this->getDataChanged()) {
  629.                 if (in_array($this->getType(), ['image', 'video', 'document'])) {
  630.                     $this->addToUpdateTaskQueue();
  631.                 }
  632.             }
  634.             $this->setDataChanged(false);
  636.             $postEvent = new AssetEvent($this, $params);
  637.             if ($isUpdate) {
  638.                 if ($differentOldPath) {
  639.                     $postEvent->setArgument('oldPath', $differentOldPath);
  640.                 }
  641.                 $this->dispatchEvent($postEvent, AssetEvents::POST_UPDATE);
  642.             } else {
  643.                 $this->dispatchEvent($postEvent, AssetEvents::POST_ADD);
  644.             }
  646.             return $this;
  647.         } catch (\Exception $e) {
  648.             $failureEvent = new AssetEvent($this, $params);
  649.             $failureEvent->setArgument('exception', $e);
  650.             if ($isUpdate) {
  651.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_UPDATE_FAILURE);
  652.             } else {
  653.                 $this->dispatchEvent($failureEvent, AssetEvents::POST_ADD_FAILURE);
  654.             }
  656.             throw $e;
  657.         }
  658.     }
  660.     /**
  661.      * @internal
  662.      *
  663.      * @throws \Exception
  664.      */
  665.     public function correctPath()
  666.     {
  667.         // set path
  668.         if ($this->getId() != 1) { // not for the root node
  670.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  671.                 throw new \Exception("invalid filename '" . $this->getKey() . "' for asset with id [ " . $this->getId() . ' ]');
  672.             }
  674.             if ($this->getParentId() == $this->getId()) {
  675.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  676.             }
  678.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  679.                 throw new \Exception('Cannot create asset called ".." or "."');
  680.             }
  682.             $parent = Asset::getById($this->getParentId());
  683.             if ($parent) {
  684.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  685.                 // that is currently in the parent asset (in memory), because this might have changed but wasn't not saved
  686.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  687.             } else {
  688.                 // parent document doesn't exist anymore, set the parent to to root
  689.                 $this->setParentId(1);
  690.                 $this->setPath('/');
  691.             }
  692.         } elseif ($this->getId() == 1) {
  693.             // some data in root node should always be the same
  694.             $this->setParentId(0);
  695.             $this->setPath('/');
  696.             $this->setFilename('');
  697.             $this->setType('folder');
  698.         }
  700.         // do not allow PHP and .htaccess files
  701.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  702.             $this->setFilename($this->getFilename() . '.txt');
  703.         }
  705.         if (mb_strlen($this->getFilename()) > 255) {
  706.             throw new \Exception('Filenames longer than 255 characters are not allowed');
  707.         }
  709.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  710.             $duplicate = Asset::getByPath($this->getRealFullPath());
  711.             if ($duplicate instanceof Asset && $duplicate->getId() != $this->getId()) {
  712.                 throw new \Exception('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  713.             }
  714.         }
  716.         $this->validatePathLength();
  717.     }
  719.     /**
  720.      * @internal
  721.      *
  722.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  723.      *
  724.      * @throws \Exception
  725.      */
  726.     protected function update($params = [])
  727.     {
  728.         $storage = Storage::get('asset');
  729.         $this->updateModificationInfos();
  731.         $path = $this->getRealFullPath();
  732.         $typeChanged = false;
  734.         if ($this->getType() != 'folder') {
  735.             if ($this->getDataChanged()) {
  736.                 $src = $this->getStream();
  738.                 if (!$storage->fileExists($path) || !stream_is_local($storage->readStream($path))) {
  739.                     // write stream directly if target file doesn't exist or if target is a remote storage
  740.                     // this is because we don't have hardlinks there, so we don't need to consider them (see below)
  741.                     $storage->writeStream($path, $src);
  742.                 } else {
  743.                     // We don't open a stream on existing files, because they could be possibly used by versions
  744.                     // using hardlinks, so it's safer to write them to a temp file first, so the inode and therefore
  745.                     // also the versioning information persists. Using the stream on the existing file would overwrite the
  746.                     // contents of the inode and therefore leads to wrong version data
  747.                     $pathInfo = pathinfo($this->getFilename());
  748.                     $tempFilePath = $this->getRealPath() . uniqid('temp_');
  749.                     if ($pathInfo['extension'] ?? false) {
  750.                         $tempFilePath .= '.' . $pathInfo['extension'];
  751.                     }
  753.                     $storage->writeStream($tempFilePath, $src);
  754.                     $storage->delete($path);
  755.                     $storage->move($tempFilePath, $path);
  756.                 }
  758.                 // delete old legacy file if exists
  759.                 $dbPath = $this->getDao()->getCurrentFullPath();
  760.                 if ($dbPath !== $path && $storage->fileExists($dbPath)) {
  761.                     $storage->delete($dbPath);
  762.                 }
  764.                 $this->closeStream(); // set stream to null, so that the source stream isn't used anymore after saving
  766.                 $mimeType = $storage->mimeType($path);
  767.                 $this->setMimeType($mimeType);
  769.                 // set type
  770.                 $type = self::getTypeFromMimeMapping($mimeType, $this->getFilename());
  771.                 if ($type != $this->getType()) {
  772.                     $this->setType($type);
  773.                     $typeChanged = true;
  774.                 }
  776.                 // not only check if the type is set but also if the implementation can be found
  777.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  778.                 if (!self::getModelFactory()->supports($className)) {
  779.                     throw new \Exception('unable to resolve asset implementation with type: ' . $this->getType());
  780.                 }
  781.             }
  782.         } else {
  783.             $storage->createDirectory($path);
  784.         }
  786.         if (!$this->getType()) {
  787.             $this->setType('unknown');
  788.         }
  790.         $this->postPersistData();
  792.         // save properties
  793.         $this->getProperties();
  794.         $this->getDao()->deleteAllProperties();
  795.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  796.             foreach ($this->getProperties() as $property) {
  797.                 if (!$property->getInherited()) {
  798.                     $property->setDao(null);
  799.                     $property->setCid($this->getId());
  800.                     $property->setCtype('asset');
  801.                     $property->setCpath($this->getRealFullPath());
  802.                     $property->save();
  803.                 }
  804.             }
  805.         }
  807.         // save dependencies
  808.         $d = new Dependency();
  809.         $d->setSourceType('asset');
  810.         $d->setSourceId($this->getId());
  812.         foreach ($this->resolveDependencies() as $requirement) {
  813.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  814.                 // dont't add a reference to yourself
  815.                 continue;
  816.             } else {
  817.                 $d->addRequirement($requirement['id'], $requirement['type']);
  818.             }
  819.         }
  820.         $d->save();
  822.         $this->getDao()->update();
  824.         //set asset to registry
  825.         $cacheKey = self::getCacheKey($this->getId());
  826.         \Pimcore\Cache\Runtime::set($cacheKey, $this);
  827.         if (static::class === Asset::class || $typeChanged) {
  828.             // get concrete type of asset
  829.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  830.             // the type (image, document, ...) depends on the mime-type
  831.             \Pimcore\Cache\Runtime::set($cacheKey, null);
  832.             Asset::getById($this->getId()); // call it to load it to the runtime cache again
  833.         }
  835.         $this->closeStream();
  836.     }
  838.     /**
  839.      * @internal
  840.      */
  841.     protected function postPersistData()
  842.     {
  843.         // hook for the save process, can be overwritten in implementations, such as Image
  844.     }
  846.     /**
  847.      * @param bool $setModificationDate
  848.      * @param bool $saveOnlyVersion
  849.      * @param string $versionNote version note
  850.      *
  851.      * @return null|Version
  852.      *
  853.      * @throws \Exception
  854.      */
  855.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  856.     {
  857.         try {
  858.             // hook should be also called if "save only new version" is selected
  859.             if ($saveOnlyVersion) {
  860.                 $event = new AssetEvent($this, [
  861.                     'saveVersionOnly' => true,
  862.                 ]);
  863.                 $this->dispatchEvent($event, AssetEvents::PRE_UPDATE);
  864.             }
  866.             // set date
  867.             if ($setModificationDate) {
  868.                 $this->setModificationDate(time());
  869.             }
  871.             // scheduled tasks are saved always, they are not versioned!
  872.             $this->saveScheduledTasks();
  874.             // create version
  875.             $version = null;
  877.             // only create a new version if there is at least 1 allowed
  878.             // or if saveVersion() was called directly (it's a newer version of the asset)
  879.             $assetsConfig = \Pimcore\Config::getSystemConfiguration('assets');
  880.             if ((is_null($assetsConfig['versions']['days'] ?? null) && is_null($assetsConfig['versions']['steps'] ?? null))
  881.                 || (!empty($assetsConfig['versions']['steps']))
  882.                 || !empty($assetsConfig['versions']['days'])
  883.                 || $setModificationDate) {
  884.                 $saveStackTrace = !($assetsConfig['versions']['disable_stack_trace'] ?? false);
  885.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion, $saveStackTrace);
  886.             }
  888.             // hook should be also called if "save only new version" is selected
  889.             if ($saveOnlyVersion) {
  890.                 $event = new AssetEvent($this, [
  891.                     'saveVersionOnly' => true,
  892.                 ]);
  893.                 $this->dispatchEvent($event, AssetEvents::POST_UPDATE);
  894.             }
  896.             return $version;
  897.         } catch (\Exception $e) {
  898.             $event = new AssetEvent($this, [
  899.                 'saveVersionOnly' => true,
  900.                 'exception' => $e,
  901.             ]);
  902.             $this->dispatchEvent($event, AssetEvents::POST_UPDATE_FAILURE);
  904.             throw $e;
  905.         }
  906.     }
  908.     /**
  909.      * {@inheritdoc}
  910.      */
  911.     public function getFullPath()
  912.     {
  913.         $path = $this->getPath() . $this->getFilename();
  915.         if (Tool::isFrontend()) {
  916.             return $this->getFrontendFullPath();
  917.         }
  919.         return $path;
  920.     }
  922.     /**
  923.      * Returns the full path of the asset (listener aware)
  924.      *
  925.      * @return string
  926.      *
  927.      * @internal
  928.      */
  929.     public function getFrontendFullPath()
  930.     {
  931.         $path = $this->getPath() . $this->getFilename();
  932.         $path = urlencode_ignore_slash($path);
  934.         $prefix = \Pimcore::getContainer()->getParameter('pimcore.config')['assets']['frontend_prefixes']['source'];
  935.         $path = $prefix . $path;
  937.         $event = new GenericEvent($this, [
  938.             'frontendPath' => $path,
  939.         ]);
  941.         $this->dispatchEvent($event, FrontendEvents::ASSET_PATH);
  943.         return $event->getArgument('frontendPath');
  944.     }
  946.     /**
  947.      * {@inheritdoc}
  948.      */
  949.     public function getRealPath()
  950.     {
  951.         return $this->path;
  952.     }
  954.     /**
  955.      * {@inheritdoc}
  956.      */
  957.     public function getRealFullPath()
  958.     {
  959.         $path = $this->getRealPath() . $this->getFilename();
  961.         return $path;
  962.     }
  964.     /**
  965.      * @return array
  966.      */
  967.     public function getSiblings()
  968.     {
  969.         if ($this->siblings === null) {
  970.             if ($this->getParentId()) {
  971.                 $list = new Asset\Listing();
  972.                 $list->addConditionParam('parentId = ?', $this->getParentId());
  973.                 if ($this->getId()) {
  974.                     $list->addConditionParam('id != ?', $this->getId());
  975.                 }
  976.                 $list->setOrderKey('filename');
  977.                 $list->setOrder('asc');
  978.                 $this->siblings = $list->getAssets();
  979.             } else {
  980.                 $this->siblings = [];
  981.             }
  982.         }
  984.         return $this->siblings;
  985.     }
  987.     /**
  988.      * @return bool
  989.      */
  990.     public function hasSiblings()
  991.     {
  992.         if (is_bool($this->hasSiblings)) {
  993.             if (($this->hasSiblings && empty($this->siblings)) || (!$this->hasSiblings && !empty($this->siblings))) {
  994.                 return $this->getDao()->hasSiblings();
  995.             } else {
  996.                 return $this->hasSiblings;
  997.             }
  998.         }
  1000.         return $this->getDao()->hasSiblings();
  1001.     }
  1003.     /**
  1004.      * @return bool
  1005.      */
  1006.     public function hasChildren()
  1007.     {
  1008.         return false;
  1009.     }
  1011.     /**
  1012.      * @return Asset[]
  1013.      */
  1014.     public function getChildren()
  1015.     {
  1016.         return [];
  1017.     }
  1019.     /**
  1020.      * {@inheritdoc}
  1021.      */
  1022.     public function getLocked()
  1023.     {
  1024.         return $this->locked;
  1025.     }
  1027.     /**
  1028.      * {@inheritdoc}
  1029.      */
  1030.     public function setLocked($locked)
  1031.     {
  1032.         $this->locked = $locked;
  1034.         return $this;
  1035.     }
  1037.     /**
  1038.      * @throws \League\Flysystem\FilesystemException
  1039.      */
  1040.     private function deletePhysicalFile()
  1041.     {
  1042.         $storage = Storage::get('asset');
  1043.         if ($this->getType() != 'folder') {
  1044.             $storage->delete($this->getRealFullPath());
  1045.         } else {
  1046.             $storage->deleteDirectory($this->getRealFullPath());
  1047.         }
  1048.     }
  1050.     /**
  1051.      * {@inheritdoc}
  1052.      */
  1053.     public function delete(bool $isNested = false)
  1054.     {
  1055.         if ($this->getId() == 1) {
  1056.             throw new \Exception('root-node cannot be deleted');
  1057.         }
  1059.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::PRE_DELETE);
  1061.         $this->beginTransaction();
  1063.         try {
  1064.             $this->closeStream();
  1066.             // remove children
  1067.             if ($this->hasChildren()) {
  1068.                 foreach ($this->getChildren() as $child) {
  1069.                     $child->delete(true);
  1070.                 }
  1071.             }
  1073.             // Dispatch Symfony Message Bus to delete versions
  1074.             \Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1075.                 new VersionDeleteMessage(Service::getElementType($this), $this->getId())
  1076.             );
  1078.             // remove all properties
  1079.             $this->getDao()->deleteAllProperties();
  1081.             // remove all tasks
  1082.             $this->getDao()->deleteAllTasks();
  1084.             // remove dependencies
  1085.             $d = $this->getDependencies();
  1086.             $d->cleanAllForElement($this);
  1088.             // remove from resource
  1089.             $this->getDao()->delete();
  1091.             $this->commit();
  1093.             // remove file on filesystem
  1094.             if (!$isNested) {
  1095.                 $fullPath = $this->getRealFullPath();
  1096.                 if ($fullPath != '/..' && !strpos($fullPath,
  1097.                         '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1098.                     $this->deletePhysicalFile();
  1099.                 }
  1100.             }
  1102.             $this->clearThumbnails(true);
  1103.         } catch (\Exception $e) {
  1104.             try {
  1105.                 $this->rollBack();
  1106.             } catch (\Exception $er) {
  1107.                 // PDO adapter throws exceptions if rollback fails
  1108.                 Logger::info($er);
  1109.             }
  1111.             $failureEvent = new AssetEvent($this);
  1112.             $failureEvent->setArgument('exception', $e);
  1113.             $this->dispatchEvent($failureEvent, AssetEvents::POST_DELETE_FAILURE);
  1114.             Logger::crit($e);
  1116.             throw $e;
  1117.         }
  1119.         // empty asset cache
  1120.         $this->clearDependentCache();
  1122.         // clear asset from registry
  1123.         \Pimcore\Cache\Runtime::set(self::getCacheKey($this->getId()), null);
  1125.         $this->dispatchEvent(new AssetEvent($this), AssetEvents::POST_DELETE);
  1126.     }
  1128.     /**
  1129.      * {@inheritdoc}
  1130.      */
  1131.     public function clearDependentCache($additionalTags = [])
  1132.     {
  1133.         try {
  1134.             $tags = [$this->getCacheTag(), 'asset_properties', 'output'];
  1135.             $tags = array_merge($tags, $additionalTags);
  1137.             \Pimcore\Cache::clearTags($tags);
  1138.         } catch (\Exception $e) {
  1139.             Logger::crit($e);
  1140.         }
  1141.     }
  1143.     /**
  1144.      * {@inheritdoc}
  1145.      */
  1146.     public function getCreationDate()
  1147.     {
  1148.         return $this->creationDate;
  1149.     }
  1151.     /**
  1152.      * {@inheritdoc}
  1153.      */
  1154.     public function getId()
  1155.     {
  1156.         return $this->id;
  1157.     }
  1159.     /**
  1160.      * @return string|null
  1161.      */
  1162.     public function getFilename()
  1163.     {
  1164.         return $this->filename;
  1165.     }
  1167.     /**
  1168.      * {@inheritdoc}
  1169.      */
  1170.     public function getKey()
  1171.     {
  1172.         return $this->getFilename();
  1173.     }
  1175.     /**
  1176.      * {@inheritdoc}
  1177.      */
  1178.     public function getModificationDate()
  1179.     {
  1180.         return $this->modificationDate;
  1181.     }
  1183.     /**
  1184.      * {@inheritdoc}
  1185.      */
  1186.     public function getParentId()
  1187.     {
  1188.         return $this->parentId;
  1189.     }
  1191.     /**
  1192.      * {@inheritdoc}
  1193.      */
  1194.     public function getPath()
  1195.     {
  1196.         return $this->path;
  1197.     }
  1199.     /**
  1200.      * {@inheritdoc}
  1201.      */
  1202.     public function getType()
  1203.     {
  1204.         return $this->type;
  1205.     }
  1207.     /**
  1208.      * {@inheritdoc}
  1209.      */
  1210.     public function setCreationDate($creationDate)
  1211.     {
  1212.         $this->creationDate = (int)$creationDate;
  1214.         return $this;
  1215.     }
  1217.     /**
  1218.      * {@inheritdoc}
  1219.      */
  1220.     public function setId($id)
  1221.     {
  1222.         $this->id = (int)$id;
  1224.         return $this;
  1225.     }
  1227.     /**
  1228.      * @param string $filename
  1229.      *
  1230.      * @return $this
  1231.      */
  1232.     public function setFilename($filename)
  1233.     {
  1234.         $this->filename = (string)$filename;
  1236.         return $this;
  1237.     }
  1239.     /**
  1240.      * {@inheritdoc}
  1241.      */
  1242.     public function setKey($key)
  1243.     {
  1244.         return $this->setFilename($key);
  1245.     }
  1247.     /**
  1248.      * {@inheritdoc}
  1249.      */
  1250.     public function setModificationDate($modificationDate)
  1251.     {
  1252.         $this->markFieldDirty('modificationDate');
  1254.         $this->modificationDate = (int)$modificationDate;
  1256.         return $this;
  1257.     }
  1259.     /**
  1260.      * @param int $parentId
  1261.      *
  1262.      * @return $this
  1263.      */
  1264.     public function setParentId($parentId)
  1265.     {
  1266.         $this->parentId = (int)$parentId;
  1267.         $this->parent = null;
  1269.         return $this;
  1270.     }
  1272.     /**
  1273.      * {@inheritdoc}
  1274.      */
  1275.     public function setPath($path)
  1276.     {
  1277.         $this->path = (string)$path;
  1279.         return $this;
  1280.     }
  1282.     /**
  1283.      * @param string $type
  1284.      *
  1285.      * @return $this
  1286.      */
  1287.     public function setType($type)
  1288.     {
  1289.         $this->type = (string)$type;
  1291.         return $this;
  1292.     }
  1294.     /**
  1295.      * @return mixed
  1296.      */
  1297.     public function getData()
  1298.     {
  1299.         $stream = $this->getStream();
  1300.         if ($stream) {
  1301.             return stream_get_contents($stream);
  1302.         }
  1304.         return '';
  1305.     }
  1307.     /**
  1308.      * @param mixed $data
  1309.      *
  1310.      * @return $this
  1311.      */
  1312.     public function setData($data)
  1313.     {
  1314.         $handle = tmpfile();
  1315.         fwrite($handle, $data);
  1316.         $this->setStream($handle);
  1318.         return $this;
  1319.     }
  1321.     /**
  1322.      * @return resource|null
  1323.      */
  1324.     public function getStream()
  1325.     {
  1326.         if ($this->stream) {
  1327.             if (get_resource_type($this->stream) !== 'stream') {
  1328.                 $this->stream = null;
  1329.             } elseif (!@rewind($this->stream)) {
  1330.                 $this->stream = null;
  1331.             }
  1332.         }
  1334.         if (!$this->stream && $this->getType() !== 'folder') {
  1335.             try {
  1336.                 $this->stream = Storage::get('asset')->readStream($this->getRealFullPath());
  1337.             } catch (\Exception $e) {
  1338.                 $this->stream = tmpfile();
  1339.             }
  1340.         }
  1342.         return $this->stream;
  1343.     }
  1345.     /**
  1346.      * @param resource|null $stream
  1347.      *
  1348.      * @return $this
  1349.      */
  1350.     public function setStream($stream)
  1351.     {
  1352.         // close existing stream
  1353.         if ($stream !== $this->stream) {
  1354.             $this->closeStream();
  1355.         }
  1357.         if (is_resource($stream)) {
  1358.             $this->setDataChanged(true);
  1359.             $this->stream = $stream;
  1361.             $isRewindable = @rewind($this->stream);
  1363.             if (!$isRewindable) {
  1364.                 $tempFile = $this->getLocalFileFromStream($this->stream);
  1365.                 $dest = fopen($tempFile, 'rb', false, File::getContext());
  1366.                 $this->stream = $dest;
  1367.             }
  1368.         } elseif (is_null($stream)) {
  1369.             $this->stream = null;
  1370.         }
  1372.         return $this;
  1373.     }
  1375.     private function closeStream()
  1376.     {
  1377.         if (is_resource($this->stream)) {
  1378.             @fclose($this->stream);
  1379.             $this->stream = null;
  1380.         }
  1381.     }
  1383.     /**
  1384.      * @return bool
  1385.      */
  1386.     public function getDataChanged()
  1387.     {
  1388.         return $this->dataChanged;
  1389.     }
  1391.     /**
  1392.      * @param bool $changed
  1393.      *
  1394.      * @return $this
  1395.      */
  1396.     public function setDataChanged($changed = true)
  1397.     {
  1398.         $this->dataChanged = $changed;
  1400.         return $this;
  1401.     }
  1403.     /**
  1404.      * {@inheritdoc}
  1405.      */
  1406.     public function getProperties()
  1407.     {
  1408.         if ($this->properties === null) {
  1409.             // try to get from cache
  1410.             $cacheKey = 'asset_properties_' . $this->getId();
  1411.             $properties = \Pimcore\Cache::load($cacheKey);
  1412.             if (!is_array($properties)) {
  1413.                 $properties = $this->getDao()->getProperties();
  1414.                 $elementCacheTag = $this->getCacheTag();
  1415.                 $cacheTags = ['asset_properties' => 'asset_properties', $elementCacheTag => $elementCacheTag];
  1416.                 \Pimcore\Cache::save($properties, $cacheKey, $cacheTags);
  1417.             }
  1419.             $this->setProperties($properties);
  1420.         }
  1422.         return $this->properties;
  1423.     }
  1425.     /**
  1426.      * {@inheritdoc}
  1427.      */
  1428.     public function setProperties(?array $properties)
  1429.     {
  1430.         $this->properties = $properties;
  1432.         return $this;
  1433.     }
  1435.     /**
  1436.      * {@inheritdoc}
  1437.      */
  1438.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1439.     {
  1440.         $this->getProperties();
  1442.         $property = new Property();
  1443.         $property->setType($type);
  1444.         $property->setCid($this->getId());
  1445.         $property->setName($name);
  1446.         $property->setCtype('asset');
  1447.         $property->setData($data);
  1448.         $property->setInherited($inherited);
  1449.         $property->setInheritable($inheritable);
  1451.         $this->properties[$name] = $property;
  1453.         return $this;
  1454.     }
  1456.     /**
  1457.      * {@inheritdoc}
  1458.      */
  1459.     public function getUserOwner()
  1460.     {
  1461.         return $this->userOwner;
  1462.     }
  1464.     /**
  1465.      * {@inheritdoc}
  1466.      */
  1467.     public function getUserModification()
  1468.     {
  1469.         return $this->userModification;
  1470.     }
  1472.     /**
  1473.      * {@inheritdoc}
  1474.      */
  1475.     public function setUserOwner($userOwner)
  1476.     {
  1477.         $this->userOwner = (int)$userOwner;
  1479.         return $this;
  1480.     }
  1482.     /**
  1483.      * {@inheritdoc}
  1484.      */
  1485.     public function setUserModification($userModification)
  1486.     {
  1487.         $this->markFieldDirty('userModification');
  1489.         $this->userModification = (int)$userModification;
  1491.         return $this;
  1492.     }
  1494.     /**
  1495.      * {@inheritdoc}
  1496.      */
  1497.     public function getVersions()
  1498.     {
  1499.         if ($this->versions === null) {
  1500.             $this->setVersions($this->getDao()->getVersions());
  1501.         }
  1503.         return $this->versions;
  1504.     }
  1506.     /**
  1507.      * @param Version[] $versions
  1508.      *
  1509.      * @return $this
  1510.      */
  1511.     public function setVersions($versions)
  1512.     {
  1513.         $this->versions = $versions;
  1515.         return $this;
  1516.     }
  1518.     /**
  1519.      * @internal
  1520.      *
  1521.      * @param bool $keep whether to delete this file on shutdown or not
  1522.      *
  1523.      * @return string
  1524.      *
  1525.      * @throws \Exception
  1526.      */
  1527.     public function getTemporaryFile(bool $keep = false)
  1528.     {
  1529.         return self::getTemporaryFileFromStream($this->getStream(), $keep);
  1530.     }
  1532.     /**
  1533.      * @internal
  1534.      *
  1535.      * @return string
  1536.      *
  1537.      * @throws \Exception
  1538.      */
  1539.     public function getLocalFile()
  1540.     {
  1541.         return self::getLocalFileFromStream($this->getStream());
  1542.     }
  1544.     /**
  1545.      * @param string $key
  1546.      * @param mixed $value
  1547.      *
  1548.      * @return $this
  1549.      */
  1550.     public function setCustomSetting($key, $value)
  1551.     {
  1552.         $this->customSettings[$key] = $value;
  1554.         return $this;
  1555.     }
  1557.     /**
  1558.      * @param string $key
  1559.      *
  1560.      * @return mixed
  1561.      */
  1562.     public function getCustomSetting($key)
  1563.     {
  1564.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1565.             return $this->customSettings[$key];
  1566.         }
  1568.         return null;
  1569.     }
  1571.     /**
  1572.      * @param string $key
  1573.      */
  1574.     public function removeCustomSetting($key)
  1575.     {
  1576.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1577.             unset($this->customSettings[$key]);
  1578.         }
  1579.     }
  1581.     /**
  1582.      * @return array
  1583.      */
  1584.     public function getCustomSettings()
  1585.     {
  1586.         return $this->customSettings;
  1587.     }
  1589.     /**
  1590.      * @param mixed $customSettings
  1591.      *
  1592.      * @return $this
  1593.      */
  1594.     public function setCustomSettings($customSettings)
  1595.     {
  1596.         if (is_string($customSettings)) {
  1597.             $customSettings = \Pimcore\Tool\Serialize::unserialize($customSettings);
  1598.         }
  1600.         if ($customSettings instanceof \stdClass) {
  1601.             $customSettings = (array)$customSettings;
  1602.         }
  1604.         if (!is_array($customSettings)) {
  1605.             $customSettings = [];
  1606.         }
  1608.         $this->customSettings = $customSettings;
  1610.         return $this;
  1611.     }
  1613.     /**
  1614.      * @return string|null
  1615.      */
  1616.     public function getMimeType()
  1617.     {
  1618.         return $this->mimetype;
  1619.     }
  1621.     /**
  1622.      * @param string $mimetype
  1623.      *
  1624.      * @return $this
  1625.      */
  1626.     public function setMimeType($mimetype)
  1627.     {
  1628.         $this->mimetype = (string)$mimetype;
  1630.         return $this;
  1631.     }
  1633.     /**
  1634.      * @param array $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1635.      *
  1636.      * @return self
  1637.      *
  1638.      * @internal
  1639.      *
  1640.      */
  1641.     public function setMetadataRaw($metadata)
  1642.     {
  1643.         $this->metadata = $metadata;
  1644.         if ($this->metadata) {
  1645.             $this->setHasMetaData(true);
  1646.         }
  1648.         return $this;
  1649.     }
  1651.     /**
  1652.      * @param array|\stdClass[] $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1653.      *
  1654.      * @return self
  1655.      */
  1656.     public function setMetadata($metadata)
  1657.     {
  1658.         $this->metadata = [];
  1659.         $this->setHasMetaData(false);
  1660.         if (!empty($metadata)) {
  1661.             foreach ((array)$metadata as $metaItem) {
  1662.                 $metaItem = (array)$metaItem; // also allow object with appropriate keys
  1663.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1664.             }
  1665.         }
  1667.         return $this;
  1668.     }
  1670.     /**
  1671.      * @return bool
  1672.      */
  1673.     public function getHasMetaData()
  1674.     {
  1675.         return $this->hasMetaData;
  1676.     }
  1678.     /**
  1679.      * @param bool $hasMetaData
  1680.      *
  1681.      * @return self
  1682.      */
  1683.     public function setHasMetaData($hasMetaData)
  1684.     {
  1685.         $this->hasMetaData = (bool)$hasMetaData;
  1687.         return $this;
  1688.     }
  1690.     /**
  1691.      * @param string $name
  1692.      * @param string $type can be "asset", "checkbox", "date", "document", "input", "object", "select" or "textarea"
  1693.      * @param mixed $data
  1694.      * @param string|null $language
  1695.      *
  1696.      * @return self
  1697.      */
  1698.     public function addMetadata($name, $type, $data = null, $language = null)
  1699.     {
  1700.         if ($name && $type) {
  1701.             $tmp = [];
  1702.             $name = str_replace('~', '---', $name);
  1703.             if (!is_array($this->metadata)) {
  1704.                 $this->metadata = [];
  1705.             }
  1707.             foreach ($this->metadata as $item) {
  1708.                 if ($item['name'] != $name || $language != $item['language']) {
  1709.                     $tmp[] = $item;
  1710.                 }
  1711.             }
  1713.             $item = [
  1714.                 'name' => $name,
  1715.                 'type' => $type,
  1716.                 'data' => $data,
  1717.                 'language' => $language,
  1718.             ];
  1720.             $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1722.             try {
  1723.                 /** @var Data $instance */
  1724.                 $instance = $loader->build($item['type']);
  1725.                 $transformedData = $instance->transformSetterData($data, $item);
  1726.                 $item['data'] = $transformedData;
  1727.             } catch (UnsupportedException $e) {
  1728.             }
  1730.             $tmp[] = $item;
  1731.             $this->metadata = $tmp;
  1733.             $this->setHasMetaData(true);
  1734.         }
  1736.         return $this;
  1737.     }
  1739.     /**
  1740.      * @param string $name
  1741.      * @param string|null $language
  1742.      *
  1743.      * @return self
  1744.      */
  1745.     public function removeMetadata(string $name, ?string $language = null)
  1746.     {
  1747.         if ($name) {
  1748.             $tmp = [];
  1749.             $name = str_replace('~', '---', $name);
  1750.             if (!is_array($this->metadata)) {
  1751.                 $this->metadata = [];
  1752.             }
  1754.             foreach ($this->metadata as $item) {
  1755.                 if ($item['name'] === $name && ($language == $item['language'] || $language === '*')) {
  1756.                     continue;
  1757.                 }
  1758.                 $tmp[] = $item;
  1759.             }
  1761.             $this->metadata = $tmp;
  1762.             $this->setHasMetaData(!empty($this->metadata));
  1763.         }
  1765.         return $this;
  1766.     }
  1768.     /**
  1769.      * @param string|null $name
  1770.      * @param string|null $language
  1771.      * @param bool $strictMatch
  1772.      * @param bool $raw
  1773.      *
  1774.      * @return array|string|null
  1775.      */
  1776.     public function getMetadata($name = null, $language = null, $strictMatch = false, $raw = false)
  1777.     {
  1778.         $preEvent = new AssetEvent($this);
  1779.         $preEvent->setArgument('metadata', $this->metadata);
  1780.         $this->dispatchEvent($preEvent, AssetEvents::PRE_GET_METADATA);
  1781.         $this->metadata = $preEvent->getArgument('metadata');
  1783.         $convert = function ($metaData) {
  1784.             $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1785.             $transformedData = $metaData['data'];
  1787.             try {
  1788.                 /** @var Data $instance */
  1789.                 $instance = $loader->build($metaData['type']);
  1790.                 $transformedData = $instance->transformGetterData($metaData['data'], $metaData);
  1791.             } catch (UnsupportedException $e) {
  1792.             }
  1794.             return $transformedData;
  1795.         };
  1797.         if ($name) {
  1798.             if ($language === null) {
  1799.                 $language = \Pimcore::getContainer()->get(LocaleServiceInterface::class)->findLocale();
  1800.             }
  1802.             $data = null;
  1803.             foreach ($this->metadata as $md) {
  1804.                 if ($md['name'] == $name) {
  1805.                     if ($language == $md['language']) {
  1806.                         if ($raw) {
  1807.                             return $md;
  1808.                         }
  1810.                         return $convert($md);
  1811.                     }
  1812.                     if (empty($md['language']) && !$strictMatch) {
  1813.                         if ($raw) {
  1814.                             return $md;
  1815.                         }
  1816.                         $data = $md;
  1817.                     }
  1818.                 }
  1819.             }
  1821.             if ($data) {
  1822.                 if ($raw) {
  1823.                     return $data;
  1824.                 }
  1826.                 return $convert($data);
  1827.             }
  1829.             return null;
  1830.         }
  1832.         $metaData = $this->getObjectVar('metadata');
  1833.         $result = [];
  1834.         if (is_array($metaData)) {
  1835.             foreach ($metaData as $md) {
  1836.                 $md = (array)$md;
  1837.                 if (!$raw) {
  1838.                     $md['data'] = $convert($md);
  1839.                 }
  1840.                 $result[] = $md;
  1841.             }
  1842.         }
  1844.         return $result;
  1845.     }
  1847.     /**
  1848.      * @param bool $formatted
  1849.      * @param int $precision
  1850.      *
  1851.      * @return string|int
  1852.      */
  1853.     public function getFileSize($formatted = false, $precision = 2)
  1854.     {
  1855.         try {
  1856.             $bytes = Storage::get('asset')->fileSize($this->getRealFullPath());
  1857.         } catch (\Exception $e) {
  1858.             $bytes = 0;
  1859.         }
  1861.         if ($formatted) {
  1862.             return formatBytes($bytes, $precision);
  1863.         }
  1865.         return $bytes;
  1866.     }
  1868.     /**
  1869.      * {@inheritdoc}
  1870.      */
  1871.     public function getParent()
  1872.     {
  1873.         if ($this->parent === null) {
  1874.             $this->setParent(Asset::getById($this->getParentId()));
  1875.         }
  1877.         return $this->parent;
  1878.     }
  1880.     /**
  1881.      * @param Asset|null $parent
  1882.      *
  1883.      * @return $this
  1884.      */
  1885.     public function setParent($parent)
  1886.     {
  1887.         $this->parent = $parent;
  1888.         if ($parent instanceof Asset) {
  1889.             $this->parentId = $parent->getId();
  1890.         }
  1892.         return $this;
  1893.     }
  1895.     public function __sleep()
  1896.     {
  1897.         $parentVars = parent::__sleep();
  1898.         $blockedVars = ['scheduledTasks', 'hasChildren', 'versions', 'parent', 'stream'];
  1900.         if ($this->isInDumpState()) {
  1901.             // this is if we want to make a full dump of the asset (eg. for a new version), including children for recyclebin
  1902.             $this->removeInheritedProperties();
  1903.         } else {
  1904.             // this is if we want to cache the asset
  1905.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  1906.         }
  1908.         return array_diff($parentVars, $blockedVars);
  1909.     }
  1911.     public function __wakeup()
  1912.     {
  1913.         if ($this->isInDumpState()) {
  1914.             // set current parent and path, this is necessary because the serialized data can have a different path than the original element (element was moved)
  1915.             $originalElement = Asset::getById($this->getId());
  1916.             if ($originalElement) {
  1917.                 $this->setParentId($originalElement->getParentId());
  1918.                 $this->setPath($originalElement->getRealPath());
  1919.             }
  1920.         }
  1922.         if ($this->isInDumpState() && $this->properties !== null) {
  1923.             $this->renewInheritedProperties();
  1924.         }
  1926.         $this->setInDumpState(false);
  1927.     }
  1929.     public function __destruct()
  1930.     {
  1931.         // close open streams
  1932.         $this->closeStream();
  1933.     }
  1935.     /**
  1936.      * {@inheritdoc}
  1937.      */
  1938.     public function getVersionCount(): int
  1939.     {
  1940.         return $this->versionCount ? $this->versionCount : 0;
  1941.     }
  1943.     /**
  1944.      * {@inheritdoc}
  1945.      */
  1946.     public function setVersionCount(?int $versionCount): ElementInterface
  1947.     {
  1948.         $this->versionCount = (int)$versionCount;
  1950.         return $this;
  1951.     }
  1953.     /**
  1954.      * {@inheritdoc}
  1955.      */
  1956.     protected function resolveDependencies(): array
  1957.     {
  1958.         $dependencies = [parent::resolveDependencies()];
  1960.         if ($this->hasMetaData) {
  1961.             $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1963.             foreach ($this->getMetadata() as $metaData) {
  1964.                 if (!empty($metaData['data'])) {
  1965.                     /** @var ElementInterface $elementData */
  1966.                     $elementData = $metaData['data'];
  1967.                     $elementType = $metaData['type'];
  1969.                     try {
  1970.                         /** @var DataDefinitionInterface $implementation */
  1971.                         $implementation = $loader->build($elementType);
  1972.                         $dependencies[] = $implementation->resolveDependencies($elementData, $metaData);
  1973.                     } catch (UnsupportedException $e) {
  1974.                     }
  1975.                 }
  1976.             }
  1977.         }
  1979.         return array_merge(...$dependencies);
  1980.     }
  1982.     public function __clone()
  1983.     {
  1984.         parent::__clone();
  1985.         $this->parent = null;
  1986.         $this->versions = null;
  1987.         $this->hasSiblings = null;
  1988.         $this->siblings = null;
  1989.         $this->scheduledTasks = null;
  1990.         $this->closeStream();
  1991.     }
  1993.     /**
  1994.      * @param bool $force
  1995.      */
  1996.     public function clearThumbnails($force = false)
  1997.     {
  1998.         if ($this->getDataChanged() || $force) {
  1999.             foreach (['thumbnail', 'asset_cache'] as $storageName) {
  2000.                 $storage = Storage::get($storageName);
  2001.                 $contents = $storage->listContents($this->getRealPath());
  2003.                 /** @var StorageAttributes $item */
  2004.                 foreach ($contents as $item) {
  2005.                     if (preg_match('@(image|video|pdf)\-thumb__' . $this->getId() . '__@', $item->path())) {
  2006.                         if ($item->isDir()) {
  2007.                             $storage->deleteDirectory($item->path());
  2008.                         } elseif ($item->isFile()) {
  2009.                             $storage->delete($item->path());
  2010.                         }
  2011.                     }
  2012.                 }
  2013.             }
  2014.         }
  2015.     }
  2017.     /**
  2018.      * @param FilesystemOperator $storage
  2019.      * @param string $oldPath
  2020.      *
  2021.      * @throws \League\Flysystem\FilesystemException
  2022.      */
  2023.     private function updateChildPaths(FilesystemOperator $storage, string $oldPath)
  2024.     {
  2025.         try {
  2026.             $children = $storage->listContents($oldPath, true);
  2027.             foreach ($children as $child) {
  2028.                 if ($child['type'] === 'file') {
  2029.                     $src  = $child['path'];
  2030.                     $dest = str_replace($oldPath, $this->getRealFullPath(), '/' . $src);
  2031.                     $storage->move($src, $dest);
  2032.                 }
  2033.             }
  2035.             $storage->deleteDirectory($oldPath);
  2036.         } catch (UnableToMoveFile $e) {
  2037.             // noting to do
  2038.         }
  2039.     }
  2041.     /**
  2042.      * @param string $oldPath
  2043.      *
  2044.      * @throws \League\Flysystem\FilesystemException
  2045.      */
  2046.     private function relocateThumbnails(string $oldPath)
  2047.     {
  2048.         $oldParent = dirname($oldPath);
  2049.         $newParent = dirname($this->getRealFullPath());
  2050.         $storage = Storage::get('thumbnail');
  2052.         try {
  2053.             //remove source parent folder thumbnails
  2054.             $contents = $storage->listContents($oldParent)->filter(fn (StorageAttributes $attributes) => ($attributes->isFile() && strstr($attributes['path'], 'image-thumb_')));
  2055.             /** @var StorageAttributes $item */
  2056.             foreach ($contents as $item) {
  2057.                 $storage->delete($item['path']);
  2058.             }
  2060.             //remove destination parent folder thumbnails
  2061.             $contents = $storage->listContents($newParent)->filter(fn (StorageAttributes $attributes) => ($attributes->isFile() && strstr($attributes['path'], 'image-thumb_')));
  2062.             /** @var StorageAttributes $item */
  2063.             foreach ($contents as $item) {
  2064.                 $storage->delete($item['path']);
  2065.             }
  2067.             $contents = $storage->listContents($oldParent);
  2068.             /** @var StorageAttributes $item */
  2069.             foreach ($contents as $item) {
  2070.                 if (preg_match('@(image|video|pdf)\-thumb__' . $this->getId() . '__@', $item->path())) {
  2071.                     $replacePath = ltrim($newParent, '/') .'/' . basename($item->path());
  2072.                     if (!$storage->fileExists($replacePath)) {
  2073.                         $storage->move($item->path(), $replacePath);
  2074.                     }
  2075.                 }
  2076.             }
  2078.             //required in case if renaming or moving parent folder
  2079.             try {
  2080.                 $storage->move($oldPath, $this->getRealFullPath());
  2081.             } catch (UnableToMoveFile $e) {
  2082.                 //update children, if unable to move parent
  2083.                 $this->updateChildPaths($storage, $oldPath);
  2084.             }
  2085.         } catch (UnableToMoveFile $e) {
  2086.             // noting to do
  2087.         }
  2088.     }
  2090.     /**
  2091.      * @param string $name
  2092.      */
  2093.     public function clearThumbnail($name)
  2094.     {
  2095.         try {
  2096.             Storage::get('thumbnail')->deleteDirectory($this->getRealPath() . 'image-thumb__' . $this->getId() . '__' . $name);
  2097.         } catch (\Exception $e) {
  2098.             // noting to do
  2099.         }
  2100.     }
  2102.     /**
  2103.      * @internal
  2104.      */
  2105.     protected function addToUpdateTaskQueue(): void
  2106.     {
  2107.         \Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  2108.             new AssetUpdateTasksMessage($this->getId())
  2109.         );
  2110.     }
  2111. }