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

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @category   Pimcore
  12.  * @package    Asset
  13.  *
  14.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  15.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  16.  */
  18. namespace Pimcore\Model;
  20. use Doctrine\DBAL\Exception\DeadlockException;
  21. use Pimcore\Event\AssetEvents;
  22. use Pimcore\Event\FrontendEvents;
  23. use Pimcore\Event\Model\AssetEvent;
  24. use Pimcore\File;
  25. use Pimcore\Logger;
  26. use Pimcore\Model\Asset\Listing;
  27. use Pimcore\Model\Element\ElementInterface;
  28. use Pimcore\Tool\Mime;
  29. use Symfony\Component\EventDispatcher\GenericEvent;
  31. /**
  32.  * @method \Pimcore\Model\Asset\Dao getDao()
  33.  * @method bool __isBasedOnLatestData()
  34.  * @method int getChildAmount($user = null)
  35.  * @method string|null getCurrentFullPath()
  36.  */
  37. class Asset extends Element\AbstractElement
  38. {
  39.     /**
  40.      * possible types of an asset
  41.      *
  42.      * @var array
  43.      */
  44.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  46.     /**
  47.      * Unique ID
  48.      *
  49.      * @var int
  50.      */
  51.     protected $id;
  53.     /**
  54.      * ID of the parent asset
  55.      *
  56.      * @var int
  57.      */
  58.     protected $parentId;
  60.     /**
  61.      * @var Asset|null
  62.      */
  63.     protected $parent;
  65.     /**
  66.      * Type
  67.      *
  68.      * @var string
  69.      */
  70.     protected $type;
  72.     /**
  73.      * Name of the file
  74.      *
  75.      * @var string
  76.      */
  77.     protected $filename;
  79.     /**
  80.      * Path of the file, without the filename, only the full path of the parent asset
  81.      *
  82.      * @var string
  83.      */
  84.     protected $path;
  86.     /**
  87.      * Mime-Type of the file
  88.      *
  89.      * @var string
  90.      */
  91.     protected $mimetype;
  93.     /**
  94.      * Timestamp of creation
  95.      *
  96.      * @var int
  97.      */
  98.     protected $creationDate;
  100.     /**
  101.      * Timestamp of modification
  102.      *
  103.      * @var int
  104.      */
  105.     protected $modificationDate;
  107.     /**
  108.      * @var resource|null
  109.      */
  110.     protected $stream;
  112.     /**
  113.      * ID of the owner user
  114.      *
  115.      * @var int
  116.      */
  117.     protected $userOwner;
  119.     /**
  120.      * ID of the user who make the latest changes
  121.      *
  122.      * @var int
  123.      */
  124.     protected $userModification;
  126.     /**
  127.      * List of properties
  128.      *
  129.      * @var array
  130.      */
  131.     protected $properties = null;
  133.     /**
  134.      * List of versions
  135.      *
  136.      * @var array|null
  137.      */
  138.     protected $versions = null;
  140.     /**
  141.      * @var array
  142.      */
  143.     protected $metadata = [];
  145.     /**
  146.      * enum('self','propagate') nullable
  147.      *
  148.      * @var string|null
  149.      */
  150.     protected $locked;
  152.     /**
  153.      * List of some custom settings  [key] => value
  154.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  155.      *
  156.      * @var array
  157.      */
  158.     protected $customSettings = [];
  160.     /**
  161.      * @var bool
  162.      */
  163.     protected $hasMetaData = false;
  165.     /**
  166.      * Dependencies of this asset
  167.      *
  168.      * @var Dependency|null
  169.      */
  170.     protected $dependencies;
  172.     /**
  173.      * Contains a list of sibling documents
  174.      *
  175.      * @var array|null
  176.      */
  177.     protected $siblings;
  179.     /**
  180.      * Indicator if document has siblings or not
  181.      *
  182.      * @var bool|null
  183.      */
  184.     protected $hasSiblings;
  186.     /**
  187.      * Contains all scheduled tasks
  188.      *
  189.      * @var array|null
  190.      */
  191.     protected $scheduledTasks = null;
  193.     /**
  194.      * Indicator if data has changed
  195.      *
  196.      * @var bool
  197.      */
  198.     protected $_dataChanged = false;
  200.     /**
  201.      * @var int
  202.      */
  203.     protected $versionCount;
  205.     /**
  206.      * @var string[]
  207.      */
  208.     protected $_temporaryFiles = [];
  210.     /**
  211.      *
  212.      * @return array
  213.      */
  214.     public static function getTypes()
  215.     {
  216.         return self::$types;
  217.     }
  219.     /**
  220.      * Static helper to get an asset by the passed path
  221.      *
  222.      * @param string $path
  223.      * @param bool $force
  224.      *
  225.      * @return static|null
  226.      */
  227.     public static function getByPath($path, $force = false)
  228.     {
  229.         $path = Element\Service::correctPath($path);
  231.         try {
  232.             $asset = new Asset();
  233.             $asset->getDao()->getByPath($path);
  235.             return static::getById($asset->getId(), $force);
  236.         } catch (\Exception $e) {
  237.             return null;
  238.         }
  239.     }
  241.     /**
  242.      * @param Asset $asset
  243.      *
  244.      * @return bool
  245.      */
  246.     protected static function typeMatch(Asset $asset)
  247.     {
  248.         $staticType = get_called_class();
  249.         if ($staticType != Asset::class) {
  250.             if (!$asset instanceof $staticType) {
  251.                 return false;
  252.             }
  253.         }
  255.         return true;
  256.     }
  258.     /**
  259.      * Static helper to get an asset by the passed ID
  260.      *
  261.      * @param int $id
  262.      * @param bool $force
  263.      *
  264.      * @return static|null
  265.      */
  266.     public static function getById($id, $force = false)
  267.     {
  268.         if (!is_numeric($id) || $id < 1) {
  269.             return null;
  270.         }
  272.         $id = intval($id);
  273.         $cacheKey = self::getCacheKey($id);
  275.         if (!$force && \Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  276.             $asset = \Pimcore\Cache\Runtime::get($cacheKey);
  277.             if ($asset && static::typeMatch($asset)) {
  278.                 return $asset;
  279.             }
  280.         }
  282.         try {
  283.             if ($force || !($asset = \Pimcore\Cache::load($cacheKey))) {
  284.                 $asset = new Asset();
  285.                 $asset->getDao()->getById($id);
  287.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  289.                 /** @var Asset $asset */
  290.                 $asset = self::getModelFactory()->build($className);
  291.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  292.                 $asset->getDao()->getById($id);
  293.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  295.                 $asset->resetDirtyMap();
  297.                 \Pimcore\Cache::save($asset, $cacheKey);
  298.             } else {
  299.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  300.             }
  301.         } catch (\Exception $e) {
  302.             return null;
  303.         }
  305.         if (!$asset || !static::typeMatch($asset)) {
  306.             return null;
  307.         }
  309.         return $asset;
  310.     }
  312.     /**
  313.      * Helper to quickly create a new asset
  314.      *
  315.      * @param int $parentId
  316.      * @param array $data
  317.      * @param bool $save
  318.      *
  319.      * @return Asset
  320.      */
  321.     public static function create($parentId, $data = [], $save = true)
  322.     {
  324.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  325.         // (tree) is generated immediately after creating an image
  326.         $class = Asset::class;
  327.         if (array_key_exists('filename', $data) && (array_key_exists('data', $data) || array_key_exists('sourcePath', $data) || array_key_exists('stream', $data))) {
  328.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  329.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($data['filename']);
  330.                 if (array_key_exists('data', $data)) {
  331.                     File::put($tmpFile, $data['data']);
  332.                     $mimeType = Mime::detect($tmpFile);
  333.                     unlink($tmpFile);
  334.                 } else {
  335.                     $streamMeta = stream_get_meta_data($data['stream']);
  336.                     if (file_exists($streamMeta['uri'])) {
  337.                         // stream is a local file, so we don't have to write a tmp file
  338.                         $mimeType = Mime::detect($streamMeta['uri']);
  339.                     } else {
  340.                         // write a tmp file because the stream isn't a pointer to the local filesystem
  341.                         $isRewindable = @rewind($data['stream']);
  342.                         $dest = fopen($tmpFile, 'w+', false, File::getContext());
  343.                         stream_copy_to_stream($data['stream'], $dest);
  344.                         $mimeType = Mime::detect($tmpFile);
  346.                         if (!$isRewindable) {
  347.                             $data['stream'] = $dest;
  348.                         } else {
  349.                             fclose($dest);
  350.                             unlink($tmpFile);
  351.                         }
  352.                     }
  353.                 }
  354.             } else {
  355.                 $mimeType = Mime::detect($data['sourcePath'], $data['filename']);
  356.                 if (is_file($data['sourcePath'])) {
  357.                     $data['stream'] = fopen($data['sourcePath'], 'r', false, File::getContext());
  358.                 }
  360.                 unset($data['sourcePath']);
  361.             }
  363.             $type = self::getTypeFromMimeMapping($mimeType, $data['filename']);
  364.             $class = '\\Pimcore\\Model\\Asset\\' . ucfirst($type);
  365.             if (array_key_exists('type', $data)) {
  366.                 unset($data['type']);
  367.             }
  368.         }
  370.         /** @var Asset $asset */
  371.         $asset = self::getModelFactory()->build($class);
  372.         $asset->setParentId($parentId);
  373.         $asset->setValues($data);
  375.         if ($save) {
  376.             $asset->save();
  377.         }
  379.         return $asset;
  380.     }
  382.     /**
  383.      * @param array $config
  384.      *
  385.      * @return mixed
  386.      *
  387.      * @throws \Exception
  388.      */
  389.     public static function getList($config = [])
  390.     {
  391.         if (!\is_array($config)) {
  392.             throw new \Exception('Unable to initiate list class - please provide valid configuration array');
  393.         }
  395.         $listClass = Listing::class;
  397.         $list = self::getModelFactory()->build($listClass);
  398.         $list->setValues($config);
  400.         return $list;
  401.     }
  403.     /**
  404.      * @param array $config
  405.      *
  406.      * @return int total count
  407.      */
  408.     public static function getTotalCount($config = [])
  409.     {
  410.         $list = static::getList($config);
  411.         $count = $list->getTotalCount();
  413.         return $count;
  414.     }
  416.     /**
  417.      * returns the asset type of a filename and mimetype
  418.      *
  419.      * @param string $mimeType
  420.      * @param string $filename
  421.      *
  422.      * @return string
  423.      */
  424.     public static function getTypeFromMimeMapping($mimeType, $filename)
  425.     {
  426.         if ($mimeType == 'directory') {
  427.             return 'folder';
  428.         }
  430.         $type = null;
  432.         $mappings = [
  433.             'unknown' => ["/\.stp$/"],
  434.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/", "/\.wmf$/"],
  435.             'text' => ['/text/', '/xml$/'],
  436.             'audio' => ['/audio/'],
  437.             'video' => ['/video/'],
  438.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  439.             'archive' => ['/zip/', '/tar/'],
  440.         ];
  442.         foreach ($mappings as $assetType => $patterns) {
  443.             foreach ($patterns as $pattern) {
  444.                 if (preg_match($pattern, $mimeType . ' .'. File::getFileExtension($filename))) {
  445.                     $type = $assetType;
  446.                     break;
  447.                 }
  448.             }
  450.             // break at first match
  451.             if ($type) {
  452.                 break;
  453.             }
  454.         }
  456.         if (!$type) {
  457.             $type = 'unknown';
  458.         }
  460.         return $type;
  461.     }
  463.     /**
  464.      * Get full path to the asset on the filesystem
  465.      *
  466.      * @return string
  467.      */
  468.     public function getFileSystemPath()
  469.     {
  470.         return PIMCORE_ASSET_DIRECTORY . $this->getRealFullPath();
  471.     }
  473.     /**
  474.      * @return $this
  475.      *
  476.      * @throws \Exception
  477.      */
  478.     public function save()
  479.     {
  480.         // additional parameters (e.g. "versionNote" for the version note)
  481.         $params = [];
  482.         if (func_num_args() && is_array(func_get_arg(0))) {
  483.             $params = func_get_arg(0);
  484.         }
  486.         $isUpdate = false;
  487.         $differentOldPath = null;
  489.         try {
  490.             $preEvent = new AssetEvent($this, $params);
  492.             if ($this->getId()) {
  493.                 $isUpdate = true;
  494.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, $preEvent);
  495.             } else {
  496.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_ADD, $preEvent);
  497.             }
  499.             $params = $preEvent->getArguments();
  501.             $this->correctPath();
  503.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  504.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  505.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  506.             $maxRetries = 5;
  507.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  508.                 $this->beginTransaction();
  510.                 try {
  511.                     if (!$isUpdate) {
  512.                         $this->getDao()->create();
  513.                     }
  515.                     // get the old path from the database before the update is done
  516.                     $oldPath = null;
  517.                     if ($isUpdate) {
  518.                         $oldPath = $this->getDao()->getCurrentFullPath();
  519.                     }
  521.                     $this->update($params);
  523.                     // if the old path is different from the new path, update all children
  524.                     $updatedChildren = [];
  525.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  526.                         $oldFullPath = PIMCORE_ASSET_DIRECTORY . $oldPath;
  527.                         if (is_file($oldFullPath) || is_dir($oldFullPath)) {
  528.                             if (!@File::rename(PIMCORE_ASSET_DIRECTORY . $oldPath, $this->getFileSystemPath())) {
  529.                                 $error = error_get_last();
  530.                                 throw new \Exception('Unable to rename asset ' . $this->getId() . ' on the filesystem: ' . $oldFullPath . ' - Reason: ' . $error['message']);
  531.                             }
  532.                             $differentOldPath = $oldPath;
  533.                             $this->getDao()->updateWorkspaces();
  534.                             $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  535.                         }
  536.                     }
  538.                     // lastly create a new version if necessary
  539.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  540.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  541.                     if ($this->getType() != 'folder') {
  542.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  543.                     }
  545.                     $this->commit();
  547.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  548.                 } catch (\Exception $e) {
  549.                     try {
  550.                         $this->rollBack();
  551.                     } catch (\Exception $er) {
  552.                         // PDO adapter throws exceptions if rollback fails
  553.                         Logger::error($er);
  554.                     }
  556.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  557.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  558.                         $run = $retries + 1;
  559.                         $waitTime = rand(1, 5) * 100000; // microseconds
  560.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  562.                         usleep($waitTime); // wait specified time until we restart the transaction
  563.                     } else {
  564.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  565.                         throw $e;
  566.                     }
  567.                 }
  568.             }
  570.             $additionalTags = [];
  571.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  572.                 foreach ($updatedChildren as $assetId) {
  573.                     $tag = 'asset_' . $assetId;
  574.                     $additionalTags[] = $tag;
  576.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  577.                     \Pimcore\Cache\Runtime::set($tag, null);
  578.                 }
  579.             }
  580.             $this->clearDependentCache($additionalTags);
  581.             $this->setDataChanged(false);
  583.             if ($isUpdate) {
  584.                 $updateEvent = new AssetEvent($this);
  585.                 if ($differentOldPath) {
  586.                     $updateEvent->setArgument('oldPath', $differentOldPath);
  587.                 }
  588.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, $updateEvent);
  589.             } else {
  590.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD, new AssetEvent($this));
  591.             }
  593.             return $this;
  594.         } catch (\Exception $e) {
  595.             $failureEvent = new AssetEvent($this);
  596.             $failureEvent->setArgument('exception', $e);
  597.             if ($isUpdate) {
  598.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, $failureEvent);
  599.             } else {
  600.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD_FAILURE, $failureEvent);
  601.             }
  603.             throw $e;
  604.         }
  605.     }
  607.     /**
  608.      * @throws \Exception
  609.      */
  610.     public function correctPath()
  611.     {
  612.         // set path
  613.         if ($this->getId() != 1) { // not for the root node
  615.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  616.                 throw new \Exception("invalid filename '".$this->getKey()."' for asset with id [ " . $this->getId() . ' ]');
  617.             }
  619.             if ($this->getParentId() == $this->getId()) {
  620.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  621.             }
  623.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  624.                 throw new \Exception('Cannot create asset called ".." or "."');
  625.             }
  627.             $parent = Asset::getById($this->getParentId());
  628.             if ($parent) {
  629.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  630.                 // that is currently in the parent asset (in memory), because this might have changed but wasn't not saved
  631.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  632.             } else {
  633.                 // parent document doesn't exist anymore, set the parent to to root
  634.                 $this->setParentId(1);
  635.                 $this->setPath('/');
  636.             }
  637.         } elseif ($this->getId() == 1) {
  638.             // some data in root node should always be the same
  639.             $this->setParentId(0);
  640.             $this->setPath('/');
  641.             $this->setFilename('');
  642.             $this->setType('folder');
  643.         }
  645.         // do not allow PHP and .htaccess files
  646.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  647.             $this->setFilename($this->getFilename() . '.txt');
  648.         }
  650.         if (mb_strlen($this->getFilename()) > 255) {
  651.             throw new \Exception('Filenames longer than 255 characters are not allowed');
  652.         }
  654.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  655.             $duplicate = Asset::getByPath($this->getRealFullPath());
  656.             if ($duplicate instanceof Asset && $duplicate->getId() != $this->getId()) {
  657.                 throw new \Exception('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  658.             }
  659.         }
  661.         $this->validatePathLength();
  662.     }
  664.     /**
  665.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  666.      *
  667.      * @throws \Exception
  668.      */
  669.     protected function update($params = [])
  670.     {
  671.         $this->updateModificationInfos();
  673.         // create foldertree
  674.         // use current file name in order to prevent problems when filename has changed
  675.         // (otherwise binary data would be overwritten with old binary data with rename() in save method)
  676.         $destinationPathRelative = $this->getDao()->getCurrentFullPath();
  677.         if (!$destinationPathRelative) {
  678.             // this is happen during a restore from the recycle bin
  679.             $destinationPathRelative = $this->getRealFullPath();
  680.         }
  681.         $destinationPath = PIMCORE_ASSET_DIRECTORY . $destinationPathRelative;
  683.         $dirPath = dirname($destinationPath);
  684.         if (!is_dir($dirPath)) {
  685.             if (!File::mkdir($dirPath)) {
  686.                 throw new \Exception('Unable to create directory: '. $dirPath . ' for asset :' . $this->getId());
  687.             }
  688.         }
  690.         $typeChanged = false;
  692.         // fix for missing parent folders
  693.         // check if folder of new destination is already created and if not do so
  694.         $newPath = dirname($this->getFileSystemPath());
  695.         if (!is_dir($newPath)) {
  696.             if (!File::mkdir($newPath)) {
  697.                 throw new \Exception('Unable to create directory: '. $newPath . ' for asset :' . $this->getId());
  698.             }
  699.         }
  701.         if ($this->getType() != 'folder') {
  702.             if ($this->getDataChanged()) {
  703.                 $src = $this->getStream();
  704.                 $streamMeta = stream_get_meta_data($src);
  705.                 if ($destinationPath != $streamMeta['uri']) {
  706.                     if (file_exists($destinationPath)) {
  707.                         // We don't open a stream on existing files, because they could be possibly used by versions
  708.                         // using hardlinks, so it's safer to delete them first, so the inode and therefore also the
  709.                         // versioning information persists. Using the stream on the existing file would overwrite the
  710.                         // contents of the inode and therefore leads to wrong version data
  711.                         unlink($destinationPath);
  712.                     }
  714.                     $dest = fopen($destinationPath, 'w', false, File::getContext());
  715.                     if ($dest) {
  716.                         stream_copy_to_stream($src, $dest);
  717.                         if (!fclose($dest)) {
  718.                             throw new \Exception('Unable to close file handle ' . $destinationPath . ' for asset ' . $this->getId());
  719.                         }
  720.                     } else {
  721.                         throw new \Exception('Unable to open file: ' . $destinationPath . ' for asset ' . $this->getId());
  722.                     }
  723.                 }
  725.                 $this->stream = null; // set stream to null, so that the source stream isn't used anymore after saving
  727.                 @chmod($destinationPath, File::getDefaultMode());
  729.                 // check file exists
  730.                 if (!is_file($destinationPath)) {
  731.                     throw new \Exception("couldn't create new asset, file " . $destinationPath . " doesn't exist");
  732.                 }
  734.                 // set mime type
  735.                 $mimetype = Mime::detect($destinationPath, $this->getFilename());
  736.                 $this->setMimetype($mimetype);
  738.                 // set type
  739.                 $type = self::getTypeFromMimeMapping($mimetype, $this->getFilename());
  740.                 if ($type != $this->getType()) {
  741.                     $this->setType($type);
  742.                     $typeChanged = true;
  743.                 }
  745.                 // not only check if the type is set but also if the implementation can be found
  746.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  747.                 if (!self::getModelFactory()->supports($className)) {
  748.                     throw new \Exception('unable to resolve asset implementation with type: ' . $this->getType());
  749.                 }
  750.             }
  752.             // scheduled tasks are saved in $this->saveVersion();
  753.         } else {
  754.             if (!is_dir($destinationPath) && !is_dir($this->getFileSystemPath())) {
  755.                 if (!File::mkdir($this->getFileSystemPath())) {
  756.                     throw new \Exception('Unable to create directory: '. $this->getFileSystemPath() . ' for asset :' . $this->getId());
  757.                 }
  758.             }
  759.         }
  761.         if (!$this->getType()) {
  762.             $this->setType('unknown');
  763.         }
  765.         $this->postPersistData();
  767.         // save properties
  768.         $this->getProperties();
  769.         $this->getDao()->deleteAllProperties();
  770.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  771.             foreach ($this->getProperties() as $property) {
  772.                 if (!$property->getInherited()) {
  773.                     $property->setDao(null);
  774.                     $property->setCid($this->getId());
  775.                     $property->setCtype('asset');
  776.                     $property->setCpath($this->getRealFullPath());
  777.                     $property->save();
  778.                 }
  779.             }
  780.         }
  782.         // save dependencies
  783.         $d = new Dependency();
  784.         $d->setSourceType('asset');
  785.         $d->setSourceId($this->getId());
  787.         foreach ($this->resolveDependencies() as $requirement) {
  788.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  789.                 // dont't add a reference to yourself
  790.                 continue;
  791.             } else {
  792.                 $d->addRequirement($requirement['id'], $requirement['type']);
  793.             }
  794.         }
  795.         $d->save();
  797.         $this->getDao()->update();
  799.         //set asset to registry
  800.         $cacheKey = self::getCacheKey($this->getId());
  801.         \Pimcore\Cache\Runtime::set($cacheKey, $this);
  802.         if (get_class($this) == 'Asset' || $typeChanged) {
  803.             // get concrete type of asset
  804.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  805.             // the type (image, document, ...) depends on the mime-type
  806.             \Pimcore\Cache\Runtime::set($cacheKey, null);
  807.             Asset::getById($this->getId()); // call it to load it to the runtime cache again
  808.         }
  810.         $this->closeStream();
  811.     }
  813.     protected function postPersistData()
  814.     {
  815.         // hook for the save process, can be overwritten in implementations, such as Image
  816.     }
  818.     /**
  819.      * @param bool $setModificationDate
  820.      * @param bool $saveOnlyVersion
  821.      * @param string $versionNote version note
  822.      *
  823.      * @return null|Version
  824.      *
  825.      * @throws \Exception
  826.      */
  827.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  828.     {
  829.         try {
  830.             // hook should be also called if "save only new version" is selected
  831.             if ($saveOnlyVersion) {
  832.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, new AssetEvent($this, [
  833.                     'saveVersionOnly' => true
  834.                 ]));
  835.             }
  837.             // set date
  838.             if ($setModificationDate) {
  839.                 $this->setModificationDate(time());
  840.             }
  842.             // scheduled tasks are saved always, they are not versioned!
  843.             $this->saveScheduledTasks();
  845.             // create version
  846.             $version = null;
  848.             // only create a new version if there is at least 1 allowed
  849.             // or if saveVersion() was called directly (it's a newer version of the asset)
  850.             $assetsConfig = \Pimcore\Config::getSystemConfiguration('assets');
  851.             if (!empty($assetsConfig['versions']['steps'])
  852.                 || !empty($assetsConfig['versions']['days'])
  853.                 || $setModificationDate) {
  854.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion);
  855.             }
  857.             // hook should be also called if "save only new version" is selected
  858.             if ($saveOnlyVersion) {
  859.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, new AssetEvent($this, [
  860.                     'saveVersionOnly' => true
  861.                 ]));
  862.             }
  864.             return $version;
  865.         } catch (\Exception $e) {
  866.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, new AssetEvent($this, [
  867.                 'saveVersionOnly' => true,
  868.                 'exception' => $e
  869.             ]));
  871.             throw $e;
  872.         }
  873.     }
  875.     /**
  876.      * Returns the full path of the asset including the filename
  877.      *
  878.      * @return string
  879.      */
  880.     public function getFullPath()
  881.     {
  882.         $path = $this->getPath() . $this->getFilename();
  884.         if (\Pimcore\Tool::isFrontend()) {
  885.             $path = urlencode_ignore_slash($path);
  887.             $event = new GenericEvent($this, [
  888.                 'frontendPath' => $path
  889.             ]);
  890.             \Pimcore::getEventDispatcher()->dispatch(FrontendEvents::ASSET_PATH, $event);
  891.             $path = $event->getArgument('frontendPath');
  892.         }
  894.         return $path;
  895.     }
  897.     /**
  898.      * @return string
  899.      */
  900.     public function getRealPath()
  901.     {
  902.         return $this->path;
  903.     }
  905.     /**
  906.      * @return string
  907.      */
  908.     public function getRealFullPath()
  909.     {
  910.         $path = $this->getRealPath() . $this->getFilename();
  912.         return $path;
  913.     }
  915.     /**
  916.      * Get a list of the sibling assets
  917.      *
  918.      * @return array
  919.      */
  920.     public function getSiblings()
  921.     {
  922.         if ($this->siblings === null) {
  923.             $list = new Asset\Listing();
  924.             // string conversion because parentId could be 0
  925.             $list->addConditionParam('parentId = ?', (string)$this->getParentId());
  926.             $list->addConditionParam('id != ?', $this->getId());
  927.             $list->setOrderKey('filename');
  928.             $list->setOrder('asc');
  929.             $this->siblings = $list->getAssets();
  930.         }
  932.         return $this->siblings;
  933.     }
  935.     /**
  936.      * Returns true if the asset has at least one sibling
  937.      *
  938.      * @return bool
  939.      */
  940.     public function hasSiblings()
  941.     {
  942.         if (is_bool($this->hasSiblings)) {
  943.             if (($this->hasSiblings && empty($this->siblings)) || (!$this->hasSiblings && !empty($this->siblings))) {
  944.                 return $this->getDao()->hasSiblings();
  945.             } else {
  946.                 return $this->hasSiblings;
  947.             }
  948.         }
  950.         return $this->getDao()->hasSiblings();
  951.     }
  953.     /**
  954.      * @return bool
  955.      */
  956.     public function hasChildren()
  957.     {
  958.         return false;
  959.     }
  961.     /**
  962.      * @return Asset[]
  963.      */
  964.     public function getChildren()
  965.     {
  966.         return [];
  967.     }
  969.     /**
  970.      * enum('self','propagate') nullable
  971.      *
  972.      * @return string|null
  973.      */
  974.     public function getLocked()
  975.     {
  976.         return $this->locked;
  977.     }
  979.     /**
  980.      * enum('self','propagate') nullable
  981.      *
  982.      * @param string|null $locked
  983.      *
  984.      * @return $this
  985.      */
  986.     public function setLocked($locked)
  987.     {
  988.         $this->locked = $locked;
  990.         return $this;
  991.     }
  993.     /**
  994.      * Deletes file from filesystem
  995.      */
  996.     protected function deletePhysicalFile()
  997.     {
  998.         $fsPath = $this->getFileSystemPath();
  1000.         if ($this->getType() != 'folder') {
  1001.             if (is_file($fsPath) && is_writable($fsPath)) {
  1002.                 unlink($fsPath);
  1003.             }
  1004.         } else {
  1005.             if (is_dir($fsPath) && is_writable($fsPath)) {
  1006.                 recursiveDelete($fsPath, true);
  1007.             }
  1008.         }
  1009.     }
  1011.     /**
  1012.      * @param bool $isNested
  1013.      *
  1014.      * @throws \Exception
  1015.      */
  1016.     public function delete(bool $isNested = false)
  1017.     {
  1018.         if ($this->getId() == 1) {
  1019.             throw new \Exception('root-node cannot be deleted');
  1020.         }
  1022.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_DELETE, new AssetEvent($this));
  1024.         $this->beginTransaction();
  1026.         try {
  1027.             $this->closeStream();
  1029.             // remove children
  1030.             if ($this->hasChildren()) {
  1031.                 foreach ($this->getChildren() as $child) {
  1032.                     $child->delete(true);
  1033.                 }
  1034.             }
  1036.             $versions = $this->getVersions();
  1037.             foreach ($versions as $version) {
  1038.                 $version->delete();
  1039.             }
  1041.             // remove permissions
  1042.             $this->getDao()->deleteAllPermissions();
  1044.             // remove all properties
  1045.             $this->getDao()->deleteAllProperties();
  1047.             // remove all metadata
  1048.             $this->getDao()->deleteAllMetadata();
  1050.             // remove all tasks
  1051.             $this->getDao()->deleteAllTasks();
  1053.             // remove dependencies
  1054.             $d = $this->getDependencies();
  1055.             $d->cleanAllForElement($this);
  1057.             // remove from resource
  1058.             $this->getDao()->delete();
  1060.             $this->commit();
  1062.             // remove file on filesystem
  1063.             if (!$isNested) {
  1064.                 $fullPath = $this->getRealFullPath();
  1065.                 if ($fullPath != '/..' && !strpos($fullPath,
  1066.                         '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1067.                     $this->deletePhysicalFile();
  1068.                 }
  1069.             }
  1070.         } catch (\Exception $e) {
  1071.             $this->rollBack();
  1072.             $failureEvent = new AssetEvent($this);
  1073.             $failureEvent->setArgument('exception', $e);
  1074.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE_FAILURE, $failureEvent);
  1075.             Logger::crit($e);
  1076.             throw $e;
  1077.         }
  1079.         // empty asset cache
  1080.         $this->clearDependentCache();
  1082.         // clear asset from registry
  1083.         \Pimcore\Cache\Runtime::set(self::getCacheKey($this->getId()), null);
  1085.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE, new AssetEvent($this));
  1086.     }
  1088.     /**
  1089.      * @param array $additionalTags
  1090.      */
  1091.     public function clearDependentCache($additionalTags = [])
  1092.     {
  1093.         try {
  1094.             $tags = [$this->getCacheTag(), 'asset_properties', 'output'];
  1095.             $tags = array_merge($tags, $additionalTags);
  1097.             \Pimcore\Cache::clearTags($tags);
  1098.         } catch (\Exception $e) {
  1099.             Logger::crit($e);
  1100.         }
  1101.     }
  1103.     /**
  1104.      * @return Dependency
  1105.      */
  1106.     public function getDependencies()
  1107.     {
  1108.         if (!$this->dependencies) {
  1109.             $this->dependencies = Dependency::getBySourceId($this->getId(), 'asset');
  1110.         }
  1112.         return $this->dependencies;
  1113.     }
  1115.     /**
  1116.      * @return int
  1117.      */
  1118.     public function getCreationDate()
  1119.     {
  1120.         return $this->creationDate;
  1121.     }
  1123.     /**
  1124.      * @return int
  1125.      */
  1126.     public function getId()
  1127.     {
  1128.         return (int) $this->id;
  1129.     }
  1131.     /**
  1132.      * @return string
  1133.      */
  1134.     public function getFilename()
  1135.     {
  1136.         return (string) $this->filename;
  1137.     }
  1139.     /**
  1140.      * Alias for getFilename()
  1141.      *
  1142.      * @return string
  1143.      */
  1144.     public function getKey()
  1145.     {
  1146.         return $this->getFilename();
  1147.     }
  1149.     /**
  1150.      * @return int
  1151.      */
  1152.     public function getModificationDate()
  1153.     {
  1154.         return (int) $this->modificationDate;
  1155.     }
  1157.     /**
  1158.      * @return int
  1159.      */
  1160.     public function getParentId()
  1161.     {
  1162.         return $this->parentId;
  1163.     }
  1165.     /**
  1166.      * @return string
  1167.      */
  1168.     public function getPath()
  1169.     {
  1170.         return $this->path;
  1171.     }
  1173.     /**
  1174.      * @return string
  1175.      */
  1176.     public function getType()
  1177.     {
  1178.         return $this->type;
  1179.     }
  1181.     /**
  1182.      * @param int $creationDate
  1183.      *
  1184.      * @return $this
  1185.      */
  1186.     public function setCreationDate($creationDate)
  1187.     {
  1188.         $this->creationDate = (int) $creationDate;
  1190.         return $this;
  1191.     }
  1193.     /**
  1194.      * @param int $id
  1195.      *
  1196.      * @return $this
  1197.      */
  1198.     public function setId($id)
  1199.     {
  1200.         $this->id = (int) $id;
  1202.         return $this;
  1203.     }
  1205.     /**
  1206.      * @param string $filename
  1207.      *
  1208.      * @return $this
  1209.      */
  1210.     public function setFilename($filename)
  1211.     {
  1212.         $this->filename = (string) $filename;
  1214.         return $this;
  1215.     }
  1217.     /**
  1218.      * Alias for setFilename()
  1219.      *
  1220.      * @param string $key
  1221.      *
  1222.      * @return $this
  1223.      */
  1224.     public function setKey($key)
  1225.     {
  1226.         return $this->setFilename($key);
  1227.     }
  1229.     /**
  1230.      * @param int $modificationDate
  1231.      *
  1232.      * @return $this
  1233.      */
  1234.     public function setModificationDate($modificationDate)
  1235.     {
  1236.         $this->markFieldDirty('modificationDate');
  1238.         $this->modificationDate = (int) $modificationDate;
  1240.         return $this;
  1241.     }
  1243.     /**
  1244.      * @param int $parentId
  1245.      *
  1246.      * @return $this
  1247.      */
  1248.     public function setParentId($parentId)
  1249.     {
  1250.         $this->parentId = (int) $parentId;
  1251.         $this->parent = null;
  1253.         return $this;
  1254.     }
  1256.     /**
  1257.      * @param string $path
  1258.      *
  1259.      * @return $this
  1260.      */
  1261.     public function setPath($path)
  1262.     {
  1263.         $this->path = $path;
  1265.         return $this;
  1266.     }
  1268.     /**
  1269.      * @param string $type
  1270.      *
  1271.      * @return $this
  1272.      */
  1273.     public function setType($type)
  1274.     {
  1275.         $this->type = $type;
  1277.         return $this;
  1278.     }
  1280.     /**
  1281.      * @return mixed
  1282.      */
  1283.     public function getData()
  1284.     {
  1285.         $stream = $this->getStream();
  1286.         if ($stream) {
  1287.             return stream_get_contents($stream);
  1288.         }
  1290.         return '';
  1291.     }
  1293.     /**
  1294.      * @param mixed $data
  1295.      *
  1296.      * @return $this
  1297.      */
  1298.     public function setData($data)
  1299.     {
  1300.         $handle = tmpfile();
  1301.         fwrite($handle, $data);
  1302.         $this->setStream($handle);
  1304.         return $this;
  1305.     }
  1307.     /**
  1308.      * @return resource
  1309.      */
  1310.     public function getStream()
  1311.     {
  1312.         if ($this->stream) {
  1313.             $streamMeta = stream_get_meta_data($this->stream);
  1314.             if (!@rewind($this->stream) && $streamMeta['stream_type'] === 'STDIO') {
  1315.                 $this->stream = null;
  1316.             }
  1317.         }
  1319.         if (!$this->stream && $this->getType() != 'folder') {
  1320.             if (file_exists($this->getFileSystemPath())) {
  1321.                 $this->stream = fopen($this->getFileSystemPath(), 'r', false, File::getContext());
  1322.             } else {
  1323.                 $this->stream = tmpfile();
  1324.             }
  1325.         }
  1327.         return $this->stream;
  1328.     }
  1330.     /**
  1331.      * @param resource|null $stream
  1332.      *
  1333.      * @return $this
  1334.      */
  1335.     public function setStream($stream)
  1336.     {
  1337.         // close existing stream
  1338.         if ($stream !== $this->stream) {
  1339.             $this->closeStream();
  1340.         }
  1342.         if (is_resource($stream)) {
  1343.             $this->setDataChanged(true);
  1344.             $this->stream = $stream;
  1346.             $isRewindable = @rewind($this->stream);
  1348.             if (!$isRewindable) {
  1349.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($this->getFilename());
  1350.                 $dest = fopen($tmpFile, 'w+', false, File::getContext());
  1351.                 stream_copy_to_stream($this->stream, $dest);
  1352.                 $this->stream = $dest;
  1354.                 $this->_temporaryFiles[] = $tmpFile;
  1355.             }
  1356.         } elseif (is_null($stream)) {
  1357.             $this->stream = null;
  1358.         }
  1360.         return $this;
  1361.     }
  1363.     protected function closeStream()
  1364.     {
  1365.         if (is_resource($this->stream)) {
  1366.             @fclose($this->stream);
  1367.             $this->stream = null;
  1368.         }
  1369.     }
  1371.     /**
  1372.      * @param string $type
  1373.      *
  1374.      * @return null|string
  1375.      *
  1376.      * @throws \Exception
  1377.      */
  1378.     public function getChecksum($type = 'md5')
  1379.     {
  1380.         if (!in_array($type, hash_algos())) {
  1381.             throw new \Exception(sprintf('Hashing algorithm `%s` is not supported', $type));
  1382.         }
  1384.         $file = $this->getFileSystemPath();
  1385.         if (is_file($file)) {
  1386.             return hash_file($type, $file);
  1387.         } elseif (\is_resource($this->getStream())) {
  1388.             return hash($type, $this->getData());
  1389.         }
  1391.         return null;
  1392.     }
  1394.     /**
  1395.      * @return bool
  1396.      */
  1397.     public function getDataChanged()
  1398.     {
  1399.         return $this->_dataChanged;
  1400.     }
  1402.     /**
  1403.      * @param bool $changed
  1404.      *
  1405.      * @return $this
  1406.      */
  1407.     public function setDataChanged($changed = true)
  1408.     {
  1409.         $this->_dataChanged = $changed;
  1411.         return $this;
  1412.     }
  1414.     /**
  1415.      * @return Property[]
  1416.      */
  1417.     public function getProperties()
  1418.     {
  1419.         if ($this->properties === null) {
  1420.             // try to get from cache
  1421.             $cacheKey = 'asset_properties_' . $this->getId();
  1422.             $properties = \Pimcore\Cache::load($cacheKey);
  1423.             if (!is_array($properties)) {
  1424.                 $properties = $this->getDao()->getProperties();
  1425.                 $elementCacheTag = $this->getCacheTag();
  1426.                 $cacheTags = ['asset_properties' => 'asset_properties', $elementCacheTag => $elementCacheTag];
  1427.                 \Pimcore\Cache::save($properties, $cacheKey, $cacheTags);
  1428.             }
  1430.             $this->setProperties($properties);
  1431.         }
  1433.         return $this->properties;
  1434.     }
  1436.     /**
  1437.      * @param Property[] $properties
  1438.      *
  1439.      * @return $this
  1440.      */
  1441.     public function setProperties($properties)
  1442.     {
  1443.         $this->properties = $properties;
  1445.         return $this;
  1446.     }
  1448.     /**
  1449.      * @param string $name
  1450.      * @param string $type
  1451.      * @param mixed $data
  1452.      * @param bool $inherited
  1453.      * @param bool $inheritable
  1454.      *
  1455.      * @return $this
  1456.      */
  1457.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1458.     {
  1459.         $this->getProperties();
  1461.         $property = new Property();
  1462.         $property->setType($type);
  1463.         $property->setCid($this->getId());
  1464.         $property->setName($name);
  1465.         $property->setCtype('asset');
  1466.         $property->setData($data);
  1467.         $property->setInherited($inherited);
  1468.         $property->setInheritable($inheritable);
  1470.         $this->properties[$name] = $property;
  1472.         return $this;
  1473.     }
  1475.     /**
  1476.      * @return int
  1477.      */
  1478.     public function getUserOwner()
  1479.     {
  1480.         return $this->userOwner;
  1481.     }
  1483.     /**
  1484.      * @return int
  1485.      */
  1486.     public function getUserModification()
  1487.     {
  1488.         return $this->userModification;
  1489.     }
  1491.     /**
  1492.      * @param int $userOwner
  1493.      *
  1494.      * @return $this
  1495.      */
  1496.     public function setUserOwner($userOwner)
  1497.     {
  1498.         $this->userOwner = (int) $userOwner;
  1500.         return $this;
  1501.     }
  1503.     /**
  1504.      * @param int $userModification
  1505.      *
  1506.      * @return $this
  1507.      */
  1508.     public function setUserModification($userModification)
  1509.     {
  1510.         $this->markFieldDirty('userModification');
  1512.         $this->userModification = (int) $userModification;
  1514.         return $this;
  1515.     }
  1517.     /**
  1518.      * @return Version[]
  1519.      */
  1520.     public function getVersions()
  1521.     {
  1522.         if ($this->versions === null) {
  1523.             $this->setVersions($this->getDao()->getVersions());
  1524.         }
  1526.         return $this->versions;
  1527.     }
  1529.     /**
  1530.      * @param Version[] $versions
  1531.      *
  1532.      * @return $this
  1533.      */
  1534.     public function setVersions($versions)
  1535.     {
  1536.         $this->versions = $versions;
  1538.         return $this;
  1539.     }
  1541.     /**
  1542.      * returns the path to a temp file
  1543.      *
  1544.      * @return string
  1545.      */
  1546.     public function getTemporaryFile()
  1547.     {
  1548.         $destinationPath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-temporary/asset_' . $this->getId() . '_' . md5(microtime()) . '__' . $this->getFilename();
  1549.         if (!is_dir(dirname($destinationPath))) {
  1550.             File::mkdir(dirname($destinationPath));
  1551.         }
  1553.         $src = $this->getStream();
  1554.         $dest = fopen($destinationPath, 'w+', false, File::getContext());
  1555.         stream_copy_to_stream($src, $dest);
  1556.         fclose($dest);
  1558.         @chmod($destinationPath, File::getDefaultMode());
  1560.         $this->_temporaryFiles[] = $destinationPath;
  1562.         return $destinationPath;
  1563.     }
  1565.     /**
  1566.      * @param string $key
  1567.      * @param mixed $value
  1568.      *
  1569.      * @return $this
  1570.      */
  1571.     public function setCustomSetting($key, $value)
  1572.     {
  1573.         $this->customSettings[$key] = $value;
  1575.         return $this;
  1576.     }
  1578.     /**
  1579.      * @param string $key
  1580.      *
  1581.      * @return mixed
  1582.      */
  1583.     public function getCustomSetting($key)
  1584.     {
  1585.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1586.             return $this->customSettings[$key];
  1587.         }
  1589.         return null;
  1590.     }
  1592.     /**
  1593.      * @param string $key
  1594.      */
  1595.     public function removeCustomSetting($key)
  1596.     {
  1597.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1598.             unset($this->customSettings[$key]);
  1599.         }
  1600.     }
  1602.     /**
  1603.      * @return array
  1604.      */
  1605.     public function getCustomSettings()
  1606.     {
  1607.         return $this->customSettings;
  1608.     }
  1610.     /**
  1611.      * @param array $customSettings
  1612.      *
  1613.      * @return $this
  1614.      */
  1615.     public function setCustomSettings($customSettings)
  1616.     {
  1617.         if (is_string($customSettings)) {
  1618.             $customSettings = \Pimcore\Tool\Serialize::unserialize($customSettings);
  1619.         }
  1621.         if ($customSettings instanceof \stdClass) {
  1622.             $customSettings = (array) $customSettings;
  1623.         }
  1625.         if (!is_array($customSettings)) {
  1626.             $customSettings = [];
  1627.         }
  1629.         $this->customSettings = $customSettings;
  1631.         return $this;
  1632.     }
  1634.     /**
  1635.      * @return string
  1636.      */
  1637.     public function getMimetype()
  1638.     {
  1639.         return $this->mimetype;
  1640.     }
  1642.     /**
  1643.      * @param string $mimetype
  1644.      *
  1645.      * @return $this
  1646.      */
  1647.     public function setMimetype($mimetype)
  1648.     {
  1649.         $this->mimetype = $mimetype;
  1651.         return $this;
  1652.     }
  1654.     /**
  1655.      * @param array|\stdClass[] $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1656.      *
  1657.      * @return self
  1658.      */
  1659.     public function setMetadata($metadata)
  1660.     {
  1661.         $this->metadata = [];
  1662.         $this->setHasMetaData(false);
  1663.         if (!empty($metadata)) {
  1664.             foreach ((array)$metadata as $metaItem) {
  1665.                 $metaItem = (array)$metaItem; // also allow object with appropriate keys (as it comes from Pimcore\Model\Webservice\Data\Asset\reverseMap)
  1666.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1667.             }
  1668.         }
  1670.         return $this;
  1671.     }
  1673.     /**
  1674.      * @return bool
  1675.      */
  1676.     public function getHasMetaData()
  1677.     {
  1678.         return $this->hasMetaData;
  1679.     }
  1681.     /**
  1682.      * @param bool $hasMetaData
  1683.      *
  1684.      * @return self
  1685.      */
  1686.     public function setHasMetaData($hasMetaData)
  1687.     {
  1688.         $this->hasMetaData = (bool) $hasMetaData;
  1690.         return $this;
  1691.     }
  1693.     /**
  1694.      * @param string $name
  1695.      * @param string $type can be "folder", "image", "input", "audio", "video", "document", "archive" or "unknown"
  1696.      * @param mixed $data
  1697.      * @param string|null $language
  1698.      *
  1699.      * @return self
  1700.      */
  1701.     public function addMetadata($name, $type, $data = null, $language = null)
  1702.     {
  1703.         if ($name && $type) {
  1704.             $tmp = [];
  1705.             $name = str_replace('~', '---', $name);
  1706.             if (!is_array($this->metadata)) {
  1707.                 $this->metadata = [];
  1708.             }
  1710.             foreach ($this->metadata as $item) {
  1711.                 if ($item['name'] != $name || $language != $item['language']) {
  1712.                     $tmp[] = $item;
  1713.                 }
  1714.             }
  1715.             $tmp[] = [
  1716.                 'name' => $name,
  1717.                 'type' => $type,
  1718.                 'data' => $data,
  1719.                 'language' => $language
  1720.             ];
  1721.             $this->metadata = $tmp;
  1723.             $this->setHasMetaData(true);
  1724.         }
  1726.         return $this;
  1727.     }
  1729.     /**
  1730.      * @param string|null $name
  1731.      * @param string|null $language
  1732.      * @param bool $strictMatch
  1733.      *
  1734.      * @return array|string|null
  1735.      */
  1736.     public function getMetadata($name = null, $language = null, $strictMatch = false)
  1737.     {
  1738.         $convert = function ($metaData) {
  1739.             if (in_array($metaData['type'], ['asset', 'document', 'object']) && is_numeric($metaData['data'])) {
  1740.                 return Element\Service::getElementById($metaData['type'], $metaData['data']);
  1741.             }
  1743.             return $metaData['data'];
  1744.         };
  1746.         if ($name) {
  1747.             if ($language === null) {
  1748.                 $language = \Pimcore::getContainer()->get('pimcore.locale')->findLocale();
  1749.             }
  1751.             $data = null;
  1752.             foreach ($this->metadata as $md) {
  1753.                 if ($md['name'] == $name) {
  1754.                     if ($language == $md['language']) {
  1755.                         return $convert($md);
  1756.                     }
  1757.                     if (empty($md['language']) && !$strictMatch) {
  1758.                         $data = $md;
  1759.                     }
  1760.                 }
  1761.             }
  1763.             if ($data) {
  1764.                 return $convert($data);
  1765.             }
  1767.             return null;
  1768.         }
  1770.         $metaData = $this->getObjectVar('metadata');
  1771.         if (is_array($metaData)) {
  1772.             foreach ($metaData as &$md) {
  1773.                 $md = (array)$md;
  1774.                 $md['data'] = $convert($md);
  1775.             }
  1776.         }
  1778.         return $metaData;
  1779.     }
  1781.     /**
  1782.      * @return Schedule\Task[]
  1783.      */
  1784.     public function getScheduledTasks()
  1785.     {
  1786.         if ($this->scheduledTasks === null) {
  1787.             $taskList = new Schedule\Task\Listing();
  1788.             $taskList->setCondition("cid = ? AND ctype='asset'", $this->getId());
  1789.             $this->setScheduledTasks($taskList->load());
  1790.         }
  1792.         return $this->scheduledTasks;
  1793.     }
  1795.     /**
  1796.      * @param array $scheduledTasks
  1797.      *
  1798.      * @return $this
  1799.      */
  1800.     public function setScheduledTasks($scheduledTasks)
  1801.     {
  1802.         $this->scheduledTasks = $scheduledTasks;
  1804.         return $this;
  1805.     }
  1807.     public function saveScheduledTasks()
  1808.     {
  1809.         $this->getScheduledTasks();
  1810.         $this->getDao()->deleteAllTasks();
  1812.         if (is_array($this->getScheduledTasks()) && count($this->getScheduledTasks()) > 0) {
  1813.             foreach ($this->getScheduledTasks() as $task) {
  1814.                 $task->setId(null);
  1815.                 $task->setDao(null);
  1816.                 $task->setCid($this->getId());
  1817.                 $task->setCtype('asset');
  1818.                 $task->save();
  1819.             }
  1820.         }
  1821.     }
  1823.     /**
  1824.      * Get filesize
  1825.      *
  1826.      * @param bool $formatted
  1827.      * @param int $precision
  1828.      *
  1829.      * @return string|int
  1830.      */
  1831.     public function getFileSize($formatted = false, $precision = 2)
  1832.     {
  1833.         $bytes = 0;
  1834.         if (is_file($this->getFileSystemPath())) {
  1835.             $bytes = filesize($this->getFileSystemPath());
  1836.         }
  1838.         if ($formatted) {
  1839.             return formatBytes($bytes, $precision);
  1840.         }
  1842.         return $bytes;
  1843.     }
  1845.     /**
  1846.      * @return Asset
  1847.      */
  1848.     public function getParent()
  1849.     {
  1850.         if ($this->parent === null) {
  1851.             $this->setParent(Asset::getById($this->getParentId()));
  1852.         }
  1854.         return $this->parent;
  1855.     }
  1857.     /**
  1858.      * @param Asset $parent
  1859.      *
  1860.      * @return $this
  1861.      */
  1862.     public function setParent($parent)
  1863.     {
  1864.         $this->parent = $parent;
  1865.         if ($parent instanceof Asset) {
  1866.             $this->parentId = $parent->getId();
  1867.         }
  1869.         return $this;
  1870.     }
  1872.     /**
  1873.      * @return string
  1874.      */
  1875.     public function getImageThumbnailSavePath()
  1876.     {
  1877.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/image-thumbnails' . $this->getRealPath();
  1878.         $path = rtrim($path, '/');
  1880.         return $path;
  1881.     }
  1883.     /**
  1884.      * @return string
  1885.      */
  1886.     public function getVideoThumbnailSavePath()
  1887.     {
  1888.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/video-thumbnails' . $this->getRealPath();
  1889.         $path = rtrim($path, '/');
  1891.         return $path;
  1892.     }
  1894.     public function __sleep()
  1895.     {
  1896.         $finalVars = [];
  1897.         $parentVars = parent::__sleep();
  1898.         $blockedVars = ['_temporaryFiles', 'scheduledTasks', 'dependencies', '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.         foreach ($parentVars as $key) {
  1909.             if (!in_array($key, $blockedVars)) {
  1910.                 $finalVars[] = $key;
  1911.             }
  1912.         }
  1914.         return $finalVars;
  1915.     }
  1917.     public function __wakeup()
  1918.     {
  1919.         if ($this->isInDumpState()) {
  1920.             // set current key and path this is necessary because the serialized data can have a different path than the original element (element was renamed or moved)
  1921.             $originalElement = Asset::getById($this->getId());
  1922.             if ($originalElement) {
  1923.                 $this->setFilename($originalElement->getFilename());
  1924.                 $this->setPath($originalElement->getRealPath());
  1925.             }
  1926.         }
  1928.         if ($this->isInDumpState() && $this->properties !== null) {
  1929.             $this->renewInheritedProperties();
  1930.         }
  1932.         $this->setInDumpState(false);
  1933.     }
  1935.     public function removeInheritedProperties()
  1936.     {
  1937.         $myProperties = $this->getProperties();
  1939.         if ($myProperties) {
  1940.             foreach ($this->getProperties() as $name => $property) {
  1941.                 if ($property->getInherited()) {
  1942.                     unset($myProperties[$name]);
  1943.                 }
  1944.             }
  1945.         }
  1947.         $this->setProperties($myProperties);
  1948.     }
  1950.     public function renewInheritedProperties()
  1951.     {
  1952.         $this->removeInheritedProperties();
  1954.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  1955.         $cacheKey = self::getCacheKey($this->getId());
  1956.         if (!\Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  1957.             \Pimcore\Cache\Runtime::set($cacheKey, $this);
  1958.         }
  1960.         $myProperties = $this->getProperties();
  1961.         $inheritedProperties = $this->getDao()->getProperties(true);
  1962.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  1963.     }
  1965.     public function __destruct()
  1966.     {
  1967.         // close open streams
  1968.         $this->closeStream();
  1970.         // delete temporary files
  1971.         foreach ($this->_temporaryFiles as $tempFile) {
  1972.             if (file_exists($tempFile)) {
  1973.                 @unlink($tempFile);
  1974.             }
  1975.         }
  1976.     }
  1978.     /**
  1979.      * @return int
  1980.      */
  1981.     public function getVersionCount(): int
  1982.     {
  1983.         return $this->versionCount ? $this->versionCount : 0;
  1984.     }
  1986.     /**
  1987.      * @param int|null $versionCount
  1988.      *
  1989.      * @return Asset
  1990.      */
  1991.     public function setVersionCount(?int $versionCount): ElementInterface
  1992.     {
  1993.         $this->versionCount = (int) $versionCount;
  1995.         return $this;
  1996.     }
  1998.     /**
  1999.      * @inheritdoc
  2000.      */
  2001.     public function resolveDependencies()
  2002.     {
  2003.         $dependencies = parent::resolveDependencies();
  2005.         if ($this->hasMetaData) {
  2006.             $metaData = $this->getMetadata();
  2008.             foreach ($metaData as $md) {
  2009.                 if (isset($md['data']) && $md['data'] instanceof ElementInterface) {
  2010.                     /** @var ElementInterface $elementData */
  2011.                     $elementData = $md['data'];
  2012.                     $elementType = $md['type'];
  2013.                     $key = $elementType . '_' . $elementData->getId();
  2014.                     $dependencies[$key] = [
  2015.                         'id' => $elementData->getId(),
  2016.                         'type' => $elementType
  2017.                     ];
  2018.                 }
  2019.             }
  2020.         }
  2022.         return $dependencies;
  2023.     }
  2025.     public function __clone()
  2026.     {
  2027.         parent::__clone();
  2028.         $this->parent = null;
  2029.         $this->versions = null;
  2030.         $this->hasSiblings = null;
  2031.         $this->siblings = null;
  2032.         $this->dependencies = null;
  2033.         $this->scheduledTasks = null;
  2034.         $this->closeStream();
  2035.     }
  2036. }