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

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 Pimcore\Config;
  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.  */
  35. class Asset extends Element\AbstractElement
  36. {
  37.     /**
  38.      * possible types of an asset
  39.      *
  40.      * @var array
  41.      */
  42.     public static $types = ['folder', 'image', 'text', 'audio', 'video', 'document', 'archive', 'unknown'];
  44.     /**
  45.      * Unique ID
  46.      *
  47.      * @var int
  48.      */
  49.     protected $id;
  51.     /**
  52.      * ID of the parent asset
  53.      *
  54.      * @var int
  55.      */
  56.     protected $parentId;
  58.     /**
  59.      * @var Asset
  60.      */
  61.     protected $parent;
  63.     /**
  64.      * Type
  65.      *
  66.      * @var string
  67.      */
  68.     protected $type;
  70.     /**
  71.      * Name of the file
  72.      *
  73.      * @var string
  74.      */
  75.     protected $filename;
  77.     /**
  78.      * Path of the file, without the filename, only the full path of the parent asset
  79.      *
  80.      * @var string
  81.      */
  82.     protected $path;
  84.     /**
  85.      * Mime-Type of the file
  86.      *
  87.      * @var string
  88.      */
  89.     protected $mimetype;
  91.     /**
  92.      * Timestamp of creation
  93.      *
  94.      * @var int
  95.      */
  96.     protected $creationDate;
  98.     /**
  99.      * Timestamp of modification
  100.      *
  101.      * @var int
  102.      */
  103.     protected $modificationDate;
  105.     /**
  106.      * @var resource
  107.      */
  108.     protected $stream;
  110.     /**
  111.      * ID of the owner user
  112.      *
  113.      * @var int
  114.      */
  115.     protected $userOwner;
  117.     /**
  118.      * ID of the user who make the latest changes
  119.      *
  120.      * @var int
  121.      */
  122.     protected $userModification;
  124.     /**
  125.      * List of properties
  126.      *
  127.      * @var array
  128.      */
  129.     protected $properties = null;
  131.     /**
  132.      * List of versions
  133.      *
  134.      * @var array
  135.      */
  136.     protected $versions = null;
  138.     /**
  139.      * @var array
  140.      */
  141.     protected $metadata = [];
  143.     /**
  144.      * enum('self','propagate') nullable
  145.      *
  146.      * @var string
  147.      */
  148.     protected $locked;
  150.     /**
  151.      * List of some custom settings  [key] => value
  152.      * Here there can be stored some data, eg. the video thumbnail files, ...  of the asset, ...
  153.      *
  154.      * @var array
  155.      */
  156.     protected $customSettings = [];
  158.     /**
  159.      * @var bool
  160.      */
  161.     protected $hasMetaData = false;
  163.     /**
  164.      * Dependencies of this asset
  165.      *
  166.      * @var Dependency
  167.      */
  168.     protected $dependencies;
  170.     /**
  171.      * Contains a list of sibling documents
  172.      *
  173.      * @var array
  174.      */
  175.     protected $siblings;
  177.     /**
  178.      * Indicator if document has siblings or not
  179.      *
  180.      * @var bool
  181.      */
  182.     protected $hasSiblings;
  184.     /**
  185.      * Contains all scheduled tasks
  186.      *
  187.      * @var array
  188.      */
  189.     protected $scheduledTasks = null;
  191.     /**
  192.      * Indicator if data has changed
  193.      *
  194.      * @var bool
  195.      */
  196.     protected $_dataChanged = false;
  198.     /**
  199.      * @var int
  200.      */
  201.     protected $versionCount;
  203.     /**
  204.      * @var string[]
  205.      */
  206.     protected $_temporaryFiles = [];
  208.     /**
  209.      *
  210.      * @return array
  211.      */
  212.     public static function getTypes()
  213.     {
  214.         return self::$types;
  215.     }
  217.     /**
  218.      * Static helper to get an asset by the passed path
  219.      *
  220.      * @param string $path
  221.      * @param bool $force
  222.      *
  223.      * @return Asset|Asset\Archive|Asset\Audio|Asset\Document|Asset\Folder|Asset\Image|Asset\Text|Asset\Unknown|Asset\Video
  224.      */
  225.     public static function getByPath($path, $force = false)
  226.     {
  227.         $path = Element\Service::correctPath($path);
  229.         try {
  230.             $asset = new Asset();
  231.             $asset->getDao()->getByPath($path);
  233.             return static::getById($asset->getId(), $force);
  234.         } catch (\Exception $e) {
  235.             return null;
  236.         }
  237.     }
  239.     /**
  240.      * @param Asset $asset
  241.      *
  242.      * @return bool
  243.      */
  244.     protected static function typeMatch(Asset $asset)
  245.     {
  246.         $staticType = get_called_class();
  247.         if ($staticType != Asset::class) {
  248.             if (!$asset instanceof $staticType) {
  249.                 return false;
  250.             }
  251.         }
  253.         return true;
  254.     }
  256.     /**
  257.      * Static helper to get an asset by the passed ID
  258.      *
  259.      * @param int $id
  260.      * @param bool $force
  261.      *
  262.      * @return Asset|Asset\Archive|Asset\Audio|Asset\Document|Asset\Folder|Asset\Image|Asset\Text|Asset\Unknown|Asset\Video
  263.      */
  264.     public static function getById($id, $force = false)
  265.     {
  266.         if (!is_numeric($id) || $id < 1) {
  267.             return null;
  268.         }
  269.         $id = intval($id);
  271.         $cacheKey = 'asset_' . $id;
  273.         if (!$force && \Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  274.             $asset = \Pimcore\Cache\Runtime::get($cacheKey);
  275.             if ($asset && static::typeMatch($asset)) {
  276.                 return $asset;
  277.             }
  278.         }
  280.         try {
  281.             if ($force || !($asset = \Pimcore\Cache::load($cacheKey))) {
  282.                 $asset = new Asset();
  283.                 $asset->getDao()->getById($id);
  285.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($asset->getType());
  287.                 $asset = self::getModelFactory()->build($className);
  288.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  289.                 $asset->getDao()->getById($id);
  290.                 $asset->__setDataVersionTimestamp($asset->getModificationDate());
  292.                 \Pimcore\Cache::save($asset, $cacheKey);
  293.             } else {
  294.                 \Pimcore\Cache\Runtime::set($cacheKey, $asset);
  295.             }
  296.         } catch (\Exception $e) {
  297.             return null;
  298.         }
  300.         if (!$asset || !static::typeMatch($asset)) {
  301.             return null;
  302.         }
  304.         return $asset;
  305.     }
  307.     /**
  308.      * Helper to quickly create a new asset
  309.      *
  310.      * @param int $parentId
  311.      * @param array $data
  312.      * @param bool $save
  313.      *
  314.      * @return Asset
  315.      */
  316.     public static function create($parentId, $data = [], $save = true)
  317.     {
  319.         // create already the real class for the asset type, this is especially for images, because a system-thumbnail
  320.         // (tree) is generated immediately after creating an image
  321.         $class = Asset::class;
  322.         if (array_key_exists('filename', $data) && (array_key_exists('data', $data) || array_key_exists('sourcePath', $data) || array_key_exists('stream', $data))) {
  323.             if (array_key_exists('data', $data) || array_key_exists('stream', $data)) {
  324.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($data['filename']);
  325.                 if (array_key_exists('data', $data)) {
  326.                     File::put($tmpFile, $data['data']);
  327.                     $mimeType = Mime::detect($tmpFile);
  328.                     unlink($tmpFile);
  329.                 } else {
  330.                     $streamMeta = stream_get_meta_data($data['stream']);
  331.                     if (file_exists($streamMeta['uri'])) {
  332.                         // stream is a local file, so we don't have to write a tmp file
  333.                         $mimeType = Mime::detect($streamMeta['uri']);
  334.                     } else {
  335.                         // write a tmp file because the stream isn't a pointer to the local filesystem
  336.                         $isRewindable = @rewind($data['stream']);
  337.                         $dest = fopen($tmpFile, 'w+', false, File::getContext());
  338.                         stream_copy_to_stream($data['stream'], $dest);
  339.                         $mimeType = Mime::detect($tmpFile);
  341.                         if (!$isRewindable) {
  342.                             $data['stream'] = $dest;
  343.                         } else {
  344.                             fclose($dest);
  345.                             unlink($tmpFile);
  346.                         }
  347.                     }
  348.                 }
  349.             } else {
  350.                 $mimeType = Mime::detect($data['sourcePath'], $data['filename']);
  351.                 if (is_file($data['sourcePath'])) {
  352.                     $data['stream'] = fopen($data['sourcePath'], 'r', false, File::getContext());
  353.                 }
  355.                 unset($data['sourcePath']);
  356.             }
  358.             $type = self::getTypeFromMimeMapping($mimeType, $data['filename']);
  359.             $class = '\\Pimcore\\Model\\Asset\\' . ucfirst($type);
  360.             if (array_key_exists('type', $data)) {
  361.                 unset($data['type']);
  362.             }
  363.         }
  365.         $asset = self::getModelFactory()->build($class);
  366.         $asset->setParentId($parentId);
  367.         $asset->setValues($data);
  369.         if ($save) {
  370.             $asset->save();
  371.         }
  373.         return $asset;
  374.     }
  376.     /**
  377.      * @param array $config
  378.      *
  379.      * @return mixed
  380.      *
  381.      * @throws \Exception
  382.      */
  383.     public static function getList($config = [])
  384.     {
  385.         if (!\is_array($config)) {
  386.             throw new \Exception('Unable to initiate list class - please provide valid configuration array');
  387.         }
  389.         $listClass = Listing::class;
  391.         $list = self::getModelFactory()->build($listClass);
  392.         $list->setValues($config);
  394.         return $list;
  395.     }
  397.     /**
  398.      * @param array $config
  399.      *
  400.      * @return int total count
  401.      */
  402.     public static function getTotalCount($config = [])
  403.     {
  404.         $list = static::getList($config);
  405.         $count = $list->getTotalCount();
  407.         return $count;
  408.     }
  410.     /**
  411.      * returns the asset type of a filename and mimetype
  412.      *
  413.      * @param $mimeType
  414.      * @param $filename
  415.      *
  416.      * @return int|string
  417.      */
  418.     public static function getTypeFromMimeMapping($mimeType, $filename)
  419.     {
  420.         if ($mimeType == 'directory') {
  421.             return 'folder';
  422.         }
  424.         $type = null;
  426.         $mappings = [
  427.             'unknown' => ["/\.stp$/"],
  428.             'image' => ['/image/', "/\.eps$/", "/\.ai$/", "/\.svgz$/", "/\.pcx$/", "/\.iff$/", "/\.pct$/", "/\.wmf$/"],
  429.             'text' => ['/text/', '/xml$/'],
  430.             'audio' => ['/audio/'],
  431.             'video' => ['/video/'],
  432.             'document' => ['/msword/', '/pdf/', '/powerpoint/', '/office/', '/excel/', '/opendocument/'],
  433.             'archive' => ['/zip/', '/tar/'],
  434.         ];
  436.         foreach ($mappings as $assetType => $patterns) {
  437.             foreach ($patterns as $pattern) {
  438.                 if (preg_match($pattern, $mimeType . ' .'. File::getFileExtension($filename))) {
  439.                     $type = $assetType;
  440.                     break;
  441.                 }
  442.             }
  444.             // break at first match
  445.             if ($type) {
  446.                 break;
  447.             }
  448.         }
  450.         if (!$type) {
  451.             $type = 'unknown';
  452.         }
  454.         return $type;
  455.     }
  457.     /**
  458.      * Get full path to the asset on the filesystem
  459.      *
  460.      * @return string
  461.      */
  462.     public function getFileSystemPath()
  463.     {
  464.         return PIMCORE_ASSET_DIRECTORY . $this->getRealFullPath();
  465.     }
  467.     /**
  468.      * @return $this
  469.      *
  470.      * @throws \Exception
  471.      */
  472.     public function save()
  473.     {
  474.         // additional parameters (e.g. "versionNote" for the version note)
  475.         $params = [];
  476.         if (func_num_args() && is_array(func_get_arg(0))) {
  477.             $params = func_get_arg(0);
  478.         }
  480.         $isUpdate = false;
  481.         $differentOldPath = null;
  483.         try {
  484.             $preEvent = new AssetEvent($this, $params);
  486.             if ($this->getId()) {
  487.                 $isUpdate = true;
  488.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, $preEvent);
  489.             } else {
  490.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_ADD, $preEvent);
  491.             }
  493.             $params = $preEvent->getArguments();
  495.             $this->correctPath();
  497.             // we wrap the save actions in a loop here, so that we can restart the database transactions in the case it fails
  498.             // if a transaction fails it gets restarted $maxRetries times, then the exception is thrown out
  499.             // this is especially useful to avoid problems with deadlocks in multi-threaded environments (forked workers, ...)
  500.             $maxRetries = 5;
  501.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  502.                 $this->beginTransaction();
  504.                 try {
  505.                     if (!$isUpdate) {
  506.                         $this->getDao()->create();
  507.                     }
  509.                     // get the old path from the database before the update is done
  510.                     $oldPath = null;
  511.                     if ($isUpdate) {
  512.                         $oldPath = $this->getDao()->getCurrentFullPath();
  513.                     }
  515.                     $this->update($params);
  517.                     // if the old path is different from the new path, update all children
  518.                     $updatedChildren = [];
  519.                     if ($oldPath && $oldPath != $this->getRealFullPath()) {
  520.                         $oldFullPath = PIMCORE_ASSET_DIRECTORY . $oldPath;
  521.                         if (is_file($oldFullPath) || is_dir($oldFullPath)) {
  522.                             if (!@File::rename(PIMCORE_ASSET_DIRECTORY . $oldPath, $this->getFileSystemPath())) {
  523.                                 $error = error_get_last();
  524.                                 throw new \Exception('Unable to rename asset ' . $this->getId() . ' on the filesystem: ' . $oldFullPath . ' - Reason: ' . $error['message']);
  525.                             }
  526.                             $differentOldPath = $oldPath;
  527.                             $this->getDao()->updateWorkspaces();
  528.                             $updatedChildren = $this->getDao()->updateChildPaths($oldPath);
  529.                         }
  530.                     }
  532.                     // lastly create a new version if necessary
  533.                     // this has to be after the registry update and the DB update, otherwise this would cause problem in the
  534.                     // $this->__wakeUp() method which is called by $version->save(); (path correction for version restore)
  535.                     if ($this->getType() != 'folder') {
  536.                         $this->saveVersion(false, false, isset($params['versionNote']) ? $params['versionNote'] : null);
  537.                     }
  539.                     $this->commit();
  541.                     break; // transaction was successfully completed, so we cancel the loop here -> no restart required
  542.                 } catch (\Exception $e) {
  543.                     try {
  544.                         $this->rollBack();
  545.                     } catch (\Exception $er) {
  546.                         // PDO adapter throws exceptions if rollback fails
  547.                         Logger::error($er);
  548.                     }
  550.                     // we try to start the transaction $maxRetries times again (deadlocks, ...)
  551.                     if ($retries < ($maxRetries - 1)) {
  552.                         $run = $retries + 1;
  553.                         $waitTime = rand(1, 5) * 100000; // microseconds
  554.                         Logger::warn('Unable to finish transaction (' . $run . ". run) because of the following reason '" . $e->getMessage() . "'. --> Retrying in " . $waitTime . ' microseconds ... (' . ($run + 1) . ' of ' . $maxRetries . ')');
  556.                         usleep($waitTime); // wait specified time until we restart the transaction
  557.                     } else {
  558.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  559.                         throw $e;
  560.                     }
  561.                 }
  562.             }
  564.             $additionalTags = [];
  565.             if (isset($updatedChildren) && is_array($updatedChildren)) {
  566.                 foreach ($updatedChildren as $assetId) {
  567.                     $tag = 'asset_' . $assetId;
  568.                     $additionalTags[] = $tag;
  570.                     // remove the child also from registry (internal cache) to avoid path inconsistencies during long running scripts, such as CLI
  571.                     \Pimcore\Cache\Runtime::set($tag, null);
  572.                 }
  573.             }
  574.             $this->clearDependentCache($additionalTags);
  575.             $this->setDataChanged(false);
  577.             if ($isUpdate) {
  578.                 $updateEvent = new AssetEvent($this);
  579.                 if ($differentOldPath) {
  580.                     $updateEvent->setArgument('oldPath', $differentOldPath);
  581.                 }
  582.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, $updateEvent);
  583.             } else {
  584.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD, new AssetEvent($this));
  585.             }
  587.             return $this;
  588.         } catch (\Exception $e) {
  589.             $failureEvent = new AssetEvent($this);
  590.             $failureEvent->setArgument('exception', $e);
  591.             if ($isUpdate) {
  592.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, $failureEvent);
  593.             } else {
  594.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_ADD_FAILURE, $failureEvent);
  595.             }
  597.             throw $e;
  598.         }
  599.     }
  601.     /**
  602.      * @throws \Exception
  603.      */
  604.     public function correctPath()
  605.     {
  606.         // set path
  607.         if ($this->getId() != 1) { // not for the root node
  609.             if (!Element\Service::isValidKey($this->getKey(), 'asset')) {
  610.                 throw new \Exception("invalid filename '".$this->getKey()."' for asset with id [ " . $this->getId() . ' ]');
  611.             }
  613.             if ($this->getParentId() == $this->getId()) {
  614.                 throw new \Exception("ParentID and ID is identical, an element can't be the parent of itself.");
  615.             }
  617.             if ($this->getFilename() === '..' || $this->getFilename() === '.') {
  618.                 throw new \Exception('Cannot create asset called ".." or "."');
  619.             }
  621.             $parent = Asset::getById($this->getParentId());
  622.             if ($parent) {
  623.                 // use the parent's path from the database here (getCurrentFullPath), to ensure the path really exists and does not rely on the path
  624.                 // that is currently in the parent asset (in memory), because this might have changed but wasn't not saved
  625.                 $this->setPath(str_replace('//', '/', $parent->getCurrentFullPath() . '/'));
  626.             } else {
  627.                 // parent document doesn't exist anymore, set the parent to to root
  628.                 $this->setParentId(1);
  629.                 $this->setPath('/');
  630.             }
  631.         } elseif ($this->getId() == 1) {
  632.             // some data in root node should always be the same
  633.             $this->setParentId(0);
  634.             $this->setPath('/');
  635.             $this->setFilename('');
  636.             $this->setType('folder');
  637.         }
  639.         // do not allow PHP and .htaccess files
  640.         if (preg_match("@\.ph(p[\d+]?|t|tml|ps|ar)$@i", $this->getFilename()) || $this->getFilename() == '.htaccess') {
  641.             $this->setFilename($this->getFilename() . '.txt');
  642.         }
  644.         if (mb_strlen($this->getFilename()) > 255) {
  645.             throw new \Exception('Filenames longer than 255 characters are not allowed');
  646.         }
  648.         if (Asset\Service::pathExists($this->getRealFullPath())) {
  649.             $duplicate = Asset::getByPath($this->getRealFullPath());
  650.             if ($duplicate instanceof Asset and $duplicate->getId() != $this->getId()) {
  651.                 throw new \Exception('Duplicate full path [ ' . $this->getRealFullPath() . ' ] - cannot save asset');
  652.             }
  653.         }
  655.         $this->validatePathLength();
  656.     }
  658.     /**
  659.      * @param array $params additional parameters (e.g. "versionNote" for the version note)
  660.      *
  661.      * @throws \Exception
  662.      */
  663.     protected function update($params = [])
  664.     {
  665.         $this->updateModificationInfos();
  667.         // create foldertree
  668.         // use current file name in order to prevent problems when filename has changed
  669.         // (otherwise binary data would be overwritten with old binary data with rename() in save method)
  670.         $destinationPathRelative = $this->getDao()->getCurrentFullPath();
  671.         if (!$destinationPathRelative) {
  672.             // this is happen during a restore from the recycle bin
  673.             $destinationPathRelative = $this->getRealFullPath();
  674.         }
  675.         $destinationPath = PIMCORE_ASSET_DIRECTORY . $destinationPathRelative;
  677.         $dirPath = dirname($destinationPath);
  678.         if (!is_dir($dirPath)) {
  679.             if (!File::mkdir($dirPath)) {
  680.                 throw new \Exception('Unable to create directory: '. $dirPath . ' for asset :' . $this->getId());
  681.             }
  682.         }
  684.         $typeChanged = false;
  686.         // fix for missing parent folders
  687.         // check if folder of new destination is already created and if not do so
  688.         $newPath = dirname($this->getFileSystemPath());
  689.         if (!is_dir($newPath)) {
  690.             if (!File::mkdir($newPath)) {
  691.                 throw new \Exception('Unable to create directory: '. $newPath . ' for asset :' . $this->getId());
  692.             }
  693.         }
  695.         if ($this->getType() != 'folder') {
  696.             if ($this->getDataChanged()) {
  697.                 $src = $this->getStream();
  698.                 $streamMeta = stream_get_meta_data($src);
  699.                 if ($destinationPath != $streamMeta['uri']) {
  700.                     if (file_exists($destinationPath)) {
  701.                         // We don't open a stream on existing files, because they could be possibly used by versions
  702.                         // using hardlinks, so it's safer to delete them first, so the inode and therefore also the
  703.                         // versioning information persists. Using the stream on the existing file would overwrite the
  704.                         // contents of the inode and therefore leads to wrong version data
  705.                         unlink($destinationPath);
  706.                     }
  708.                     $dest = fopen($destinationPath, 'w', false, File::getContext());
  709.                     if ($dest) {
  710.                         stream_copy_to_stream($src, $dest);
  711.                         if (!fclose($dest)) {
  712.                             throw new \Exception('Unable to close file handle ' . $destinationPath . ' for asset ' . $this->getId());
  713.                         }
  714.                     } else {
  715.                         throw new \Exception('Unable to open file: ' . $destinationPath . ' for asset ' . $this->getId());
  716.                     }
  717.                 }
  719.                 $this->stream = null; // set stream to null, so that the source stream isn't used anymore after saving
  721.                 @chmod($destinationPath, File::getDefaultMode());
  723.                 // check file exists
  724.                 if (!is_file($destinationPath)) {
  725.                     throw new \Exception("couldn't create new asset, file " . $destinationPath . " doesn't exist");
  726.                 }
  728.                 // set mime type
  729.                 $mimetype = Mime::detect($destinationPath, $this->getFilename());
  730.                 $this->setMimetype($mimetype);
  732.                 // set type
  733.                 $type = self::getTypeFromMimeMapping($mimetype, $this->getFilename());
  734.                 if ($type != $this->getType()) {
  735.                     $this->setType($type);
  736.                     $typeChanged = true;
  737.                 }
  739.                 // not only check if the type is set but also if the implementation can be found
  740.                 $className = 'Pimcore\\Model\\Asset\\' . ucfirst($this->getType());
  741.                 if (!self::getModelFactory()->supports($className)) {
  742.                     throw new \Exception('unable to resolve asset implementation with type: ' . $this->getType());
  743.                 }
  744.             }
  746.             // scheduled tasks are saved in $this->saveVersion();
  747.         } else {
  748.             if (!is_dir($destinationPath) && !is_dir($this->getFileSystemPath())) {
  749.                 if (!File::mkdir($this->getFileSystemPath())) {
  750.                     throw new \Exception('Unable to create directory: '. $this->getFileSystemPath() . ' for asset :' . $this->getId());
  751.                 }
  752.             }
  753.         }
  755.         $this->postPersistData();
  757.         // save properties
  758.         $this->getProperties();
  759.         $this->getDao()->deleteAllProperties();
  760.         if (is_array($this->getProperties()) and count($this->getProperties()) > 0) {
  761.             foreach ($this->getProperties() as $property) {
  762.                 if (!$property->getInherited()) {
  763.                     $property->setDao(null);
  764.                     $property->setCid($this->getId());
  765.                     $property->setCtype('asset');
  766.                     $property->setCpath($this->getRealFullPath());
  767.                     $property->save();
  768.                 }
  769.             }
  770.         }
  772.         // save dependencies
  773.         $d = new Dependency();
  774.         $d->setSourceType('asset');
  775.         $d->setSourceId($this->getId());
  777.         foreach ($this->resolveDependencies() as $requirement) {
  778.             if ($requirement['id'] == $this->getId() && $requirement['type'] == 'asset') {
  779.                 // dont't add a reference to yourself
  780.                 continue;
  781.             } else {
  782.                 $d->addRequirement($requirement['id'], $requirement['type']);
  783.             }
  784.         }
  785.         $d->save();
  787.         $this->getDao()->update();
  789.         //set asset to registry
  790.         \Pimcore\Cache\Runtime::set('asset_' . $this->getId(), $this);
  791.         if (get_class($this) == 'Asset' || $typeChanged) {
  792.             // get concrete type of asset
  793.             // this is important because at the time of creating an asset it's not clear which type (resp. class) it will have
  794.             // the type (image, document, ...) depends on the mime-type
  795.             \Pimcore\Cache\Runtime::set('asset_' . $this->getId(), null);
  796.             $asset = Asset::getById($this->getId());
  797.             \Pimcore\Cache\Runtime::set('asset_' . $this->getId(), $asset);
  798.         }
  800.         $this->closeStream();
  801.     }
  803.     protected function postPersistData()
  804.     {
  805.         // hook for the save process, can be overwritten in implementations, such as Image
  806.     }
  808.     /**
  809.      * @param bool $setModificationDate
  810.      * @param bool $saveOnlyVersion
  811.      * @param string $versionNote version note
  812.      *
  813.      * @return null|Version
  814.      *
  815.      * @throws \Exception
  816.      */
  817.     public function saveVersion($setModificationDate = true, $saveOnlyVersion = true, $versionNote = null)
  818.     {
  819.         try {
  820.             // hook should be also called if "save only new version" is selected
  821.             if ($saveOnlyVersion) {
  822.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_UPDATE, new AssetEvent($this, [
  823.                     'saveVersionOnly' => true
  824.                 ]));
  825.             }
  827.             // set date
  828.             if ($setModificationDate) {
  829.                 $this->setModificationDate(time());
  830.             }
  832.             // scheduled tasks are saved always, they are not versioned!
  833.             $this->saveScheduledTasks();
  835.             // create version
  836.             $version = null;
  838.             // only create a new version if there is at least 1 allowed
  839.             // or if saveVersion() was called directly (it's a newer version of the asset)
  840.             if (Config::getSystemConfig()->assets->versions->steps
  841.                 || Config::getSystemConfig()->assets->versions->days
  842.                 || $setModificationDate) {
  843.                 $version = $this->doSaveVersion($versionNote, $saveOnlyVersion);
  844.             }
  846.             // hook should be also called if "save only new version" is selected
  847.             if ($saveOnlyVersion) {
  848.                 \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE, new AssetEvent($this, [
  849.                     'saveVersionOnly' => true
  850.                 ]));
  851.             }
  853.             return $version;
  854.         } catch (\Exception $e) {
  855.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_UPDATE_FAILURE, new AssetEvent($this, [
  856.                 'saveVersionOnly' => true,
  857.                 'exception' => $e
  858.             ]));
  860.             throw $e;
  861.         }
  862.     }
  864.     /**
  865.      * Returns the full path of the asset including the filename
  866.      *
  867.      * @return string
  868.      */
  869.     public function getFullPath()
  870.     {
  871.         $path = $this->getPath() . $this->getFilename();
  873.         if (\Pimcore\Tool::isFrontend()) {
  874.             $path = urlencode_ignore_slash($path);
  876.             $event = new GenericEvent($this, [
  877.                 'frontendPath' => $path
  878.             ]);
  879.             \Pimcore::getEventDispatcher()->dispatch(FrontendEvents::ASSET_PATH, $event);
  880.             $path = $event->getArgument('frontendPath');
  881.         }
  883.         return $path;
  884.     }
  886.     /**
  887.      * @return string
  888.      */
  889.     public function getRealPath()
  890.     {
  891.         return $this->path;
  892.     }
  894.     /**
  895.      * @return string
  896.      */
  897.     public function getRealFullPath()
  898.     {
  899.         $path = $this->getRealPath() . $this->getFilename();
  901.         return $path;
  902.     }
  904.     /**
  905.      * Get a list of the sibling assets
  906.      *
  907.      * @return array
  908.      */
  909.     public function getSiblings()
  910.     {
  911.         if ($this->siblings === null) {
  912.             $list = new Asset\Listing();
  913.             // string conversion because parentId could be 0
  914.             $list->addConditionParam('parentId = ?', (string)$this->getParentId());
  915.             $list->addConditionParam('id != ?', $this->getId());
  916.             $list->setOrderKey('filename');
  917.             $list->setOrder('asc');
  918.             $this->siblings = $list->getAssets();
  919.         }
  921.         return $this->siblings;
  922.     }
  924.     /**
  925.      * Returns true if the asset has at least one sibling
  926.      *
  927.      * @return bool
  928.      */
  929.     public function hasSiblings()
  930.     {
  931.         if (is_bool($this->hasSiblings)) {
  932.             if (($this->hasSiblings and empty($this->siblings)) or (!$this->hasSiblings and !empty($this->siblings))) {
  933.                 return $this->getDao()->hasSiblings();
  934.             } else {
  935.                 return $this->hasSiblings;
  936.             }
  937.         }
  939.         return $this->getDao()->hasSiblings();
  940.     }
  942.     /**
  943.      * @return bool
  944.      */
  945.     public function hasChildren()
  946.     {
  947.         return false;
  948.     }
  950.     /**
  951.      * @return Asset[]
  952.      */
  953.     public function getChildren()
  954.     {
  955.         return [];
  956.     }
  958.     /**
  959.      * Returns true if the element is locked
  960.      *
  961.      * @return string
  962.      */
  963.     public function getLocked()
  964.     {
  965.         return $this->locked;
  966.     }
  968.     /**
  969.      * @param  $locked
  970.      *
  971.      * @return $this
  972.      */
  973.     public function setLocked($locked)
  974.     {
  975.         $this->locked = $locked;
  977.         return $this;
  978.     }
  980.     /**
  981.      * Deletes file from filesystem
  982.      */
  983.     protected function deletePhysicalFile()
  984.     {
  985.         $fsPath = $this->getFileSystemPath();
  987.         if ($this->getType() != 'folder') {
  988.             if (is_file($fsPath) && is_writable($fsPath)) {
  989.                 unlink($fsPath);
  990.             }
  991.         } else {
  992.             if (is_dir($fsPath) && is_writable($fsPath)) {
  993.                 recursiveDelete($fsPath, true);
  994.             }
  995.         }
  996.     }
  998.     /**
  999.      * @param bool $isNested
  1000.      *
  1001.      * @throws \Exception
  1002.      */
  1003.     public function delete(bool $isNested = false)
  1004.     {
  1005.         if ($this->getId() == 1) {
  1006.             throw new \Exception('root-node cannot be deleted');
  1007.         }
  1009.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::PRE_DELETE, new AssetEvent($this));
  1011.         $this->beginTransaction();
  1013.         try {
  1014.             $this->closeStream();
  1016.             // remove children
  1017.             if ($this->hasChildren()) {
  1018.                 foreach ($this->getChildren() as $child) {
  1019.                     $child->delete(true);
  1020.                 }
  1021.             }
  1023.             $versions = $this->getVersions();
  1024.             foreach ($versions as $version) {
  1025.                 $version->delete();
  1026.             }
  1028.             // remove permissions
  1029.             $this->getDao()->deleteAllPermissions();
  1031.             // remove all properties
  1032.             $this->getDao()->deleteAllProperties();
  1034.             // remove all metadata
  1035.             $this->getDao()->deleteAllMetadata();
  1037.             // remove all tasks
  1038.             $this->getDao()->deleteAllTasks();
  1040.             // remove dependencies
  1041.             $d = $this->getDependencies();
  1042.             $d->cleanAllForElement($this);
  1044.             // remove from resource
  1045.             $this->getDao()->delete();
  1047.             $this->commit();
  1049.             // remove file on filesystem
  1050.             if (!$isNested) {
  1051.                 $fullPath = $this->getRealFullPath();
  1052.                 if ($fullPath != '/..' && !strpos($fullPath,
  1053.                         '/../') && $this->getKey() !== '.' && $this->getKey() !== '..') {
  1054.                     $this->deletePhysicalFile();
  1055.                 }
  1056.             }
  1057.         } catch (\Exception $e) {
  1058.             $this->rollBack();
  1059.             $failureEvent = new AssetEvent($this);
  1060.             $failureEvent->setArgument('exception', $e);
  1061.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE_FAILURE, $failureEvent);
  1062.             Logger::crit($e);
  1063.             throw $e;
  1064.         }
  1066.         // empty asset cache
  1067.         $this->clearDependentCache();
  1069.         // clear asset from registry
  1070.         \Pimcore\Cache\Runtime::set('asset_' . $this->getId(), null);
  1072.         \Pimcore::getEventDispatcher()->dispatch(AssetEvents::POST_DELETE, new AssetEvent($this));
  1073.     }
  1075.     /**
  1076.      * @param array $additionalTags
  1077.      */
  1078.     public function clearDependentCache($additionalTags = [])
  1079.     {
  1080.         try {
  1081.             $tags = ['asset_' . $this->getId(), 'asset_properties', 'output'];
  1082.             $tags = array_merge($tags, $additionalTags);
  1084.             \Pimcore\Cache::clearTags($tags);
  1085.         } catch (\Exception $e) {
  1086.             Logger::crit($e);
  1087.         }
  1088.     }
  1090.     /**
  1091.      * @return Dependency
  1092.      */
  1093.     public function getDependencies()
  1094.     {
  1095.         if (!$this->dependencies) {
  1096.             $this->dependencies = Dependency::getBySourceId($this->getId(), 'asset');
  1097.         }
  1099.         return $this->dependencies;
  1100.     }
  1102.     /**
  1103.      * @return int
  1104.      */
  1105.     public function getCreationDate()
  1106.     {
  1107.         return $this->creationDate;
  1108.     }
  1110.     /**
  1111.      * @return int
  1112.      */
  1113.     public function getId()
  1114.     {
  1115.         return (int) $this->id;
  1116.     }
  1118.     /**
  1119.      * @return string
  1120.      */
  1121.     public function getFilename()
  1122.     {
  1123.         return (string) $this->filename;
  1124.     }
  1126.     /**
  1127.      * Alias for getFilename()
  1128.      *
  1129.      * @return string
  1130.      */
  1131.     public function getKey()
  1132.     {
  1133.         return $this->getFilename();
  1134.     }
  1136.     /**
  1137.      * @return int
  1138.      */
  1139.     public function getModificationDate()
  1140.     {
  1141.         return (int) $this->modificationDate;
  1142.     }
  1144.     /**
  1145.      * @return int
  1146.      */
  1147.     public function getParentId()
  1148.     {
  1149.         return $this->parentId;
  1150.     }
  1152.     /**
  1153.      * @return string
  1154.      */
  1155.     public function getPath()
  1156.     {
  1157.         return $this->path;
  1158.     }
  1160.     /**
  1161.      * @return string
  1162.      */
  1163.     public function getType()
  1164.     {
  1165.         return $this->type;
  1166.     }
  1168.     /**
  1169.      * @param int $creationDate
  1170.      *
  1171.      * @return $this
  1172.      */
  1173.     public function setCreationDate($creationDate)
  1174.     {
  1175.         $this->creationDate = (int) $creationDate;
  1177.         return $this;
  1178.     }
  1180.     /**
  1181.      * @param int $id
  1182.      *
  1183.      * @return $this
  1184.      */
  1185.     public function setId($id)
  1186.     {
  1187.         $this->id = (int) $id;
  1189.         return $this;
  1190.     }
  1192.     /**
  1193.      * @param string $filename
  1194.      *
  1195.      * @return $this
  1196.      */
  1197.     public function setFilename($filename)
  1198.     {
  1199.         $this->filename = (string) $filename;
  1201.         return $this;
  1202.     }
  1204.     /**
  1205.      * @param int $modificationDate
  1206.      *
  1207.      * @return $this
  1208.      */
  1209.     public function setModificationDate($modificationDate)
  1210.     {
  1211.         $this->modificationDate = (int) $modificationDate;
  1213.         return $this;
  1214.     }
  1216.     /**
  1217.      * @param int $parentId
  1218.      *
  1219.      * @return $this
  1220.      */
  1221.     public function setParentId($parentId)
  1222.     {
  1223.         $this->parentId = (int) $parentId;
  1224.         $this->parent = null;
  1226.         return $this;
  1227.     }
  1229.     /**
  1230.      * @param string $path
  1231.      *
  1232.      * @return $this
  1233.      */
  1234.     public function setPath($path)
  1235.     {
  1236.         $this->path = $path;
  1238.         return $this;
  1239.     }
  1241.     /**
  1242.      * @param string $type
  1243.      *
  1244.      * @return $this
  1245.      */
  1246.     public function setType($type)
  1247.     {
  1248.         $this->type = $type;
  1250.         return $this;
  1251.     }
  1253.     /**
  1254.      * @return mixed
  1255.      */
  1256.     public function getData()
  1257.     {
  1258.         $stream = $this->getStream();
  1259.         if ($stream) {
  1260.             return stream_get_contents($stream);
  1261.         }
  1263.         return '';
  1264.     }
  1266.     /**
  1267.      * @param mixed $data
  1268.      *
  1269.      * @return $this
  1270.      */
  1271.     public function setData($data)
  1272.     {
  1273.         $handle = tmpfile();
  1274.         fwrite($handle, $data);
  1275.         $this->setStream($handle);
  1277.         return $this;
  1278.     }
  1280.     /**
  1281.      * @return resource
  1282.      */
  1283.     public function getStream()
  1284.     {
  1285.         if ($this->stream) {
  1286.             $streamMeta = stream_get_meta_data($this->stream);
  1287.             if (!@rewind($this->stream) && $streamMeta['stream_type'] === 'STDIO') {
  1288.                 $this->stream = null;
  1289.             }
  1290.         }
  1292.         if (!$this->stream && $this->getType() != 'folder') {
  1293.             if (file_exists($this->getFileSystemPath())) {
  1294.                 $this->stream = fopen($this->getFileSystemPath(), 'r', false, File::getContext());
  1295.             } else {
  1296.                 $this->stream = tmpfile();
  1297.             }
  1298.         }
  1300.         return $this->stream;
  1301.     }
  1303.     /**
  1304.      * @param $stream
  1305.      *
  1306.      * @return $this
  1307.      */
  1308.     public function setStream($stream)
  1309.     {
  1310.         // close existing stream
  1311.         if ($stream !== $this->stream) {
  1312.             $this->closeStream();
  1313.         }
  1315.         if (is_resource($stream)) {
  1316.             $this->setDataChanged(true);
  1317.             $this->stream = $stream;
  1319.             $isRewindable = @rewind($this->stream);
  1321.             if (!$isRewindable) {
  1322.                 $tmpFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-create-tmp-file-' . uniqid() . '.' . File::getFileExtension($this->getFilename());
  1323.                 $dest = fopen($tmpFile, 'w+', false, File::getContext());
  1324.                 stream_copy_to_stream($this->stream, $dest);
  1325.                 $this->stream = $dest;
  1327.                 $this->_temporaryFiles[] = $tmpFile;
  1328.             }
  1329.         } elseif (is_null($stream)) {
  1330.             $this->stream = null;
  1331.         }
  1333.         return $this;
  1334.     }
  1336.     protected function closeStream()
  1337.     {
  1338.         if (is_resource($this->stream)) {
  1339.             @fclose($this->stream);
  1340.             $this->stream = null;
  1341.         }
  1342.     }
  1344.     /**
  1345.      * @param string $type
  1346.      *
  1347.      * @return null|string
  1348.      *
  1349.      * @throws \Exception
  1350.      */
  1351.     public function getChecksum($type = 'md5')
  1352.     {
  1353.         if (!in_array($type, hash_algos())) {
  1354.             throw new \Exception(sprintf('Hashing algorithm `%s` is not supported', $type));
  1355.         }
  1357.         $file = $this->getFileSystemPath();
  1358.         if (is_file($file)) {
  1359.             return hash_file($type, $file);
  1360.         } elseif (\is_resource($this->getStream())) {
  1361.             return hash($type, $this->getData());
  1362.         }
  1364.         return null;
  1365.     }
  1367.     /**
  1368.      * @return bool
  1369.      */
  1370.     public function getDataChanged()
  1371.     {
  1372.         return $this->_dataChanged;
  1373.     }
  1375.     /**
  1376.      * @param bool $changed
  1377.      *
  1378.      * @return $this
  1379.      */
  1380.     public function setDataChanged($changed = true)
  1381.     {
  1382.         $this->_dataChanged = $changed;
  1384.         return $this;
  1385.     }
  1387.     /**
  1388.      * @return Property[]
  1389.      */
  1390.     public function getProperties()
  1391.     {
  1392.         if ($this->properties === null) {
  1393.             // try to get from cache
  1394.             $cacheKey = 'asset_properties_' . $this->getId();
  1395.             $properties = \Pimcore\Cache::load($cacheKey);
  1396.             if (!is_array($properties)) {
  1397.                 $properties = $this->getDao()->getProperties();
  1398.                 $elementCacheTag = $this->getCacheTag();
  1399.                 $cacheTags = ['asset_properties' => 'asset_properties', $elementCacheTag => $elementCacheTag];
  1400.                 \Pimcore\Cache::save($properties, $cacheKey, $cacheTags);
  1401.             }
  1403.             $this->setProperties($properties);
  1404.         }
  1406.         return $this->properties;
  1407.     }
  1409.     /**
  1410.      * @param Property[] $properties
  1411.      *
  1412.      * @return $this
  1413.      */
  1414.     public function setProperties($properties)
  1415.     {
  1416.         $this->properties = $properties;
  1418.         return $this;
  1419.     }
  1421.     /**
  1422.      * @param $name
  1423.      * @param $type
  1424.      * @param $data
  1425.      * @param bool $inherited
  1426.      * @param bool $inheritable
  1427.      *
  1428.      * @return $this
  1429.      */
  1430.     public function setProperty($name, $type, $data, $inherited = false, $inheritable = false)
  1431.     {
  1432.         $this->getProperties();
  1434.         $property = new Property();
  1435.         $property->setType($type);
  1436.         $property->setCid($this->getId());
  1437.         $property->setName($name);
  1438.         $property->setCtype('asset');
  1439.         $property->setData($data);
  1440.         $property->setInherited($inherited);
  1441.         $property->setInheritable($inheritable);
  1443.         $this->properties[$name] = $property;
  1445.         return $this;
  1446.     }
  1448.     /**
  1449.      * @return int
  1450.      */
  1451.     public function getUserOwner()
  1452.     {
  1453.         return $this->userOwner;
  1454.     }
  1456.     /**
  1457.      * @return int
  1458.      */
  1459.     public function getUserModification()
  1460.     {
  1461.         return $this->userModification;
  1462.     }
  1464.     /**
  1465.      * @param int $userOwner
  1466.      *
  1467.      * @return $this
  1468.      */
  1469.     public function setUserOwner($userOwner)
  1470.     {
  1471.         $this->userOwner = (int) $userOwner;
  1473.         return $this;
  1474.     }
  1476.     /**
  1477.      * @param int $userModification
  1478.      *
  1479.      * @return $this
  1480.      */
  1481.     public function setUserModification($userModification)
  1482.     {
  1483.         $this->userModification = (int) $userModification;
  1485.         return $this;
  1486.     }
  1488.     /**
  1489.      * @return Version[]
  1490.      */
  1491.     public function getVersions()
  1492.     {
  1493.         if ($this->versions === null) {
  1494.             $this->setVersions($this->getDao()->getVersions());
  1495.         }
  1497.         return $this->versions;
  1498.     }
  1500.     /**
  1501.      * @param Version[] $versions
  1502.      *
  1503.      * @return $this
  1504.      */
  1505.     public function setVersions($versions)
  1506.     {
  1507.         $this->versions = $versions;
  1509.         return $this;
  1510.     }
  1512.     /**
  1513.      * returns the path to a temp file
  1514.      *
  1515.      * @return string
  1516.      */
  1517.     public function getTemporaryFile()
  1518.     {
  1519.         $destinationPath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/asset-temporary/asset_' . $this->getId() . '_' . md5(microtime()) . '__' . $this->getFilename();
  1520.         if (!is_dir(dirname($destinationPath))) {
  1521.             File::mkdir(dirname($destinationPath));
  1522.         }
  1524.         $src = $this->getStream();
  1525.         $dest = fopen($destinationPath, 'w+', false, File::getContext());
  1526.         stream_copy_to_stream($src, $dest);
  1527.         fclose($dest);
  1529.         @chmod($destinationPath, File::getDefaultMode());
  1531.         $this->_temporaryFiles[] = $destinationPath;
  1533.         return $destinationPath;
  1534.     }
  1536.     /**
  1537.      * @param string $key
  1538.      * @param mixed $value
  1539.      *
  1540.      * @return $this
  1541.      */
  1542.     public function setCustomSetting($key, $value)
  1543.     {
  1544.         $this->customSettings[$key] = $value;
  1546.         return $this;
  1547.     }
  1549.     /**
  1550.      * @param $key
  1551.      *
  1552.      * @return null
  1553.      */
  1554.     public function getCustomSetting($key)
  1555.     {
  1556.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1557.             return $this->customSettings[$key];
  1558.         }
  1560.         return null;
  1561.     }
  1563.     /**
  1564.      * @param $key
  1565.      */
  1566.     public function removeCustomSetting($key)
  1567.     {
  1568.         if (is_array($this->customSettings) && array_key_exists($key, $this->customSettings)) {
  1569.             unset($this->customSettings[$key]);
  1570.         }
  1571.     }
  1573.     /**
  1574.      * @return array
  1575.      */
  1576.     public function getCustomSettings()
  1577.     {
  1578.         return $this->customSettings;
  1579.     }
  1581.     /**
  1582.      * @param array $customSettings
  1583.      *
  1584.      * @return $this
  1585.      */
  1586.     public function setCustomSettings($customSettings)
  1587.     {
  1588.         if (is_string($customSettings)) {
  1589.             $customSettings = \Pimcore\Tool\Serialize::unserialize($customSettings);
  1590.         }
  1592.         if ($customSettings instanceof \stdClass) {
  1593.             $customSettings = (array) $customSettings;
  1594.         }
  1596.         if (!is_array($customSettings)) {
  1597.             $customSettings = [];
  1598.         }
  1600.         $this->customSettings = $customSettings;
  1602.         return $this;
  1603.     }
  1605.     /**
  1606.      * @return string
  1607.      */
  1608.     public function getMimetype()
  1609.     {
  1610.         return $this->mimetype;
  1611.     }
  1613.     /**
  1614.      * @param string $mimetype
  1615.      *
  1616.      * @return $this
  1617.      */
  1618.     public function setMimetype($mimetype)
  1619.     {
  1620.         $this->mimetype = $mimetype;
  1622.         return $this;
  1623.     }
  1625.     /**
  1626.      * @param array $metadata
  1627.      *
  1628.      * @return self
  1629.      */
  1630.     public function setMetadata($metadata)
  1631.     {
  1632.         $this->metadata = [];
  1633.         $this->setHasMetaData(false);
  1634.         if (!empty($metadata)) {
  1635.             foreach ((array)$metadata as $metaItem) {
  1636.                 $this->addMetadata($metaItem['name'], $metaItem['type'], $metaItem['data'] ?? null, $metaItem['language'] ?? null);
  1637.             }
  1638.         }
  1640.         return $this;
  1641.     }
  1643.     /**
  1644.      * @return bool
  1645.      */
  1646.     public function getHasMetaData()
  1647.     {
  1648.         return $this->hasMetaData;
  1649.     }
  1651.     /**
  1652.      * @param bool $hasMetaData
  1653.      *
  1654.      * @return self
  1655.      */
  1656.     public function setHasMetaData($hasMetaData)
  1657.     {
  1658.         $this->hasMetaData = (bool) $hasMetaData;
  1660.         return $this;
  1661.     }
  1663.     /**
  1664.      * @param string $name
  1665.      * @param string $type can be "folder", "image", "input", "audio", "video", "document", "archive" or "unknown"
  1666.      * @param null $data
  1667.      * @param null $language
  1668.      *
  1669.      * @return self
  1670.      */
  1671.     public function addMetadata($name, $type, $data = null, $language = null)
  1672.     {
  1673.         if ($name && $type) {
  1674.             $tmp = [];
  1675.             $name = str_replace('~', '---', $name);
  1676.             if (!is_array($this->metadata)) {
  1677.                 $this->metadata = [];
  1678.             }
  1680.             foreach ($this->metadata as $item) {
  1681.                 if ($item['name'] != $name || $language != $item['language']) {
  1682.                     $tmp[] = $item;
  1683.                 }
  1684.             }
  1685.             $tmp[] = [
  1686.                 'name' => $name,
  1687.                 'type' => $type,
  1688.                 'data' => $data,
  1689.                 'language' => $language
  1690.             ];
  1691.             $this->metadata = $tmp;
  1693.             $this->setHasMetaData(true);
  1694.         }
  1696.         return $this;
  1697.     }
  1699.     /**
  1700.      * @param null $name
  1701.      * @param null $language
  1702.      * @param bool $strictMatch
  1703.      *
  1704.      * @return array|null
  1705.      */
  1706.     public function getMetadata($name = null, $language = null, $strictMatch = false)
  1707.     {
  1708.         $convert = function ($metaData) {
  1709.             if (in_array($metaData['type'], ['asset', 'document', 'object']) && is_numeric($metaData['data'])) {
  1710.                 return Element\Service::getElementById($metaData['type'], $metaData['data']);
  1711.             }
  1713.             return $metaData['data'];
  1714.         };
  1716.         if ($name) {
  1717.             if ($language === null) {
  1718.                 $language = \Pimcore::getContainer()->get('pimcore.locale')->findLocale();
  1719.             }
  1721.             $data = null;
  1722.             foreach ($this->metadata as $md) {
  1723.                 if ($md['name'] == $name) {
  1724.                     if ($language == $md['language']) {
  1725.                         return $convert($md);
  1726.                     }
  1727.                     if (empty($md['language']) && !$strictMatch) {
  1728.                         $data = $md;
  1729.                     }
  1730.                 }
  1731.             }
  1733.             if ($data) {
  1734.                 return $convert($data);
  1735.             }
  1737.             return null;
  1738.         }
  1740.         $metaData = $this->getObjectVar('metadata');
  1741.         if (is_array($metaData)) {
  1742.             foreach ($metaData as &$md) {
  1743.                 $md = (array)$md;
  1744.                 $md['data'] = $convert($md);
  1745.             }
  1746.         }
  1748.         return $metaData;
  1749.     }
  1751.     /**
  1752.      * @return array
  1753.      */
  1754.     public function getScheduledTasks()
  1755.     {
  1756.         if ($this->scheduledTasks === null) {
  1757.             $taskList = new Schedule\Task\Listing();
  1758.             $taskList->setCondition("cid = ? AND ctype='asset'", $this->getId());
  1759.             $this->setScheduledTasks($taskList->load());
  1760.         }
  1762.         return $this->scheduledTasks;
  1763.     }
  1765.     /**
  1766.      * @param $scheduledTasks
  1767.      *
  1768.      * @return $this
  1769.      */
  1770.     public function setScheduledTasks($scheduledTasks)
  1771.     {
  1772.         $this->scheduledTasks = $scheduledTasks;
  1774.         return $this;
  1775.     }
  1777.     public function saveScheduledTasks()
  1778.     {
  1779.         $this->getScheduledTasks();
  1780.         $this->getDao()->deleteAllTasks();
  1782.         if (is_array($this->getScheduledTasks()) && count($this->getScheduledTasks()) > 0) {
  1783.             foreach ($this->getScheduledTasks() as $task) {
  1784.                 $task->setId(null);
  1785.                 $task->setDao(null);
  1786.                 $task->setCid($this->getId());
  1787.                 $task->setCtype('asset');
  1788.                 $task->save();
  1789.             }
  1790.         }
  1791.     }
  1793.     /**
  1794.      * Get filesize
  1795.      *
  1796.      * @param bool $formatted
  1797.      * @param int $precision
  1798.      *
  1799.      * @return string
  1800.      */
  1801.     public function getFileSize($formatted = false, $precision = 2)
  1802.     {
  1803.         $bytes = 0;
  1804.         if (is_file($this->getFileSystemPath())) {
  1805.             $bytes = filesize($this->getFileSystemPath());
  1806.         }
  1808.         if ($formatted) {
  1809.             return formatBytes($bytes, $precision);
  1810.         }
  1812.         return $bytes;
  1813.     }
  1815.     /**
  1816.      * @return Asset
  1817.      */
  1818.     public function getParent()
  1819.     {
  1820.         if ($this->parent === null) {
  1821.             $this->setParent(Asset::getById($this->getParentId()));
  1822.         }
  1824.         return $this->parent;
  1825.     }
  1827.     /**
  1828.      * @param Asset $parent
  1829.      *
  1830.      * @return $this
  1831.      */
  1832.     public function setParent($parent)
  1833.     {
  1834.         $this->parent = $parent;
  1835.         if ($parent instanceof Asset) {
  1836.             $this->parentId = $parent->getId();
  1837.         }
  1839.         return $this;
  1840.     }
  1842.     /**
  1843.      * @return string
  1844.      */
  1845.     public function getImageThumbnailSavePath()
  1846.     {
  1847.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/image-thumbnails' . $this->getRealPath();
  1848.         $path = rtrim($path, '/');
  1850.         return $path;
  1851.     }
  1853.     /**
  1854.      * @return string
  1855.      */
  1856.     public function getVideoThumbnailSavePath()
  1857.     {
  1858.         $path = PIMCORE_TEMPORARY_DIRECTORY . '/video-thumbnails' . $this->getRealPath();
  1859.         $path = rtrim($path, '/');
  1861.         return $path;
  1862.     }
  1864.     public function __sleep()
  1865.     {
  1866.         $finalVars = [];
  1867.         $parentVars = parent::__sleep();
  1868.         $blockedVars = ['_temporaryFiles', 'scheduledTasks', 'dependencies', 'userPermissions', 'hasChildren', 'versions', 'parent', 'stream'];
  1870.         if ($this->isInDumpState()) {
  1871.             // this is if we want to make a full dump of the asset (eg. for a new version), including children for recyclebin
  1872.             $this->removeInheritedProperties();
  1873.         } else {
  1874.             // this is if we want to cache the asset
  1875.             $blockedVars = array_merge($blockedVars, ['children', 'properties']);
  1876.         }
  1878.         foreach ($parentVars as $key) {
  1879.             if (!in_array($key, $blockedVars)) {
  1880.                 $finalVars[] = $key;
  1881.             }
  1882.         }
  1884.         return $finalVars;
  1885.     }
  1887.     public function __wakeup()
  1888.     {
  1889.         if ($this->isInDumpState()) {
  1890.             // 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)
  1891.             $originalElement = Asset::getById($this->getId());
  1892.             if ($originalElement) {
  1893.                 $this->setFilename($originalElement->getFilename());
  1894.                 $this->setPath($originalElement->getRealPath());
  1895.             }
  1896.         }
  1898.         if ($this->isInDumpState() && $this->properties !== null) {
  1899.             $this->renewInheritedProperties();
  1900.         }
  1902.         $this->setInDumpState(false);
  1903.     }
  1905.     public function removeInheritedProperties()
  1906.     {
  1907.         $myProperties = $this->getProperties();
  1909.         if ($myProperties) {
  1910.             foreach ($this->getProperties() as $name => $property) {
  1911.                 if ($property->getInherited()) {
  1912.                     unset($myProperties[$name]);
  1913.                 }
  1914.             }
  1915.         }
  1917.         $this->setProperties($myProperties);
  1918.     }
  1920.     public function renewInheritedProperties()
  1921.     {
  1922.         $this->removeInheritedProperties();
  1924.         // add to registry to avoid infinite regresses in the following $this->getDao()->getProperties()
  1925.         $cacheKey = 'asset_' . $this->getId();
  1926.         if (!\Pimcore\Cache\Runtime::isRegistered($cacheKey)) {
  1927.             \Pimcore\Cache\Runtime::set($cacheKey, $this);
  1928.         }
  1930.         $myProperties = $this->getProperties();
  1931.         $inheritedProperties = $this->getDao()->getProperties(true);
  1932.         $this->setProperties(array_merge($inheritedProperties, $myProperties));
  1933.     }
  1935.     public function __destruct()
  1936.     {
  1937.         // close open streams
  1938.         $this->closeStream();
  1940.         // delete temporary files
  1941.         foreach ($this->_temporaryFiles as $tempFile) {
  1942.             if (file_exists($tempFile)) {
  1943.                 @unlink($tempFile);
  1944.             }
  1945.         }
  1946.     }
  1948.     /**
  1949.      * @return int
  1950.      */
  1951.     public function getVersionCount(): int
  1952.     {
  1953.         return $this->versionCount ? $this->versionCount : 0;
  1954.     }
  1956.     /**
  1957.      * @param int|null $versionCount
  1958.      *
  1959.      * @return Asset
  1960.      */
  1961.     public function setVersionCount(?int $versionCount): ElementInterface
  1962.     {
  1963.         $this->versionCount = (int) $versionCount;
  1965.         return $this;
  1966.     }
  1968.     /**
  1969.      * @inheritdoc
  1970.      */
  1971.     public function resolveDependencies()
  1972.     {
  1973.         $dependencies = parent::resolveDependencies();
  1975.         if ($this->hasMetaData) {
  1976.             $metaData = $this->getMetadata();
  1978.             foreach ($metaData as $md) {
  1979.                 if (isset($md['data']) && $md['data'] instanceof ElementInterface) {
  1980.                     /**
  1981.                      * @var $elementData ElementInterface
  1982.                      */
  1983.                     $elementData = $md['data'];
  1984.                     $elementType = $md['type'];
  1985.                     $key = $elementType . '_' . $elementData->getId();
  1986.                     $dependencies[$key] = [
  1987.                         'id' => $elementData->getId(),
  1988.                         'type' => $elementType
  1989.                     ];
  1990.                 }
  1991.             }
  1992.         }
  1994.         return $dependencies;
  1995.     }
  1996. }