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

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\Loader\ImplementationLoader\Exception\UnsupportedException;
  26. use Pimcore\Logger;
  27. use Pimcore\Model\Asset\Listing;
  28. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\Data;
  29. use Pimcore\Model\Asset\MetaData\ClassDefinition\Data\DataDefinitionInterface;
  30. use Pimcore\Model\Element\ElementInterface;
  31. use Pimcore\Tool;
  32. use Pimcore\Tool\Mime;
  33. use Symfony\Component\EventDispatcher\GenericEvent;
  35. /**
  36.  * @method \Pimcore\Model\Asset\Dao getDao()
  37.  * @method bool __isBasedOnLatestData()
  38.  * @method int getChildAmount($user = null)
  39.  * @method string|null getCurrentFullPath()
  40.  */
  41. class Asset extends Element\AbstractElement
  42. {
  43.     /**
  44.      * possible types of an asset
  45.      *
  46.      * @var array
  47.      */
  48.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  50.     /**
  51.      * Unique ID
  52.      *
  53.      * @var int
  54.      */
  55.     protected $id;
  57.     /**
  58.      * ID of the parent asset
  59.      *
  60.      * @var int
  61.      */
  62.     protected $parentId;
  64.     /**
  65.      * @var Asset|null
  66.      */
  67.     protected $parent;
  69.     /**
  70.      * Type
  71.      *
  72.      * @var string
  73.      */
  74.     protected $type;
  76.     /**
  77.      * Name of the file
  78.      *
  79.      * @var string
  80.      */
  81.     protected $filename;
  83.     /**
  84.      * Path of the file, without the filename, only the full path of the parent asset
  85.      *
  86.      * @var string
  87.      */
  88.     protected $path;
  90.     /**
  91.      * Mime-Type of the file
  92.      *
  93.      * @var string
  94.      */
  95.     protected $mimetype;
  97.     /**
  98.      * Timestamp of creation
  99.      *
  100.      * @var int
  101.      */
  102.     protected $creationDate;
  104.     /**
  105.      * Timestamp of modification
  106.      *
  107.      * @var int
  108.      */
  109.     protected $modificationDate;
  111.     /**
  112.      * @var resource|null
  113.      */
  114.     protected $stream;
  116.     /**
  117.      * ID of the owner user
  118.      *
  119.      * @var int
  120.      */
  121.     protected $userOwner;
  123.     /**
  124.      * ID of the user who make the latest changes
  125.      *
  126.      * @var int
  127.      */
  128.     protected $userModification;
  130.     /**
  131.      * List of properties
  132.      *
  133.      * @var array
  134.      */
  135.     protected $properties = null;
  137.     /**
  138.      * List of versions
  139.      *
  140.      * @var array|null
  141.      */
  142.     protected $versions = null;
  144.     /**
  145.      * @var array
  146.      */
  147.     protected $metadata = [];
  149.     /**
  150.      * enum('self','propagate') nullable
  151.      *
  152.      * @var string|null
  153.      */
  154.     protected $locked;
  156.     /**
  157.      * List of some custom settings  [key] => value
  158.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  159.      *
  160.      * @var array
  161.      */
  162.     protected $customSettings = [];
  164.     /**
  165.      * @var bool
  166.      */
  167.     protected $hasMetaData = false;
  169.     /**
  170.      * Contains a list of sibling documents
  171.      *
  172.      * @var array|null
  173.      */
  174.     protected $siblings;
  176.     /**
  177.      * Indicator if document has siblings or not
  178.      *
  179.      * @var bool|null
  180.      */
  181.     protected $hasSiblings;
  183.     /**
  184.      * Contains all scheduled tasks
  185.      *
  186.      * @var array|null
  187.      */
  188.     protected $scheduledTasks = null;
  190.     /**
  191.      * Indicator if data has changed
  192.      *
  193.      * @var bool
  194.      */
  195.     protected $_dataChanged = false;
  197.     /**
  198.      * @var int
  199.      */
  200.     protected $versionCount;
  202.     /**
  203.      * @var string[]
  204.      */
  205.     protected $_temporaryFiles = [];
  207.     /**
  208.      *
  209.      * @return array
  210.      */
  211.     public static function getTypes()
  212.     {
  213.         return self::$types;
  214.     }
  216.     /**
  217.      * Static helper to get an asset by the passed path
  218.      *
  219.      * @param string $path
  220.      * @param bool $force
  221.      *
  222.      * @return static|null
  223.      */
  224.     public static function getByPath($path, $force = false)
  225.     {
  226.         $path = Element\Service::correctPath($path);
  228.         try {
  229.             $asset = new Asset();
  230.             $asset->getDao()->getByPath($path);
  232.             return static::getById($asset->getId(), $force);
  233.         } catch (\Exception $e) {
  234.             return null;
  235.         }
  236.     }
  238.     /**
  239.      * @param Asset $asset
  240.      *
  241.      * @return bool
  242.      */
  243.     protected static function typeMatch(Asset $asset)
  244.     {
  245.         $staticType = get_called_class();
  246.         if ($staticType != Asset::class) {
  247.             if (!$asset instanceof $staticType) {
  248.                 return false;
  249.             }
  250.         }
  252.         return true;
  253.     }
  255.     /**
  256.      * Static helper to get an asset by the passed ID
  257.      *
  258.      * @param int $id
  259.      * @param bool $force
  260.      *
  261.      * @return static|null
  262.      */
  263.     public static function getById($id, $force = false)
  264.     {
  265.         if (!is_numeric($id) || $id < 1) {
  266.             return null;
  267.         }
  269.         $id = intval($id);
  270.         $cacheKey = self::getCacheKey($id);
  272.         if (!$force && \Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  273.             $asset = \Pimcore\Cache\Runtime::get($cacheKey);
  274.             if ($asset && static::typeMatch($asset)) {
  275.                 return $asset;
  276.             }
  277.         }
  279.         try {
  280.             if ($force || !($asset = \Pimcore\Cache::load($cacheKey))) {
  281.                 $asset = new Asset();
  282.                 $asset->getDao()->getById($id);
  284.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  286.                 /** @var Asset $asset */
  287.                 $asset = self::getModelFactory()->build($className);
  288.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  289.                 $asset->getDao()->getById($id);
  290.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  292.                 $asset->resetDirtyMap();
  294.                 \Pimcore\Cache::save($asset, $cacheKey);
  295.             } else {
  296.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  297.             }
  298.         } catch (\Exception $e) {
  299.             return null;
  300.         }
  302.         if (!$asset || !static::typeMatch($asset)) {
  303.             return null;
  304.         }
  306.         return $asset;
  307.     }
  309.     /**
  310.      * Helper to quickly create a new asset
  311.      *
  312.      * @param int $parentId
  313.      * @param array $data
  314.      * @param bool $save
  315.      *
  316.      * @return Asset
  317.      */
  318.     public static function create($parentId, $data = [], $save = true)
  319.     {
  321.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  322.         // (tree) is generated immediately after creating an image
  323.         $class = Asset::class;
  324.         if (array_key_exists('filename', $data) && (array_key_exists('data', $data) || array_key_exists('sourcePath', $data) || array_key_exists('stream', $data))) {
  325.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  326.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($data['filename']);
  327.                 if (array_key_exists('data', $data)) {
  328.                     File::put($tmpFile, $data['data']);
  329.                     $mimeType = Mime::detect($tmpFile);
  330.                     unlink($tmpFile);
  331.                 } else {
  332.                     $streamMeta = stream_get_meta_data($data['stream']);
  333.                     if (file_exists($streamMeta['uri'])) {
  334.                         // stream is a local file, so we don't have to write a tmp file
  335.                         $mimeType = Mime::detect($streamMeta['uri']);
  336.                     } else {
  337.                         // write a tmp file because the stream isn't a pointer to the local filesystem
  338.                         $isRewindable = @rewind($data['stream']);
  339.                         $dest = fopen($tmpFile, 'w+', false, File::getContext());
  340.                         stream_copy_to_stream($data['stream'], $dest);
  341.                         $mimeType = Mime::detect($tmpFile);
  343.                         if (!$isRewindable) {
  344.                             $data['stream'] = $dest;
  345.                         } else {
  346.                             fclose($dest);
  347.                             unlink($tmpFile);
  348.                         }
  349.                     }
  350.                 }
  351.             } else {
  352.                 $mimeType = Mime::detect($data['sourcePath'], $data['filename']);
  353.                 if (is_file($data['sourcePath'])) {
  354.                     $data['stream'] = fopen($data['sourcePath'], 'r', false, File::getContext());
  355.                 }
  357.                 unset($data['sourcePath']);
  358.             }
  360.             $type = self::getTypeFromMimeMapping($mimeType, $data['filename']);
  361.             $class = '\\Pimcore\\Model\\Asset\\' . ucfirst($type);
  362.             if (array_key_exists('type', $data)) {
  363.                 unset($data['type']);
  364.             }
  365.         }
  367.         /** @var Asset $asset */
  368.         $asset = self::getModelFactory()->build($class);
  369.         $asset->setParentId($parentId);
  370.         $asset->setValues($data);
  372.         if ($save) {
  373.             $asset->save();
  374.         }
  376.         return $asset;
  377.     }
  379.     /**
  380.      * @param array $config
  381.      *
  382.      * @return mixed
  383.      *
  384.      * @throws \Exception
  385.      */
  386.     public static function getList($config = [])
  387.     {
  388.         if (!\is_array($config)) {
  389.             throw new \Exception('Unable to initiate list class - please provide valid configuration array');
  390.         }
  392.         $listClass = Listing::class;
  394.         $list = self::getModelFactory()->build($listClass);
  395.         $list->setValues($config);
  397.         return $list;
  398.     }
  400.     /**
  401.      * @param array $config
  402.      *
  403.      * @return int total count
  404.      */
  405.     public static function getTotalCount($config = [])
  406.     {
  407.         $list = static::getList($config);
  408.         $count = $list->getTotalCount();
  410.         return $count;
  411.     }
  413.     /**
  414.      * returns the asset type of a filename and mimetype
  415.      *
  416.      * @param string $mimeType
  417.      * @param string $filename
  418.      *
  419.      * @return string
  420.      */
  421.     public static function getTypeFromMimeMapping($mimeType, $filename)
  422.     {
  423.         if ($mimeType == 'directory') {
  424.             return 'folder';
  425.         }
  427.         $type = null;
  429.         $mappings = [
  430.             'unknown' => ["/\.stp$/"],
  431.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/", "/\.wmf$/"],
  432.             'text' => ['/text/', '/xml$/'],
  433.             'audio' => ['/audio/'],
  434.             'video' => ['/video/'],
  435.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  436.             'archive' => ['/zip/', '/tar/'],
  437.         ];
  439.         foreach ($mappings as $assetType => $patterns) {
  440.             foreach ($patterns as $pattern) {
  441.                 if (preg_match($pattern, $mimeType . ' .' . File::getFileExtension($filename))) {
  442.                     $type = $assetType;
  443.                     break;
  444.                 }
  445.             }
  447.             // break at first match
  448.             if ($type) {
  449.                 break;
  450.             }
  451.         }
  453.         if (!$type) {
  454.             $type = 'unknown';
  455.         }
  457.         return $type;
  458.     }
  460.     /**
  461.      * Get full path to the asset on the filesystem
  462.      *
  463.      * @return string
  464.      */
  465.     public function getFileSystemPath()
  466.     {
  467.         return PIMCORE_ASSET_DIRECTORY . $this->getRealFullPath();
  468.     }
  470.     /**
  471.      * @return $this
  472.      *
  473.      * @throws \Exception
  474.      */
  475.     public function save()
  476.     {
  477.         // additional parameters (e.g. "versionNote" for the version note)
  478.         $params = [];
  479.         if (func_num_args() && is_array(func_get_arg(0))) {
  480.             $params = func_get_arg(0);
  481.         }
  483.         $isUpdate = false;
  484.         $differentOldPath = null;
  486.         try {
  487.             $preEvent = new AssetEvent($this, $params);
  489.             if ($this->getId()) {
  490.                 $isUpdate = true;
  491.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, $preEvent);
  492.             } else {
  493.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_ADD, $preEvent);
  494.             }
  496.             $params = $preEvent->getArguments();
  498.             $this->correctPath();
  500.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  501.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  502.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  503.             $maxRetries = 5;
  504.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  505.                 $this->beginTransaction();
  507.                 try {
  508.                     if (!$isUpdate) {
  509.                         $this->getDao()->create();
  510.                     }
  512.                     // get the old path from the database before the update is done
  513.                     $oldPath = null;
  514.                     if ($isUpdate) {
  515.                         $oldPath = $this->getDao()->getCurrentFullPath();
  516.                     }
  518.                     $this->update($params);
  520.                     // if the old path is different from the new path, update all children
  521.                     $updatedChildren = [];
  522.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  523.                         $oldFullPath = PIMCORE_ASSET_DIRECTORY . $oldPath;
  524.                         if (is_file($oldFullPath) || is_dir($oldFullPath)) {
  525.                             if (!@File::rename(PIMCORE_ASSET_DIRECTORY . $oldPath, $this->getFileSystemPath())) {
  526.                                 $error = error_get_last();
  527.                                 throw new \Exception('Unable to rename asset ' . $this->getId() . ' on the filesystem: ' . $oldFullPath . ' - Reason: ' . $error['message']);
  528.                             }
  529.                             $differentOldPath = $oldPath;
  530.                             $this->getDao()->updateWorkspaces();
  531.                             $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  532.                         }
  533.                     }
  535.                     // lastly create a new version if necessary
  536.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  537.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  538.                     if ($this->getType() != 'folder') {
  539.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  540.                     }
  542.                     $this->commit();
  544.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  545.                 } catch (\Exception $e) {
  546.                     try {
  547.                         $this->rollBack();
  548.                     } catch (\Exception $er) {
  549.                         // PDO adapter throws exceptions if rollback fails
  550.                         Logger::error($er);
  551.                     }
  553.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  554.                     if ($e instanceof DeadlockException && $retries < ($maxRetries - 1)) {
  555.                         $run = $retries + 1;
  556.                         $waitTime = rand(1, 5) * 100000; // microseconds
  557.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  559.                         usleep($waitTime); // wait specified time until we restart the transaction
  560.                     } else {
  561.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  562.                         throw $e;
  563.                     }
  564.                 }
  565.             }
  567.             $additionalTags = [];
  568.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  569.                 foreach ($updatedChildren as $assetId) {
  570.                     $tag = 'asset_' . $assetId;
  571.                     $additionalTags[] = $tag;
  573.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  574.                     \Pimcore\Cache\Runtime::set($tag, null);
  575.                 }
  576.             }
  577.             $this->clearDependentCache($additionalTags);
  578.             $this->setDataChanged(false);
  580.             if ($isUpdate) {
  581.                 $updateEvent = new AssetEvent($this);
  582.                 if ($differentOldPath) {
  583.                     $updateEvent->setArgument('oldPath', $differentOldPath);
  584.                 }
  585.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, $updateEvent);
  586.             } else {
  587.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD, new AssetEvent($this));
  588.             }
  590.             return $this;
  591.         } catch (\Exception $e) {
  592.             $failureEvent = new AssetEvent($this);
  593.             $failureEvent->setArgument('exception', $e);
  594.             if ($isUpdate) {
  595.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, $failureEvent);
  596.             } else {
  597.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD_FAILURE, $failureEvent);
  598.             }
  600.             throw $e;
  601.         }
  602.     }
  604.     /**
  605.      * @throws \Exception
  606.      */
  607.     public function correctPath()
  608.     {
  609.         // set path
  610.         if ($this->getId() != 1) { // not for the root node
  612.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  613.                 throw new \Exception("invalid filename '" . $this->getKey() . "' for asset with id [ " . $this->getId() . ' ]');
  614.             }
  616.             if ($this->getParentId() == $this->getId()) {
  617.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  618.             }
  620.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  621.                 throw new \Exception('Cannot create asset called ".." or "."');
  622.             }
  624.             $parent = Asset::getById($this->getParentId());
  625.             if ($parent) {
  626.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  627.                 // that is currently in the parent asset (in memory), because this might have changed but wasn't not saved
  628.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  629.             } else {
  630.                 // parent document doesn't exist anymore, set the parent to to root
  631.                 $this->setParentId(1);
  632.                 $this->setPath('/');
  633.             }
  634.         } elseif ($this->getId() == 1) {
  635.             // some data in root node should always be the same
  636.             $this->setParentId(0);
  637.             $this->setPath('/');
  638.             $this->setFilename('');
  639.             $this->setType('folder');
  640.         }
  642.         // do not allow PHP and .htaccess files
  643.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  644.             $this->setFilename($this->getFilename() . '.txt');
  645.         }
  647.         if (mb_strlen($this->getFilename()) > 255) {
  648.             throw new \Exception('Filenames longer than 255 characters are not allowed');
  649.         }
  651.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  652.             $duplicate = Asset::getByPath($this->getRealFullPath());
  653.             if ($duplicate instanceof Asset && $duplicate->getId() != $this->getId()) {
  654.                 throw new \Exception('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  655.             }
  656.         }
  658.         $this->validatePathLength();
  659.     }
  661.     /**
  662.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  663.      *
  664.      * @throws \Exception
  665.      */
  666.     protected function update($params = [])
  667.     {
  668.         $this->updateModificationInfos();
  670.         // create foldertree
  671.         // use current file name in order to prevent problems when filename has changed
  672.         // (otherwise binary data would be overwritten with old binary data with rename() in save method)
  673.         $destinationPathRelative = $this->getDao()->getCurrentFullPath();
  674.         if (!$destinationPathRelative) {
  675.             // this is happen during a restore from the recycle bin
  676.             $destinationPathRelative = $this->getRealFullPath();
  677.         }
  678.         $destinationPath = PIMCORE_ASSET_DIRECTORY . $destinationPathRelative;
  680.         $dirPath = dirname($destinationPath);
  681.         if (!is_dir($dirPath)) {
  682.             if (!File::mkdir($dirPath)) {
  683.                 throw new \Exception('Unable to create directory: ' . $dirPath . ' for asset :' . $this->getId());
  684.             }
  685.         }
  687.         $typeChanged = false;
  689.         // fix for missing parent folders
  690.         // check if folder of new destination is already created and if not do so
  691.         $newPath = dirname($this->getFileSystemPath());
  692.         if (!is_dir($newPath)) {
  693.             if (!File::mkdir($newPath)) {
  694.                 throw new \Exception('Unable to create directory: ' . $newPath . ' for asset :' . $this->getId());
  695.             }
  696.         }
  698.         if ($this->getType() != 'folder') {
  699.             if ($this->getDataChanged()) {
  700.                 $src = $this->getStream();
  701.                 $streamMeta = stream_get_meta_data($src);
  702.                 if ($destinationPath != $streamMeta['uri']) {
  703.                     if (file_exists($destinationPath)) {
  704.                         // We don't open a stream on existing files, because they could be possibly used by versions
  705.                         // using hardlinks, so it's safer to delete them first, so the inode and therefore also the
  706.                         // versioning information persists. Using the stream on the existing file would overwrite the
  707.                         // contents of the inode and therefore leads to wrong version data
  708.                         unlink($destinationPath);
  709.                     }
  711.                     $dest = fopen($destinationPath, 'w', false, File::getContext());
  712.                     if ($dest) {
  713.                         stream_copy_to_stream($src, $dest);
  714.                         if (!fclose($dest)) {
  715.                             throw new \Exception('Unable to close file handle ' . $destinationPath . ' for asset ' . $this->getId());
  716.                         }
  717.                     } else {
  718.                         throw new \Exception('Unable to open file: ' . $destinationPath . ' for asset ' . $this->getId());
  719.                     }
  720.                 }
  722.                 $this->stream = null; // set stream to null, so that the source stream isn't used anymore after saving
  724.                 @chmod($destinationPath, File::getDefaultMode());
  726.                 // check file exists
  727.                 if (!is_file($destinationPath)) {
  728.                     throw new \Exception("couldn't create new asset, file " . $destinationPath . " doesn't exist");
  729.                 }
  731.                 // set mime type
  732.                 $mimetype = Mime::detect($destinationPath, $this->getFilename());
  733.                 $this->setMimetype($mimetype);
  735.                 // set type
  736.                 $type = self::getTypeFromMimeMapping($mimetype, $this->getFilename());
  737.                 if ($type != $this->getType()) {
  738.                     $this->setType($type);
  739.                     $typeChanged = true;
  740.                 }
  742.                 // not only check if the type is set but also if the implementation can be found
  743.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  744.                 if (!self::getModelFactory()->supports($className)) {
  745.                     throw new \Exception('unable to resolve asset implementation with type: ' . $this->getType());
  746.                 }
  747.             }
  749.             // scheduled tasks are saved in $this->saveVersion();
  750.         } else {
  751.             if (!is_dir($destinationPath) && !is_dir($this->getFileSystemPath())) {
  752.                 if (!File::mkdir($this->getFileSystemPath())) {
  753.                     throw new \Exception('Unable to create directory: ' . $this->getFileSystemPath() . ' for asset :' . $this->getId());
  754.                 }
  755.             }
  756.         }
  758.         if (!$this->getType()) {
  759.             $this->setType('unknown');
  760.         }
  762.         $this->postPersistData();
  764.         // save properties
  765.         $this->getProperties();
  766.         $this->getDao()->deleteAllProperties();
  767.         if (is_array($this->getProperties()) && count($this->getProperties()) > 0) {
  768.             foreach ($this->getProperties() as $property) {
  769.                 if (!$property->getInherited()) {
  770.                     $property->setDao(null);
  771.                     $property->setCid($this->getId());
  772.                     $property->setCtype('asset');
  773.                     $property->setCpath($this->getRealFullPath());
  774.                     $property->save();
  775.                 }
  776.             }
  777.         }
  779.         // save dependencies
  780.         $d = new Dependency();
  781.         $d->setSourceType('asset');
  782.         $d->setSourceId($this->getId());
  784.         foreach ($this->resolveDependencies() as $requirement) {
  785.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  786.                 // dont't add a reference to yourself
  787.                 continue;
  788.             } else {
  789.                 $d->addRequirement($requirement['id'], $requirement['type']);
  790.             }
  791.         }
  792.         $d->save();
  794.         $this->getDao()->update();
  796.         //set asset to registry
  797.         $cacheKey = self::getCacheKey($this->getId());
  798.         \Pimcore\Cache\Runtime::set($cacheKey, $this);
  799.         if (get_class($this) == 'Asset' || $typeChanged) {
  800.             // get concrete type of asset
  801.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  802.             // the type (image, document, ...) depends on the mime-type
  803.             \Pimcore\Cache\Runtime::set($cacheKey, null);
  804.             Asset::getById($this->getId()); // call it to load it to the runtime cache again
  805.         }
  807.         $this->closeStream();
  808.     }
  810.     protected function postPersistData()
  811.     {
  812.         // hook for the save process, can be overwritten in implementations, such as Image
  813.     }
  815.     /**
  816.      * @param bool $setModificationDate
  817.      * @param bool $saveOnlyVersion
  818.      * @param string $versionNote version note
  819.      *
  820.      * @return null|Version
  821.      *
  822.      * @throws \Exception
  823.      */
  824.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  825.     {
  826.         try {
  827.             // hook should be also called if "save only new version" is selected
  828.             if ($saveOnlyVersion) {
  829.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, new AssetEvent($this, [
  830.                     'saveVersionOnly' => true,
  831.                 ]));
  832.             }
  834.             // set date
  835.             if ($setModificationDate) {
  836.                 $this->setModificationDate(time());
  837.             }
  839.             // scheduled tasks are saved always, they are not versioned!
  840.             $this->saveScheduledTasks();
  842.             // create version
  843.             $version = null;
  845.             // only create a new version if there is at least 1 allowed
  846.             // or if saveVersion() was called directly (it's a newer version of the asset)
  847.             $assetsConfig = \Pimcore\Config::getSystemConfiguration('assets');
  848.             if (!empty($assetsConfig['versions']['steps'])
  849.                 || !empty($assetsConfig['versions']['days'])
  850.                 || $setModificationDate) {
  851.                 $saveStackTrace = !($assetsConfig['versions']['disable_stack_trace'] ?? false);
  852.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion, $saveStackTrace);
  853.             }
  855.             // hook should be also called if "save only new version" is selected
  856.             if ($saveOnlyVersion) {
  857.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, new AssetEvent($this, [
  858.                     'saveVersionOnly' => true,
  859.                 ]));
  860.             }
  862.             return $version;
  863.         } catch (\Exception $e) {
  864.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, new AssetEvent($this, [
  865.                 'saveVersionOnly' => true,
  866.                 'exception' => $e,
  867.             ]));
  869.             throw $e;
  870.         }
  871.     }
  873.     /**
  874.      * Returns the full path of the asset including the filename
  875.      *
  876.      * @return string
  877.      */
  878.     public function getFullPath()
  879.     {
  880.         $path = $this->getPath() . $this->getFilename();
  882.         if (Tool::isFrontend()) {
  883.             return $this->getFrontendFullPath();
  884.         }
  886.         return $path;
  887.     }
  889.     /**
  890.      * Returns the full path of the asset (listener aware)
  891.      *
  892.      * @return string
  893.      *
  894.      * @internal
  895.      */
  896.     public function getFrontendFullPath()
  897.     {
  898.         $path = $this->getPath() . $this->getFilename();
  899.         $path = urlencode_ignore_slash($path);
  901.         $event = new GenericEvent($this, [
  902.             'frontendPath' => $path,
  903.         ]);
  905.         \Pimcore::getEventDispatcher()->dispatch(FrontendEvents::ASSET_PATH, $event);
  907.         return $event->getArgument('frontendPath');
  908.     }
  910.     /**
  911.      * @return string
  912.      */
  913.     public function getRealPath()
  914.     {
  915.         return $this->path;
  916.     }
  918.     /**
  919.      * @return string
  920.      */
  921.     public function getRealFullPath()
  922.     {
  923.         $path = $this->getRealPath() . $this->getFilename();
  925.         return $path;
  926.     }
  928.     /**
  929.      * Get a list of the sibling assets
  930.      *
  931.      * @return array
  932.      */
  933.     public function getSiblings()
  934.     {
  935.         if ($this->siblings === null) {
  936.             $list = new Asset\Listing();
  937.             // string conversion because parentId could be 0
  938.             $list->addConditionParam('parentId = ?', (string)$this->getParentId());
  939.             $list->addConditionParam('id != ?', $this->getId());
  940.             $list->setOrderKey('filename');
  941.             $list->setOrder('asc');
  942.             $this->siblings = $list->getAssets();
  943.         }
  945.         return $this->siblings;
  946.     }
  948.     /**
  949.      * Returns true if the asset has at least one sibling
  950.      *
  951.      * @return bool
  952.      */
  953.     public function hasSiblings()
  954.     {
  955.         if (is_bool($this->hasSiblings)) {
  956.             if (($this->hasSiblings && empty($this->siblings)) || (!$this->hasSiblings && !empty($this->siblings))) {
  957.                 return $this->getDao()->hasSiblings();
  958.             } else {
  959.                 return $this->hasSiblings;
  960.             }
  961.         }
  963.         return $this->getDao()->hasSiblings();
  964.     }
  966.     /**
  967.      * @return bool
  968.      */
  969.     public function hasChildren()
  970.     {
  971.         return false;
  972.     }
  974.     /**
  975.      * @return Asset[]
  976.      */
  977.     public function getChildren()
  978.     {
  979.         return [];
  980.     }
  982.     /**
  983.      * enum('self','propagate') nullable
  984.      *
  985.      * @return string|null
  986.      */
  987.     public function getLocked()
  988.     {
  989.         return $this->locked;
  990.     }
  992.     /**
  993.      * enum('self','propagate') nullable
  994.      *
  995.      * @param string|null $locked
  996.      *
  997.      * @return $this
  998.      */
  999.     public function setLocked($locked)
  1000.     {
  1001.         $this->locked = $locked;
  1003.         return $this;
  1004.     }
  1006.     /**
  1007.      * Deletes file from filesystem
  1008.      */
  1009.     protected function deletePhysicalFile()
  1010.     {
  1011.         $fsPath = $this->getFileSystemPath();
  1013.         if ($this->getType() != 'folder') {
  1014.             if (is_file($fsPath) && is_writable($fsPath)) {
  1015.                 unlink($fsPath);
  1016.             }
  1017.         } else {
  1018.             if (is_dir($fsPath) && is_writable($fsPath)) {
  1019.                 recursiveDelete($fsPath, true);
  1020.             }
  1021.         }
  1022.     }
  1024.     /**
  1025.      * @param bool $isNested
  1026.      *
  1027.      * @throws \Exception
  1028.      */
  1029.     public function delete(bool $isNested = false)
  1030.     {
  1031.         if ($this->getId() == 1) {
  1032.             throw new \Exception('root-node cannot be deleted');
  1033.         }
  1035.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_DELETE, new AssetEvent($this));
  1037.         $this->beginTransaction();
  1039.         try {
  1040.             $this->closeStream();
  1042.             // remove children
  1043.             if ($this->hasChildren()) {
  1044.                 foreach ($this->getChildren() as $child) {
  1045.                     $child->delete(true);
  1046.                 }
  1047.             }
  1049.             $versions = $this->getVersions();
  1050.             foreach ($versions as $version) {
  1051.                 $version->delete();
  1052.             }
  1054.             // remove permissions
  1055.             $this->getDao()->deleteAllPermissions();
  1057.             // remove all properties
  1058.             $this->getDao()->deleteAllProperties();
  1060.             // remove all metadata
  1061.             $this->getDao()->deleteAllMetadata();
  1063.             // remove all tasks
  1064.             $this->getDao()->deleteAllTasks();
  1066.             // remove dependencies
  1067.             $d = $this->getDependencies();
  1068.             $d->cleanAllForElement($this);
  1070.             // remove from resource
  1071.             $this->getDao()->delete();
  1073.             $this->commit();
  1075.             // remove file on filesystem
  1076.             if (!$isNested) {
  1077.                 $fullPath = $this->getRealFullPath();
  1078.                 if ($fullPath != '/..' && !strpos($fullPath,
  1079.                         '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1080.                     $this->deletePhysicalFile();
  1081.                 }
  1082.             }
  1083.         } catch (\Exception $e) {
  1084.             $this->rollBack();
  1085.             $failureEvent = new AssetEvent($this);
  1086.             $failureEvent->setArgument('exception', $e);
  1087.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE_FAILURE, $failureEvent);
  1088.             Logger::crit($e);
  1089.             throw $e;
  1090.         }
  1092.         // empty asset cache
  1093.         $this->clearDependentCache();
  1095.         // clear asset from registry
  1096.         \Pimcore\Cache\Runtime::set(self::getCacheKey($this->getId()), null);
  1098.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE, new AssetEvent($this));
  1099.     }
  1101.     /**
  1102.      * @param array $additionalTags
  1103.      */
  1104.     public function clearDependentCache($additionalTags = [])
  1105.     {
  1106.         try {
  1107.             $tags = [$this->getCacheTag(), 'asset_properties', 'output'];
  1108.             $tags = array_merge($tags, $additionalTags);
  1110.             \Pimcore\Cache::clearTags($tags);
  1111.         } catch (\Exception $e) {
  1112.             Logger::crit($e);
  1113.         }
  1114.     }
  1116.     /**
  1117.      * @return int
  1118.      */
  1119.     public function getCreationDate()
  1120.     {
  1121.         return $this->creationDate;
  1122.     }
  1124.     /**
  1125.      * @return int
  1126.      */
  1127.     public function getId()
  1128.     {
  1129.         return (int)$this->id;
  1130.     }
  1132.     /**
  1133.      * @return string
  1134.      */
  1135.     public function getFilename()
  1136.     {
  1137.         return (string)$this->filename;
  1138.     }
  1140.     /**
  1141.      * Alias for getFilename()
  1142.      *
  1143.      * @return string
  1144.      */
  1145.     public function getKey()
  1146.     {
  1147.         return $this->getFilename();
  1148.     }
  1150.     /**
  1151.      * @return int
  1152.      */
  1153.     public function getModificationDate()
  1154.     {
  1155.         return (int)$this->modificationDate;
  1156.     }
  1158.     /**
  1159.      * @return int
  1160.      */
  1161.     public function getParentId()
  1162.     {
  1163.         return $this->parentId;
  1164.     }
  1166.     /**
  1167.      * @return string
  1168.      */
  1169.     public function getPath()
  1170.     {
  1171.         return $this->path;
  1172.     }
  1174.     /**
  1175.      * @return string
  1176.      */
  1177.     public function getType()
  1178.     {
  1179.         return $this->type;
  1180.     }
  1182.     /**
  1183.      * @param int $creationDate
  1184.      *
  1185.      * @return $this
  1186.      */
  1187.     public function setCreationDate($creationDate)
  1188.     {
  1189.         $this->creationDate = (int)$creationDate;
  1191.         return $this;
  1192.     }
  1194.     /**
  1195.      * @param int $id
  1196.      *
  1197.      * @return $this
  1198.      */
  1199.     public function setId($id)
  1200.     {
  1201.         $this->id = (int)$id;
  1203.         return $this;
  1204.     }
  1206.     /**
  1207.      * @param string $filename
  1208.      *
  1209.      * @return $this
  1210.      */
  1211.     public function setFilename($filename)
  1212.     {
  1213.         $this->filename = (string)$filename;
  1215.         return $this;
  1216.     }
  1218.     /**
  1219.      * Alias for setFilename()
  1220.      *
  1221.      * @param string $key
  1222.      *
  1223.      * @return $this
  1224.      */
  1225.     public function setKey($key)
  1226.     {
  1227.         return $this->setFilename($key);
  1228.     }
  1230.     /**
  1231.      * @param int $modificationDate
  1232.      *
  1233.      * @return $this
  1234.      */
  1235.     public function setModificationDate($modificationDate)
  1236.     {
  1237.         $this->markFieldDirty('modificationDate');
  1239.         $this->modificationDate = (int)$modificationDate;
  1241.         return $this;
  1242.     }
  1244.     /**
  1245.      * @param int $parentId
  1246.      *
  1247.      * @return $this
  1248.      */
  1249.     public function setParentId($parentId)
  1250.     {
  1251.         $this->parentId = (int)$parentId;
  1252.         $this->parent = null;
  1254.         return $this;
  1255.     }
  1257.     /**
  1258.      * @param string $path
  1259.      *
  1260.      * @return $this
  1261.      */
  1262.     public function setPath($path)
  1263.     {
  1264.         $this->path = $path;
  1266.         return $this;
  1267.     }
  1269.     /**
  1270.      * @param string $type
  1271.      *
  1272.      * @return $this
  1273.      */
  1274.     public function setType($type)
  1275.     {
  1276.         $this->type = $type;
  1278.         return $this;
  1279.     }
  1281.     /**
  1282.      * @return mixed
  1283.      */
  1284.     public function getData()
  1285.     {
  1286.         $stream = $this->getStream();
  1287.         if ($stream) {
  1288.             return stream_get_contents($stream);
  1289.         }
  1291.         return '';
  1292.     }
  1294.     /**
  1295.      * @param mixed $data
  1296.      *
  1297.      * @return $this
  1298.      */
  1299.     public function setData($data)
  1300.     {
  1301.         $handle = tmpfile();
  1302.         fwrite($handle, $data);
  1303.         $this->setStream($handle);
  1305.         return $this;
  1306.     }
  1308.     /**
  1309.      * @return resource
  1310.      */
  1311.     public function getStream()
  1312.     {
  1313.         if ($this->stream) {
  1314.             if (get_resource_type($this->stream) !== 'stream') {
  1315.                 $this->stream = null;
  1316.             } else {
  1317.                 $streamMeta = stream_get_meta_data($this->stream);
  1318.                 if (!@rewind($this->stream) && $streamMeta['stream_type'] === 'STDIO') {
  1319.                     $this->stream = null;
  1320.                 }
  1321.             }
  1322.         }
  1324.         if (!$this->stream && $this->getType() != 'folder') {
  1325.             if (file_exists($this->getFileSystemPath())) {
  1326.                 $this->stream = fopen($this->getFileSystemPath(), 'r', false, File::getContext());
  1327.             } else {
  1328.                 $this->stream = tmpfile();
  1329.             }
  1330.         }
  1332.         return $this->stream;
  1333.     }
  1335.     /**
  1336.      * @param resource|null $stream
  1337.      *
  1338.      * @return $this
  1339.      */
  1340.     public function setStream($stream)
  1341.     {
  1342.         // close existing stream
  1343.         if ($stream !== $this->stream) {
  1344.             $this->closeStream();
  1345.         }
  1347.         if (is_resource($stream)) {
  1348.             $this->setDataChanged(true);
  1349.             $this->stream = $stream;
  1351.             $isRewindable = @rewind($this->stream);
  1353.             if (!$isRewindable) {
  1354.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($this->getFilename());
  1355.                 $dest = fopen($tmpFile, 'w+', false, File::getContext());
  1356.                 stream_copy_to_stream($this->stream, $dest);
  1357.                 $this->stream = $dest;
  1359.                 $this->_temporaryFiles[] = $tmpFile;
  1360.             }
  1361.         } elseif (is_null($stream)) {
  1362.             $this->stream = null;
  1363.         }
  1365.         return $this;
  1366.     }
  1368.     protected function closeStream()
  1369.     {
  1370.         if (is_resource($this->stream)) {
  1371.             @fclose($this->stream);
  1372.             $this->stream = null;
  1373.         }
  1374.     }
  1376.     /**
  1377.      * @param string $type
  1378.      *
  1379.      * @return null|string
  1380.      *
  1381.      * @throws \Exception
  1382.      */
  1383.     public function getChecksum($type = 'md5')
  1384.     {
  1385.         if (!in_array($type, hash_algos())) {
  1386.             throw new \Exception(sprintf('Hashing algorithm `%s` is not supported', $type));
  1387.         }
  1389.         $file = $this->getFileSystemPath();
  1390.         if (is_file($file)) {
  1391.             return hash_file($type, $file);
  1392.         } elseif (\is_resource($this->getStream())) {
  1393.             return hash($type, $this->getData());
  1394.         }
  1396.         return null;
  1397.     }
  1399.     /**
  1400.      * @return bool
  1401.      */
  1402.     public function getDataChanged()
  1403.     {
  1404.         return $this->_dataChanged;
  1405.     }
  1407.     /**
  1408.      * @param bool $changed
  1409.      *
  1410.      * @return $this
  1411.      */
  1412.     public function setDataChanged($changed = true)
  1413.     {
  1414.         $this->_dataChanged = $changed;
  1416.         return $this;
  1417.     }
  1419.     /**
  1420.      * @return Property[]
  1421.      */
  1422.     public function getProperties()
  1423.     {
  1424.         if ($this->properties === null) {
  1425.             // try to get from cache
  1426.             $cacheKey = 'asset_properties_' . $this->getId();
  1427.             $properties = \Pimcore\Cache::load($cacheKey);
  1428.             if (!is_array($properties)) {
  1429.                 $properties = $this->getDao()->getProperties();
  1430.                 $elementCacheTag = $this->getCacheTag();
  1431.                 $cacheTags = ['asset_properties' => 'asset_properties', $elementCacheTag => $elementCacheTag];
  1432.                 \Pimcore\Cache::save($properties, $cacheKey, $cacheTags);
  1433.             }
  1435.             $this->setProperties($properties);
  1436.         }
  1438.         return $this->properties;
  1439.     }
  1441.     /**
  1442.      * @param Property[] $properties
  1443.      *
  1444.      * @return $this
  1445.      */
  1446.     public function setProperties($properties)
  1447.     {
  1448.         $this->properties = $properties;
  1450.         return $this;
  1451.     }
  1453.     /**
  1454.      * @param string $name
  1455.      * @param string $type
  1456.      * @param mixed $data
  1457.      * @param bool $inherited
  1458.      * @param bool $inheritable
  1459.      *
  1460.      * @return $this
  1461.      */
  1462.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1463.     {
  1464.         $this->getProperties();
  1466.         $property = new Property();
  1467.         $property->setType($type);
  1468.         $property->setCid($this->getId());
  1469.         $property->setName($name);
  1470.         $property->setCtype('asset');
  1471.         $property->setData($data);
  1472.         $property->setInherited($inherited);
  1473.         $property->setInheritable($inheritable);
  1475.         $this->properties[$name] = $property;
  1477.         return $this;
  1478.     }
  1480.     /**
  1481.      * @return int
  1482.      */
  1483.     public function getUserOwner()
  1484.     {
  1485.         return $this->userOwner;
  1486.     }
  1488.     /**
  1489.      * @return int
  1490.      */
  1491.     public function getUserModification()
  1492.     {
  1493.         return $this->userModification;
  1494.     }
  1496.     /**
  1497.      * @param int $userOwner
  1498.      *
  1499.      * @return $this
  1500.      */
  1501.     public function setUserOwner($userOwner)
  1502.     {
  1503.         $this->userOwner = (int)$userOwner;
  1505.         return $this;
  1506.     }
  1508.     /**
  1509.      * @param int $userModification
  1510.      *
  1511.      * @return $this
  1512.      */
  1513.     public function setUserModification($userModification)
  1514.     {
  1515.         $this->markFieldDirty('userModification');
  1517.         $this->userModification = (int)$userModification;
  1519.         return $this;
  1520.     }
  1522.     /**
  1523.      * @return Version[]
  1524.      */
  1525.     public function getVersions()
  1526.     {
  1527.         if ($this->versions === null) {
  1528.             $this->setVersions($this->getDao()->getVersions());
  1529.         }
  1531.         return $this->versions;
  1532.     }
  1534.     /**
  1535.      * @param Version[] $versions
  1536.      *
  1537.      * @return $this
  1538.      */
  1539.     public function setVersions($versions)
  1540.     {
  1541.         $this->versions = $versions;
  1543.         return $this;
  1544.     }
  1546.     /**
  1547.      * returns the path to a temp file
  1548.      *
  1549.      * @return string
  1550.      */
  1551.     public function getTemporaryFile()
  1552.     {
  1553.         $destinationPath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-temporary/asset_' . $this->getId() . '_' . md5(microtime()) . '__' . $this->getFilename();
  1554.         if (!is_dir(dirname($destinationPath))) {
  1555.             File::mkdir(dirname($destinationPath));
  1556.         }
  1558.         $src = $this->getStream();
  1559.         $dest = fopen($destinationPath, 'w+', false, File::getContext());
  1560.         stream_copy_to_stream($src, $dest);
  1561.         fclose($dest);
  1563.         @chmod($destinationPath, File::getDefaultMode());
  1565.         $this->_temporaryFiles[] = $destinationPath;
  1567.         return $destinationPath;
  1568.     }
  1570.     /**
  1571.      * @param string $key
  1572.      * @param mixed $value
  1573.      *
  1574.      * @return $this
  1575.      */
  1576.     public function setCustomSetting($key, $value)
  1577.     {
  1578.         $this->customSettings[$key] = $value;
  1580.         return $this;
  1581.     }
  1583.     /**
  1584.      * @param string $key
  1585.      *
  1586.      * @return mixed
  1587.      */
  1588.     public function getCustomSetting($key)
  1589.     {
  1590.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1591.             return $this->customSettings[$key];
  1592.         }
  1594.         return null;
  1595.     }
  1597.     /**
  1598.      * @param string $key
  1599.      */
  1600.     public function removeCustomSetting($key)
  1601.     {
  1602.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1603.             unset($this->customSettings[$key]);
  1604.         }
  1605.     }
  1607.     /**
  1608.      * @return array
  1609.      */
  1610.     public function getCustomSettings()
  1611.     {
  1612.         return $this->customSettings;
  1613.     }
  1615.     /**
  1616.      * @param array $customSettings
  1617.      *
  1618.      * @return $this
  1619.      */
  1620.     public function setCustomSettings($customSettings)
  1621.     {
  1622.         if (is_string($customSettings)) {
  1623.             $customSettings = \Pimcore\Tool\Serialize::unserialize($customSettings);
  1624.         }
  1626.         if ($customSettings instanceof \stdClass) {
  1627.             $customSettings = (array)$customSettings;
  1628.         }
  1630.         if (!is_array($customSettings)) {
  1631.             $customSettings = [];
  1632.         }
  1634.         $this->customSettings = $customSettings;
  1636.         return $this;
  1637.     }
  1639.     /**
  1640.      * @return string
  1641.      */
  1642.     public function getMimetype()
  1643.     {
  1644.         return $this->mimetype;
  1645.     }
  1647.     /**
  1648.      * @param string $mimetype
  1649.      *
  1650.      * @return $this
  1651.      */
  1652.     public function setMimetype($mimetype)
  1653.     {
  1654.         $this->mimetype = $mimetype;
  1656.         return $this;
  1657.     }
  1659.     /**
  1660.      * @param array $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1661.      *
  1662.      * @return self
  1663.      *
  1664.      * @internal
  1665.      *
  1666.      */
  1667.     public function setMetadataRaw($metadata)
  1668.     {
  1669.         $this->metadata = $metadata;
  1670.         if ($this->metadata) {
  1671.             $this->setHasMetaData(true);
  1672.         }
  1674.         return $this;
  1675.     }
  1677.     /**
  1678.      * @param array|\stdClass[] $metadata for each array item: mandatory keys: name, type - optional keys: data, language
  1679.      *
  1680.      * @return self
  1681.      */
  1682.     public function setMetadata($metadata)
  1683.     {
  1684.         $this->metadata = [];
  1685.         $this->setHasMetaData(false);
  1686.         if (!empty($metadata)) {
  1687.             foreach ((array)$metadata as $metaItem) {
  1688.                 $metaItem = (array)$metaItem; // also allow object with appropriate keys (as it comes from Pimcore\Model\Webservice\Data\Asset\reverseMap)
  1689.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1690.             }
  1691.         }
  1693.         return $this;
  1694.     }
  1696.     /**
  1697.      * @return bool
  1698.      */
  1699.     public function getHasMetaData()
  1700.     {
  1701.         return $this->hasMetaData;
  1702.     }
  1704.     /**
  1705.      * @param bool $hasMetaData
  1706.      *
  1707.      * @return self
  1708.      */
  1709.     public function setHasMetaData($hasMetaData)
  1710.     {
  1711.         $this->hasMetaData = (bool)$hasMetaData;
  1713.         return $this;
  1714.     }
  1716.     /**
  1717.      * @param string $name
  1718.      * @param string $type can be "asset", "checkbox", "date", "document", "input", "object", "select" or "textarea"
  1719.      * @param mixed $data
  1720.      * @param string|null $language
  1721.      *
  1722.      * @return self
  1723.      */
  1724.     public function addMetadata($name, $type, $data = null, $language = null)
  1725.     {
  1726.         if ($name && $type) {
  1727.             $tmp = [];
  1728.             $name = str_replace('~', '---', $name);
  1729.             if (!is_array($this->metadata)) {
  1730.                 $this->metadata = [];
  1731.             }
  1733.             foreach ($this->metadata as $item) {
  1734.                 if ($item['name'] != $name || $language != $item['language']) {
  1735.                     $tmp[] = $item;
  1736.                 }
  1737.             }
  1739.             $item = [
  1740.                 'name' => $name,
  1741.                 'type' => $type,
  1742.                 'data' => $data,
  1743.                 'language' => $language,
  1744.             ];
  1746.             $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1748.             try {
  1749.                 /** @var Data $instance */
  1750.                 $instance = $loader->build($item['type']);
  1751.                 $transformedData = $instance->transformSetterData($data, $item);
  1752.                 $item['data'] = $transformedData;
  1753.             } catch (UnsupportedException $e) {
  1754.             }
  1756.             $tmp[] = $item;
  1757.             $this->metadata = $tmp;
  1759.             $this->setHasMetaData(true);
  1760.         }
  1762.         return $this;
  1763.     }
  1765.     /**
  1766.      * @param string|null $name
  1767.      * @param string|null $language
  1768.      * @param bool $strictMatch
  1769.      * @param bool $raw
  1770.      *
  1771.      * @return array|string|null
  1772.      */
  1773.     public function getMetadata($name = null, $language = null, $strictMatch = false, $raw = false)
  1774.     {
  1775.         $preEvent = new AssetEvent($this);
  1776.         $preEvent->setArgument('metadata', $this->metadata);
  1777.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_GET_METADATA, $preEvent);
  1778.         $this->metadata = $preEvent->getArgument('metadata');
  1780.         $convert = function ($metaData) {
  1781.             $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1782.             $transformedData = $metaData['data'];
  1784.             try {
  1785.                 /** @var Data $instance */
  1786.                 $instance = $loader->build($metaData['type']);
  1787.                 $transformedData = $instance->transformGetterData($metaData['data'], $metaData);
  1788.             } catch (UnsupportedException $e) {
  1789.             }
  1791.             return $transformedData;
  1792.         };
  1794.         if ($name) {
  1795.             if ($language === null) {
  1796.                 $language = \Pimcore::getContainer()->get('pimcore.locale')->findLocale();
  1797.             }
  1799.             $data = null;
  1800.             foreach ($this->metadata as $md) {
  1801.                 if ($md['name'] == $name) {
  1802.                     if ($language == $md['language']) {
  1803.                         if ($raw) {
  1804.                             return $md;
  1805.                         }
  1807.                         return $convert($md);
  1808.                     }
  1809.                     if (empty($md['language']) && !$strictMatch) {
  1810.                         if ($raw) {
  1811.                             return $md;
  1812.                         }
  1813.                         $data = $md;
  1814.                     }
  1815.                 }
  1816.             }
  1818.             if ($data) {
  1819.                 if ($raw) {
  1820.                     return $data;
  1821.                 }
  1823.                 return $convert($data);
  1824.             }
  1826.             return null;
  1827.         }
  1829.         $metaData = $this->getObjectVar('metadata');
  1830.         $result = [];
  1831.         if (is_array($metaData)) {
  1832.             foreach ($metaData as $md) {
  1833.                 $md = (array)$md;
  1834.                 if (!$raw) {
  1835.                     $md['data'] = $convert($md);
  1836.                 }
  1837.                 $result[] = $md;
  1838.             }
  1839.         }
  1841.         return $metaData;
  1842.     }
  1844.     /**
  1845.      * @return Schedule\Task[]
  1846.      */
  1847.     public function getScheduledTasks()
  1848.     {
  1849.         if ($this->scheduledTasks === null) {
  1850.             $taskList = new Schedule\Task\Listing();
  1851.             $taskList->setCondition("cid = ? AND ctype='asset'", $this->getId());
  1852.             $this->setScheduledTasks($taskList->load());
  1853.         }
  1855.         return $this->scheduledTasks;
  1856.     }
  1858.     /**
  1859.      * @param array $scheduledTasks
  1860.      *
  1861.      * @return $this
  1862.      */
  1863.     public function setScheduledTasks($scheduledTasks)
  1864.     {
  1865.         $this->scheduledTasks = $scheduledTasks;
  1867.         return $this;
  1868.     }
  1870.     public function saveScheduledTasks()
  1871.     {
  1872.         $this->getScheduledTasks();
  1873.         $this->getDao()->deleteAllTasks();
  1875.         if (is_array($this->getScheduledTasks()) && count($this->getScheduledTasks()) > 0) {
  1876.             foreach ($this->getScheduledTasks() as $task) {
  1877.                 $task->setId(null);
  1878.                 $task->setDao(null);
  1879.                 $task->setCid($this->getId());
  1880.                 $task->setCtype('asset');
  1881.                 $task->save();
  1882.             }
  1883.         }
  1884.     }
  1886.     /**
  1887.      * Get filesize
  1888.      *
  1889.      * @param bool $formatted
  1890.      * @param int $precision
  1891.      *
  1892.      * @return string|int
  1893.      */
  1894.     public function getFileSize($formatted = false, $precision = 2)
  1895.     {
  1896.         $bytes = 0;
  1897.         if (is_file($this->getFileSystemPath())) {
  1898.             $bytes = filesize($this->getFileSystemPath());
  1899.         }
  1901.         if ($formatted) {
  1902.             return formatBytes($bytes, $precision);
  1903.         }
  1905.         return $bytes;
  1906.     }
  1908.     /**
  1909.      * @return Asset
  1910.      */
  1911.     public function getParent()
  1912.     {
  1913.         if ($this->parent === null) {
  1914.             $this->setParent(Asset::getById($this->getParentId()));
  1915.         }
  1917.         return $this->parent;
  1918.     }
  1920.     /**
  1921.      * @param Asset $parent
  1922.      *
  1923.      * @return $this
  1924.      */
  1925.     public function setParent($parent)
  1926.     {
  1927.         $this->parent = $parent;
  1928.         if ($parent instanceof Asset) {
  1929.             $this->parentId = $parent->getId();
  1930.         }
  1932.         return $this;
  1933.     }
  1935.     /**
  1936.      * @return string
  1937.      */
  1938.     public function getImageThumbnailSavePath()
  1939.     {
  1940.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/image-thumbnails' . $this->getRealPath();
  1941.         $path = rtrim($path, '/');
  1943.         return $path;
  1944.     }
  1946.     /**
  1947.      * @return string
  1948.      */
  1949.     public function getVideoThumbnailSavePath()
  1950.     {
  1951.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/video-thumbnails' . $this->getRealPath();
  1952.         $path = rtrim($path, '/');
  1954.         return $path;
  1955.     }
  1957.     public function __sleep()
  1958.     {
  1959.         $parentVars = parent::__sleep();
  1960.         $blockedVars = ['_temporaryFiles', 'scheduledTasks', 'hasChildren', 'versions', 'parent', 'stream'];
  1962.         if ($this->isInDumpState()) {
  1963.             // this is if we want to make a full dump of the asset (eg. for a new version), including children for recyclebin
  1964.             $this->removeInheritedProperties();
  1965.         } else {
  1966.             // this is if we want to cache the asset
  1967.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  1968.         }
  1970.         return array_diff($parentVars, $blockedVars);
  1971.     }
  1973.     public function __wakeup()
  1974.     {
  1975.         if ($this->isInDumpState()) {
  1976.             // 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)
  1977.             $originalElement = Asset::getById($this->getId());
  1978.             if ($originalElement) {
  1979.                 $this->setFilename($originalElement->getFilename());
  1980.                 $this->setPath($originalElement->getRealPath());
  1981.             }
  1982.         }
  1984.         if ($this->isInDumpState() && $this->properties !== null) {
  1985.             $this->renewInheritedProperties();
  1986.         }
  1988.         $this->setInDumpState(false);
  1989.     }
  1991.     public function removeInheritedProperties()
  1992.     {
  1993.         $myProperties = $this->getProperties();
  1995.         if ($myProperties) {
  1996.             foreach ($this->getProperties() as $name => $property) {
  1997.                 if ($property->getInherited()) {
  1998.                     unset($myProperties[$name]);
  1999.                 }
  2000.             }
  2001.         }
  2003.         $this->setProperties($myProperties);
  2004.     }
  2006.     public function renewInheritedProperties()
  2007.     {
  2008.         $this->removeInheritedProperties();
  2010.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  2011.         $cacheKey = self::getCacheKey($this->getId());
  2012.         if (!\Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  2013.             \Pimcore\Cache\Runtime::set($cacheKey, $this);
  2014.         }
  2016.         $myProperties = $this->getProperties();
  2017.         $inheritedProperties = $this->getDao()->getProperties(true);
  2018.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  2019.     }
  2021.     public function __destruct()
  2022.     {
  2023.         // close open streams
  2024.         $this->closeStream();
  2026.         // delete temporary files
  2027.         foreach ($this->_temporaryFiles as $tempFile) {
  2028.             if (file_exists($tempFile)) {
  2029.                 @unlink($tempFile);
  2030.             }
  2031.         }
  2032.     }
  2034.     /**
  2035.      * @return int
  2036.      */
  2037.     public function getVersionCount(): int
  2038.     {
  2039.         return $this->versionCount ? $this->versionCount : 0;
  2040.     }
  2042.     /**
  2043.      * @param int|null $versionCount
  2044.      *
  2045.      * @return Asset
  2046.      */
  2047.     public function setVersionCount(?int $versionCount): ElementInterface
  2048.     {
  2049.         $this->versionCount = (int)$versionCount;
  2051.         return $this;
  2052.     }
  2054.     /**
  2055.      * @inheritdoc
  2056.      */
  2057.     public function resolveDependencies()
  2058.     {
  2059.         $dependencies = parent::resolveDependencies();
  2061.         if ($this->hasMetaData) {
  2062.             $metaData = $this->getMetadata();
  2064.             foreach ($metaData as $md) {
  2065.                 if (isset($md['data']) && $md['data']) {
  2066.                     /** @var ElementInterface $elementData */
  2067.                     $elementData = $md['data'];
  2068.                     $elementType = $md['type'];
  2069.                     $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  2070.                     /** @var DataDefinitionInterface $implementation */
  2071.                     try {
  2072.                         $implementation = $loader->build($elementType);
  2073.                         $dependencies = array_merge($dependencies, $implementation->resolveDependencies($elementData, $md));
  2074.                     } catch (UnsupportedException $e) {
  2075.                     }
  2076.                 }
  2077.             }
  2078.         }
  2080.         return $dependencies;
  2081.     }
  2083.     public function __clone()
  2084.     {
  2085.         parent::__clone();
  2086.         $this->parent = null;
  2087.         $this->versions = null;
  2088.         $this->hasSiblings = null;
  2089.         $this->siblings = null;
  2090.         $this->scheduledTasks = null;
  2091.         $this->closeStream();
  2092.     }
  2093. }