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

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