vendor/pimcore/pimcore/bundles/AdminBundle/Controller/Admin/Asset/AssetController.php line 245

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\Bundle\AdminBundle\Controller\Admin\Asset;
  18. use Pimcore\Bundle\AdminBundle\Controller\Admin\ElementControllerBase;
  19. use Pimcore\Bundle\AdminBundle\Controller\Traits\AdminStyleTrait;
  20. use Pimcore\Bundle\AdminBundle\Controller\Traits\ApplySchedulerDataTrait;
  21. use Pimcore\Bundle\AdminBundle\Helper\GridHelperService;
  22. use Pimcore\Bundle\AdminBundle\Security\CsrfProtectionHandler;
  23. use Pimcore\Config;
  24. use Pimcore\Controller\KernelControllerEventInterface;
  25. use Pimcore\Controller\Traits\ElementEditLockHelperTrait;
  26. use Pimcore\Db\Helper;
  27. use Pimcore\Event\Admin\ElementAdminStyleEvent;
  28. use Pimcore\Event\AdminEvents;
  29. use Pimcore\Event\AssetEvents;
  30. use Pimcore\Event\Model\Asset\ResolveUploadTargetEvent;
  31. use Pimcore\File;
  32. use Pimcore\Loader\ImplementationLoader\Exception\UnsupportedException;
  33. use Pimcore\Logger;
  34. use Pimcore\Messenger\AssetPreviewImageMessage;
  35. use Pimcore\Model;
  36. use Pimcore\Model\Asset;
  37. use Pimcore\Model\DataObject\ClassDefinition\Data\ManyToManyRelation;
  38. use Pimcore\Model\DataObject\Concrete;
  39. use Pimcore\Model\Element;
  40. use Pimcore\Model\Element\ValidationException;
  41. use Pimcore\Model\Metadata;
  42. use Pimcore\Model\Schedule\Task;
  43. use Pimcore\Tool;
  44. use Symfony\Component\EventDispatcher\GenericEvent;
  45. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  46. use Symfony\Component\HttpFoundation\JsonResponse;
  47. use Symfony\Component\HttpFoundation\Request;
  48. use Symfony\Component\HttpFoundation\Response;
  49. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  50. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  51. use Symfony\Component\HttpFoundation\StreamedResponse;
  52. use Symfony\Component\HttpKernel\Event\ControllerEvent;
  53. use Symfony\Component\Mime\MimeTypes;
  54. use Symfony\Component\Process\Process;
  55. use Symfony\Component\Routing\Annotation\Route;
  56. use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
  57. use Symfony\Contracts\Translation\TranslatorInterface;
  59. /**
  60.  * @Route("/asset")
  61.  *
  62.  * @internal
  63.  */
  64. class AssetController extends ElementControllerBase implements KernelControllerEventInterface
  65. {
  66.     use AdminStyleTrait;
  67.     use ElementEditLockHelperTrait;
  68.     use ApplySchedulerDataTrait;
  70.     /**
  71.      * @var Asset\Service
  72.      */
  73.     protected $_assetService;
  75.     /**
  76.      * @Route("/tree-get-root", name="pimcore_admin_asset_treegetroot", methods={"GET"})
  77.      *
  78.      * @param Request $request
  79.      *
  80.      * @return JsonResponse
  81.      */
  82.     public function treeGetRootAction(Request $request)
  83.     {
  84.         return parent::treeGetRootAction($request);
  85.     }
  87.     /**
  88.      * @Route("/delete-info", name="pimcore_admin_asset_deleteinfo", methods={"GET"})
  89.      *
  90.      * @param Request $request
  91.      * @param EventDispatcherInterface $eventDispatcher
  92.      *
  93.      * @return JsonResponse
  94.      */
  95.     public function deleteInfoAction(Request $request, EventDispatcherInterface $eventDispatcher)
  96.     {
  97.         return parent::deleteInfoAction($request, $eventDispatcher);
  98.     }
  100.     /**
  101.      * @Route("/get-data-by-id", name="pimcore_admin_asset_getdatabyid", methods={"GET"})
  102.      *
  103.      * @param Request $request
  104.      *
  105.      * @return JsonResponse
  106.      */
  107.     public function getDataByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  108.     {
  109.         $assetId = (int)$request->get('id');
  110.         $type = (string)$request->get('type');
  112.         $asset = Asset::getById($assetId);
  113.         if (!$asset instanceof Asset) {
  114.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  115.         }
  117.         // check for lock on non-folder items only.
  118.         if ($type !== 'folder' && ($asset->isAllowed('publish') || $asset->isAllowed('delete'))) {
  119.             if (Element\Editlock::isLocked($assetId, 'asset')) {
  120.                 return $this->getEditLockResponse($assetId, 'asset');
  121.             }
  123.             Element\Editlock::lock($request->get('id'), 'asset');
  124.         }
  126.         $asset = clone $asset;
  127.         $asset->setParent(null);
  129.         $asset->setStream(null);
  130.         $data = $asset->getObjectVars();
  131.         $data['locked'] = $asset->isLocked();
  133.         if ($asset instanceof Asset\Text) {
  134.             if ($asset->getFileSize() < 2000000) {
  135.                 // it doesn't make sense to show a preview for files bigger than 2MB
  136.                 $data['data'] = \ForceUTF8\Encoding::toUTF8($asset->getData());
  137.             } else {
  138.                 $data['data'] = false;
  139.             }
  140.         } elseif ($asset instanceof Asset\Document) {
  141.             $data['pdfPreviewAvailable'] = (bool)$this->getDocumentPreviewPdf($asset);
  142.         } elseif ($asset instanceof Asset\Video) {
  143.             $videoInfo = [];
  145.             if (\Pimcore\Video::isAvailable()) {
  146.                 $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  147.                 $thumbnail = $asset->getThumbnail($config, ['mp4']);
  148.                 if ($thumbnail) {
  149.                     if ($thumbnail['status'] == 'finished') {
  150.                         $videoInfo['previewUrl'] = $thumbnail['formats']['mp4'];
  151.                         $videoInfo['width'] = $asset->getWidth();
  152.                         $videoInfo['height'] = $asset->getHeight();
  154.                         $metaData = $asset->getSphericalMetaData();
  155.                         if (isset($metaData['ProjectionType']) && strtolower($metaData['ProjectionType']) == 'equirectangular') {
  156.                             $videoInfo['isVrVideo'] = true;
  157.                         }
  158.                     }
  159.                 }
  160.             }
  162.             $data['videoInfo'] = $videoInfo;
  163.         } elseif ($asset instanceof Asset\Image) {
  164.             $imageInfo = [];
  166.             $previewUrl = $this->generateUrl('pimcore_admin_asset_getimagethumbnail', [
  167.                 'id' => $asset->getId(),
  168.                 'treepreview' => true,
  169.                 '_dc' => time(),
  170.             ]);
  172.             if ($asset->isAnimated()) {
  173.                 $previewUrl = $this->generateUrl('pimcore_admin_asset_getasset', [
  174.                     'id' => $asset->getId(),
  175.                     '_dc' => time(),
  176.                 ]);
  177.             }
  179.             $imageInfo['previewUrl'] = $previewUrl;
  181.             if ($asset->getWidth() && $asset->getHeight()) {
  182.                 $imageInfo['dimensions'] = [];
  183.                 $imageInfo['dimensions']['width'] = $asset->getWidth();
  184.                 $imageInfo['dimensions']['height'] = $asset->getHeight();
  185.             }
  187.             $imageInfo['exiftoolAvailable'] = (bool)\Pimcore\Tool\Console::getExecutable('exiftool');
  189.             if (!$asset->getEmbeddedMetaData(false)) {
  190.                 $asset->getEmbeddedMetaData(true, false); // read Exif, IPTC and XPM like in the old days ...
  191.             }
  193.             $data['imageInfo'] = $imageInfo;
  194.         }
  196.         $predefinedMetaData = Metadata\Predefined\Listing::getByTargetType('asset', [$asset->getType()]);
  197.         $predefinedMetaDataGroups = [];
  198.         /** @var Metadata\Predefined $item */
  199.         foreach ($predefinedMetaData as $item) {
  200.             if ($item->getGroup()) {
  201.                 $predefinedMetaDataGroups[$item->getGroup()] = true;
  202.             }
  203.         }
  204.         $data['predefinedMetaDataGroups'] = array_keys($predefinedMetaDataGroups);
  205.         $data['properties'] = Element\Service::minimizePropertiesForEditmode($asset->getProperties());
  206.         $data['metadata'] = Asset\Service::expandMetadataForEditmode($asset->getMetadata());
  207.         $data['versionDate'] = $asset->getModificationDate();
  208.         $data['filesizeFormatted'] = $asset->getFileSize(true);
  209.         $data['filesize'] = $asset->getFileSize();
  210.         $data['fileExtension'] = File::getFileExtension($asset->getFilename());
  211.         $data['idPath'] = Element\Service::getIdPath($asset);
  212.         $data['userPermissions'] = $asset->getUserPermissions($this->getAdminUser());
  213.         $frontendPath = $asset->getFrontendFullPath();
  214.         $data['url'] = preg_match('/^http(s)?:\\/\\/.+/', $frontendPath) ?
  215.             $frontendPath :
  216.             $request->getSchemeAndHttpHost() . $frontendPath;
  218.         $data['scheduledTasks'] = array_map(
  219.             static function (Task $task) {
  220.                 return $task->getObjectVars();
  221.             },
  222.             $asset->getScheduledTasks()
  223.         );
  225.         $this->addAdminStyle($asset, ElementAdminStyleEvent::CONTEXT_EDITOR, $data);
  227.         $data['php'] = [
  228.             'classes' => array_merge([get_class($asset)], array_values(class_parents($asset))),
  229.             'interfaces' => array_values(class_implements($asset)),
  230.         ];
  232.         $event = new GenericEvent($this, [
  233.             'data' => $data,
  234.             'asset' => $asset,
  235.         ]);
  236.         $eventDispatcher->dispatch($event, AdminEvents::ASSET_GET_PRE_SEND_DATA);
  237.         $data = $event->getArgument('data');
  239.         if ($asset->isAllowed('view')) {
  240.             return $this->adminJson($data);
  241.         }
  243.         throw $this->createAccessDeniedHttpException();
  244.     }
  246.     /**
  247.      * @Route("/tree-get-childs-by-id", name="pimcore_admin_asset_treegetchildsbyid", methods={"GET"})
  248.      *
  249.      * @param Request $request
  250.      *
  251.      * @return JsonResponse
  252.      */
  253.     public function treeGetChildsByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  254.     {
  255.         $allParams = array_merge($request->request->all(), $request->query->all());
  257.         $assets = [];
  258.         $cv = false;
  259.         $asset = Asset::getById($allParams['node']);
  261.         $filter = $request->get('filter');
  262.         $limit = (int)$allParams['limit'];
  263.         if (!is_null($filter)) {
  264.             if (substr($filter, -1) != '*') {
  265.                 $filter .= '*';
  266.             }
  267.             $filter = str_replace('*', '%', $filter);
  269.             $limit = 100;
  270.             $offset = 0;
  271.         } elseif (!$allParams['limit']) {
  272.             $limit = 100000000;
  273.         }
  275.         $offset = isset($allParams['start']) ? (int)$allParams['start'] : 0;
  277.         $filteredTotalCount = 0;
  279.         if ($asset->hasChildren()) {
  280.             if ($allParams['view']) {
  281.                 $cv = \Pimcore\Model\Element\Service::getCustomViewById($allParams['view']);
  282.             }
  284.             // get assets
  285.             $childrenList = new Asset\Listing();
  286.             $childrenList->addConditionParam('parentId = ?', [$asset->getId()]);
  287.             $childrenList->filterAccessibleByUser($this->getAdminUser(), $asset);
  289.             if (!is_null($filter)) {
  290.                 $childrenList->addConditionParam('CAST(assets.filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci LIKE ?', [$filter]);
  291.             }
  293.             $childrenList->setLimit($limit);
  294.             $childrenList->setOffset($offset);
  295.             $childrenList->setOrderKey("FIELD(assets.type, 'folder') DESC, CAST(assets.filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci ASC", false);
  297.             \Pimcore\Model\Element\Service::addTreeFilterJoins($cv, $childrenList);
  299.             $beforeListLoadEvent = new GenericEvent($this, [
  300.                 'list' => $childrenList,
  301.                 'context' => $allParams,
  302.             ]);
  303.             $eventDispatcher->dispatch($beforeListLoadEvent, AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD);
  304.             /** @var Asset\Listing $childrenList */
  305.             $childrenList = $beforeListLoadEvent->getArgument('list');
  307.             $children = $childrenList->load();
  309.             $filteredTotalCount = $childrenList->getTotalCount();
  311.             foreach ($children as $childAsset) {
  312.                 $assetTreeNode = $this->getTreeNodeConfig($childAsset);
  313.                 if ($assetTreeNode['permissions']['list'] == 1) {
  314.                     $assets[] = $assetTreeNode;
  315.                 }
  316.             }
  317.         }
  319.         //Hook for modifying return value - e.g. for changing permissions based on asset data
  320.         $event = new GenericEvent($this, [
  321.             'assets' => $assets,
  322.         ]);
  323.         $eventDispatcher->dispatch($event, AdminEvents::ASSET_TREE_GET_CHILDREN_BY_ID_PRE_SEND_DATA);
  324.         $assets = $event->getArgument('assets');
  326.         if ($allParams['limit']) {
  327.             return $this->adminJson([
  328.                 'offset' => $offset,
  329.                 'limit' => $limit,
  330.                 'total' => $asset->getChildAmount($this->getAdminUser()),
  331.                 'overflow' => !is_null($filter) && ($filteredTotalCount > $limit),
  332.                 'nodes' => $assets,
  333.                 'filter' => $request->get('filter') ? $request->get('filter') : '',
  334.                 'inSearch' => (int)$request->get('inSearch'),
  335.             ]);
  336.         } else {
  337.             return $this->adminJson($assets);
  338.         }
  339.     }
  341.     /**
  342.      * @Route("/add-asset", name="pimcore_admin_asset_addasset", methods={"POST"})
  343.      *
  344.      * @param Request $request
  345.      * @param Config $config
  346.      *
  347.      * @return JsonResponse
  348.      */
  349.     public function addAssetAction(Request $request, Config $config)
  350.     {
  351.         try {
  352.             $res = $this->addAsset($request, $config);
  354.             $response = [
  355.                 'success' => $res['success'],
  356.             ];
  358.             if ($res['success']) {
  359.                 $response['asset'] = [
  360.                     'id' => $res['asset']->getId(),
  361.                     'path' => $res['asset']->getFullPath(),
  362.                     'type' => $res['asset']->getType(),
  363.                 ];
  364.             }
  366.             return $this->adminJson($response);
  367.         } catch (\Exception $e) {
  368.             return $this->adminJson([
  369.                 'success' => false,
  370.                 'message' => $e->getMessage(),
  371.             ]);
  372.         }
  373.     }
  375.     /**
  376.      * @Route("/add-asset-compatibility", name="pimcore_admin_asset_addassetcompatibility", methods={"POST"})
  377.      *
  378.      * @param Request $request
  379.      * @param Config $config
  380.      *
  381.      * @return JsonResponse
  382.      */
  383.     public function addAssetCompatibilityAction(Request $request, Config $config)
  384.     {
  385.         try {
  386.             // this is a special action for the compatibility mode upload (without flash)
  387.             $res = $this->addAsset($request, $config);
  389.             $response = $this->adminJson([
  390.                 'success' => $res['success'],
  391.                 'msg' => $res['success'] ? 'Success' : 'Error',
  392.                 'id' => $res['asset'] ? $res['asset']->getId() : null,
  393.                 'fullpath' => $res['asset'] ? $res['asset']->getRealFullPath() : null,
  394.                 'type' => $res['asset'] ? $res['asset']->getType() : null,
  395.             ]);
  396.             $response->headers->set('Content-Type', 'text/html');
  398.             return $response;
  399.         } catch (\Exception $e) {
  400.             return $this->adminJson([
  401.                 'success' => false,
  402.                 'message' => $e->getMessage(),
  403.             ]);
  404.         }
  405.     }
  407.     /**
  408.      * @Route("/exists", name="pimcore_admin_asset_exists", methods={"GET"})
  409.      *
  410.      * @param Request $request
  411.      *
  412.      * @return JsonResponse
  413.      *
  414.      * @throws \Exception
  415.      */
  416.     public function existsAction(Request $request)
  417.     {
  418.         $parentAsset = \Pimcore\Model\Asset::getById((int)$request->get('parentId'));
  420.         return new JsonResponse([
  421.             'exists' => Asset\Service::pathExists($parentAsset->getRealFullPath().'/'.$request->get('filename')),
  422.         ]);
  423.     }
  425.     /**
  426.      * @param Request $request
  427.      * @param Config $config
  428.      *
  429.      * @return array
  430.      *
  431.      * @throws \Exception
  432.      */
  433.     protected function addAsset(Request $request, Config $config)
  434.     {
  435.         $defaultUploadPath = $config['assets']['default_upload_path'] ?? '/';
  437.         if (array_key_exists('Filedata', $_FILES)) {
  438.             $filename = $_FILES['Filedata']['name'];
  439.             $sourcePath = $_FILES['Filedata']['tmp_name'];
  440.         } elseif ($request->get('type') == 'base64') {
  441.             $filename = $request->get('filename');
  442.             $sourcePath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/upload-base64' . uniqid() . '.tmp';
  443.             $data = preg_replace('@^data:[^,]+;base64,@', '', $request->get('data'));
  444.             File::put($sourcePath, base64_decode($data));
  445.         } else {
  446.             throw new \Exception('The filename of the asset is empty');
  447.         }
  449.         $parentId = $request->get('parentId');
  450.         $parentPath = $request->get('parentPath');
  452.         if ($request->get('dir') && $request->get('parentId')) {
  453.             // this is for uploading folders with Drag&Drop
  454.             // param "dir" contains the relative path of the file
  455.             $parent = Asset::getById((int) $request->get('parentId'));
  456.             $dir = $request->get('dir');
  457.             if (strpos($dir, '..') !== false) {
  458.                 throw new \Exception('not allowed');
  459.             }
  461.             $newPath = $parent->getRealFullPath() . '/' . trim($dir, '/ ');
  463.             $maxRetries = 5;
  464.             $newParent = null;
  465.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  466.                 try {
  467.                     $newParent = Asset\Service::createFolderByPath($newPath);
  469.                     break;
  470.                 } catch (\Exception $e) {
  471.                     if ($retries < ($maxRetries - 1)) {
  472.                         $waitTime = rand(100000, 900000); // microseconds
  473.                         usleep($waitTime); // wait specified time until we restart the transaction
  474.                     } else {
  475.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  476.                         throw $e;
  477.                     }
  478.                 }
  479.             }
  480.             if ($newParent) {
  481.                 $parentId = $newParent->getId();
  482.             }
  483.         } elseif (!$request->get('parentId') && $parentPath) {
  484.             $parent = Asset::getByPath($parentPath);
  485.             if ($parent instanceof Asset\Folder) {
  486.                 $parentId = $parent->getId();
  487.             }
  488.         }
  490.         $filename = Element\Service::getValidKey($filename, 'asset');
  491.         if (empty($filename)) {
  492.             throw new \Exception('The filename of the asset is empty');
  493.         }
  495.         $context = $request->get('context');
  496.         if ($context) {
  497.             $context = json_decode($context, true);
  498.             $context = $context ?: [];
  500.             $this->validateManyToManyRelationAssetType($context, $filename, $sourcePath);
  502.             $event = new ResolveUploadTargetEvent($parentId, $filename, $context);
  503.             \Pimcore::getEventDispatcher()->dispatch($event, AssetEvents::RESOLVE_UPLOAD_TARGET);
  504.             $filename = Element\Service::getValidKey($event->getFilename(), 'asset');
  505.             $parentId = $event->getParentId();
  506.         }
  508.         if (!$parentId) {
  509.             $parentId = Asset\Service::createFolderByPath($defaultUploadPath)->getId();
  510.         }
  512.         $parentAsset = Asset::getById((int)$parentId);
  514.         if (!$request->get('allowOverwrite')) {
  515.             // check for duplicate filename
  516.             $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  517.         }
  519.         if (!$parentAsset->isAllowed('create')) {
  520.             throw $this->createAccessDeniedHttpException(
  521.                 'Missing the permission to create new assets in the folder: ' . $parentAsset->getRealFullPath()
  522.             );
  523.         }
  525.         if (is_file($sourcePath) && filesize($sourcePath) < 1) {
  526.             throw new \Exception('File is empty!');
  527.         } elseif (!is_file($sourcePath)) {
  528.             throw new \Exception('Something went wrong, please check upload_max_filesize and post_max_size in your php.ini as well as the write permissions of your temporary directories.');
  529.         }
  531.         // check if there is a requested type and if matches the asset type of the uploaded file
  532.         $uploadAssetType = $request->get('uploadAssetType');
  533.         if ($uploadAssetType) {
  534.             $mimetype = MimeTypes::getDefault()->guessMimeType($sourcePath);
  535.             $assetType = Asset::getTypeFromMimeMapping($mimetype, $filename);
  537.             if ($uploadAssetType !== $assetType) {
  538.                 throw new \Exception("Mime type $mimetype does not match with asset type: $uploadAssetType");
  539.             }
  540.         }
  542.         if ($request->get('allowOverwrite') && Asset\Service::pathExists($parentAsset->getRealFullPath().'/'.$filename)) {
  543.             $asset = Asset::getByPath($parentAsset->getRealFullPath().'/'.$filename);
  544.             $asset->setStream(fopen($sourcePath, 'rb', false, File::getContext()));
  545.             $asset->save();
  546.         } else {
  547.             $asset = Asset::create($parentId, [
  548.                 'filename' => $filename,
  549.                 'sourcePath' => $sourcePath,
  550.                 'userOwner' => $this->getAdminUser()->getId(),
  551.                 'userModification' => $this->getAdminUser()->getId(),
  552.             ]);
  553.         }
  555.         @unlink($sourcePath);
  557.         return [
  558.             'success' => true,
  559.             'asset' => $asset,
  560.         ];
  561.     }
  563.     /**
  564.      * @param string $targetPath
  565.      * @param string $filename
  566.      *
  567.      * @return string
  568.      */
  569.     protected function getSafeFilename($targetPath, $filename)
  570.     {
  571.         $pathinfo = pathinfo($filename);
  572.         $originalFilename = $pathinfo['filename'];
  573.         $originalFileextension = empty($pathinfo['extension']) ? '' : '.' . $pathinfo['extension'];
  574.         $count = 1;
  576.         if ($targetPath == '/') {
  577.             $targetPath = '';
  578.         }
  580.         while (true) {
  581.             if (Asset\Service::pathExists($targetPath . '/' . $filename)) {
  582.                 $filename = $originalFilename . '_' . $count . $originalFileextension;
  583.                 $count++;
  584.             } else {
  585.                 return $filename;
  586.             }
  587.         }
  588.     }
  590.     /**
  591.      * @Route("/replace-asset", name="pimcore_admin_asset_replaceasset", methods={"POST", "PUT"})
  592.      *
  593.      * @param Request $request
  594.      * @param TranslatorInterface $translator
  595.      *
  596.      * @return JsonResponse
  597.      *
  598.      * @throws \Exception
  599.      */
  600.     public function replaceAssetAction(Request $request, TranslatorInterface $translator)
  601.     {
  602.         $asset = Asset::getById((int) $request->get('id'));
  604.         $newFilename = Element\Service::getValidKey($_FILES['Filedata']['name'], 'asset');
  605.         $mimetype = MimeTypes::getDefault()->guessMimeType($_FILES['Filedata']['tmp_name']);
  606.         $newType = Asset::getTypeFromMimeMapping($mimetype, $newFilename);
  608.         if ($newType != $asset->getType()) {
  609.             return $this->adminJson([
  610.                 'success' => false,
  611.                 'message' => sprintf($translator->trans('asset_type_change_not_allowed', [], 'admin'), $asset->getType(), $newType),
  612.             ]);
  613.         }
  615.         $stream = fopen($_FILES['Filedata']['tmp_name'], 'r+');
  616.         $asset->setStream($stream);
  617.         $asset->setCustomSetting('thumbnails', null);
  618.         $asset->setUserModification($this->getAdminUser()->getId());
  620.         $newFileExt = File::getFileExtension($newFilename);
  621.         $currentFileExt = File::getFileExtension($asset->getFilename());
  622.         if ($newFileExt != $currentFileExt) {
  623.             $newFilename = preg_replace('/\.' . $currentFileExt . '$/i', '.' . $newFileExt, $asset->getFilename());
  624.             $newFilename = Element\Service::getSafeCopyName($newFilename, $asset->getParent());
  625.             $asset->setFilename($newFilename);
  626.         }
  628.         if ($asset->isAllowed('publish')) {
  629.             $asset->save();
  631.             $response = $this->adminJson([
  632.                 'id' => $asset->getId(),
  633.                 'path' => $asset->getRealFullPath(),
  634.                 'success' => true,
  635.             ]);
  637.             // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  638.             // Ext.form.Action.Submit and mark the submission as failed
  639.             $response->headers->set('Content-Type', 'text/html');
  641.             return $response;
  642.         } else {
  643.             throw new \Exception('missing permission');
  644.         }
  645.     }
  647.     /**
  648.      * @Route("/add-folder", name="pimcore_admin_asset_addfolder", methods={"POST"})
  649.      *
  650.      * @param Request $request
  651.      *
  652.      * @return JsonResponse
  653.      */
  654.     public function addFolderAction(Request $request)
  655.     {
  656.         $success = false;
  657.         $parentAsset = Asset::getById((int)$request->get('parentId'));
  658.         $equalAsset = Asset::getByPath($parentAsset->getRealFullPath() . '/' . $request->get('name'));
  660.         if ($parentAsset->isAllowed('create')) {
  661.             if (!$equalAsset) {
  662.                 $asset = Asset::create($request->get('parentId'), [
  663.                     'filename' => $request->get('name'),
  664.                     'type' => 'folder',
  665.                     'userOwner' => $this->getAdminUser()->getId(),
  666.                     'userModification' => $this->getAdminUser()->getId(),
  667.                 ]);
  668.                 $success = true;
  669.             }
  670.         } else {
  671.             Logger::debug('prevented creating asset because of missing permissions');
  672.         }
  674.         return $this->adminJson(['success' => $success]);
  675.     }
  677.     /**
  678.      * @Route("/delete", name="pimcore_admin_asset_delete", methods={"DELETE"})
  679.      *
  680.      * @param Request $request
  681.      *
  682.      * @return JsonResponse
  683.      */
  684.     public function deleteAction(Request $request)
  685.     {
  686.         $type = $request->get('type');
  688.         if ($type === 'childs') {
  689.             trigger_deprecation(
  690.                 'pimcore/pimcore',
  691.                 '10.4',
  692.                 'Type childs is deprecated. Use children instead'
  693.             );
  694.             $type = 'children';
  695.         }
  696.         if ($type === 'children') {
  697.             $parentAsset = Asset::getById((int) $request->get('id'));
  699.             $list = new Asset\Listing();
  700.             $list->setCondition('path LIKE ?', [Helper::escapeLike($parentAsset->getRealFullPath()) . '/%']);
  701.             $list->setLimit((int)$request->get('amount'));
  702.             $list->setOrderKey('LENGTH(path)', false);
  703.             $list->setOrder('DESC');
  705.             $deletedItems = [];
  706.             foreach ($list as $asset) {
  707.                 $deletedItems[$asset->getId()] = $asset->getRealFullPath();
  708.                 if ($asset->isAllowed('delete') && !$asset->isLocked()) {
  709.                     $asset->delete();
  710.                 }
  711.             }
  713.             return $this->adminJson(['success' => true, 'deleted' => $deletedItems]);
  714.         }
  715.         if ($request->get('id')) {
  716.             $asset = Asset::getById((int) $request->get('id'));
  717.             if ($asset && $asset->isAllowed('delete')) {
  718.                 if ($asset->isLocked()) {
  719.                     return $this->adminJson([
  720.                         'success' => false,
  721.                         'message' => 'prevented deleting asset, because it is locked: ID: ' . $asset->getId(),
  722.                     ]);
  723.                 }
  725.                 $asset->delete();
  727.                 return $this->adminJson(['success' => true]);
  728.             }
  729.         }
  731.         throw $this->createAccessDeniedHttpException();
  732.     }
  734.     /**
  735.      * @param Asset $element
  736.      *
  737.      * @return array
  738.      */
  739.     protected function getTreeNodeConfig($element)
  740.     {
  741.         $asset = $element;
  743.         $permissions =  $asset->getUserPermissions($this->getAdminUser());
  745.         $tmpAsset = [
  746.             'id' => $asset->getId(),
  747.             'key' => $element->getKey(),
  748.             'text' => htmlspecialchars($asset->getFilename()),
  749.             'type' => $asset->getType(),
  750.             'path' => $asset->getRealFullPath(),
  751.             'basePath' => $asset->getRealPath(),
  752.             'locked' => $asset->isLocked(),
  753.             'lockOwner' => $asset->getLocked() ? true : false,
  754.             'elementType' => 'asset',
  755.             'permissions' => [
  756.                 'remove' => $permissions['delete'],
  757.                 'settings' => $permissions['settings'],
  758.                 'rename' => $permissions['rename'],
  759.                 'publish' => $permissions['publish'],
  760.                 'view' => $permissions['view'],
  761.                 'list' => $permissions['list'],
  762.             ],
  763.         ];
  765.         $hasChildren = $asset->getDao()->hasChildren($this->getAdminUser());
  767.         // set type specific settings
  768.         if ($asset instanceof Asset\Folder) {
  769.             $tmpAsset['leaf'] = false;
  770.             $tmpAsset['expanded'] = !$hasChildren;
  771.             $tmpAsset['loaded'] = !$hasChildren;
  772.             $tmpAsset['permissions']['create'] = $permissions['create'];
  773.             $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset, ['origin' => 'treeNode']);
  774.         } else {
  775.             $tmpAsset['leaf'] = true;
  776.             $tmpAsset['expandable'] = false;
  777.             $tmpAsset['expanded'] = false;
  778.         }
  780.         $this->addAdminStyle($asset, ElementAdminStyleEvent::CONTEXT_TREE, $tmpAsset);
  782.         if ($asset instanceof Asset\Image) {
  783.             try {
  784.                 $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset, ['origin' => 'treeNode']);
  786.                 // we need the dimensions for the wysiwyg editors, so that they can resize the image immediately
  787.                 if ($asset->getCustomSetting('imageDimensionsCalculated')) {
  788.                     $tmpAsset['imageWidth'] = $asset->getCustomSetting('imageWidth');
  789.                     $tmpAsset['imageHeight'] = $asset->getCustomSetting('imageHeight');
  790.                 }
  791.             } catch (\Exception $e) {
  792.                 Logger::debug('Cannot get dimensions of image, seems to be broken.');
  793.             }
  794.         } elseif ($asset->getType() == 'video') {
  795.             try {
  796.                 if (\Pimcore\Video::isAvailable()) {
  797.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset, ['origin' => 'treeNode']);
  798.                 }
  799.             } catch (\Exception $e) {
  800.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  801.             }
  802.         } elseif ($asset->getType() == 'document') {
  803.             try {
  804.                 // add the PDF check here, otherwise the preview layer in admin is shown without content
  805.                 if (\Pimcore\Document::isAvailable() && \Pimcore\Document::isFileTypeSupported($asset->getFilename())) {
  806.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset, ['origin' => 'treeNode']);
  807.                 }
  808.             } catch (\Exception $e) {
  809.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  810.             }
  811.         }
  813.         $tmpAsset['cls'] = '';
  814.         if ($asset->isLocked()) {
  815.             $tmpAsset['cls'] .= 'pimcore_treenode_locked ';
  816.         }
  817.         if ($asset->getLocked()) {
  818.             $tmpAsset['cls'] .= 'pimcore_treenode_lockOwner ';
  819.         }
  821.         return $tmpAsset;
  822.     }
  824.     /**
  825.      * @param Asset $asset
  826.      * @param array $params
  827.      *
  828.      * @return null|string
  829.      */
  830.     protected function getThumbnailUrl(Asset $asset, array $params = [])
  831.     {
  832.         $defaults = [
  833.             'id' => $asset->getId(),
  834.             'treepreview' => true,
  835.             '_dc' => $asset->getModificationDate(),
  836.         ];
  838.         $params = array_merge($defaults, $params);
  840.         if ($asset instanceof Asset\Image) {
  841.             return $this->generateUrl('pimcore_admin_asset_getimagethumbnail', $params);
  842.         }
  844.         if ($asset instanceof Asset\Folder) {
  845.             return $this->generateUrl('pimcore_admin_asset_getfolderthumbnail', $params);
  846.         }
  848.         if ($asset instanceof Asset\Video && \Pimcore\Video::isAvailable()) {
  849.             return $this->generateUrl('pimcore_admin_asset_getvideothumbnail', $params);
  850.         }
  852.         if ($asset instanceof Asset\Document && \Pimcore\Document::isAvailable() && $asset->getPageCount()) {
  853.             return $this->generateUrl('pimcore_admin_asset_getdocumentthumbnail', $params);
  854.         }
  856.         if ($asset instanceof Asset\Audio) {
  857.             return '/bundles/pimcoreadmin/img/flat-color-icons/speaker.svg';
  858.         }
  860.         if ($asset instanceof Asset) {
  861.             return '/bundles/pimcoreadmin/img/filetype-not-supported.svg';
  862.         }
  863.     }
  865.     /**
  866.      * @Route("/update", name="pimcore_admin_asset_update", methods={"PUT"})
  867.      *
  868.      * @param Request $request
  869.      *
  870.      * @return JsonResponse
  871.      *
  872.      * @throws \Exception
  873.      */
  874.     public function updateAction(Request $request)
  875.     {
  876.         $success = false;
  877.         $allowUpdate = true;
  879.         $updateData = array_merge($request->request->all(), $request->query->all());
  881.         $asset = Asset::getById((int) $request->get('id'));
  882.         if ($asset->isAllowed('settings')) {
  883.             $asset->setUserModification($this->getAdminUser()->getId());
  885.             // if the position is changed the path must be changed || also from the children
  886.             if ($parentId = $request->get('parentId')) {
  887.                 $parentAsset = Asset::getById((int) $parentId);
  889.                 //check if parent is changed i.e. asset is moved
  890.                 if ($asset->getParentId() != $parentAsset->getId()) {
  891.                     if (!$parentAsset->isAllowed('create')) {
  892.                         throw new \Exception('Prevented moving asset - no create permission on new parent ');
  893.                     }
  895.                     $intendedPath = $parentAsset->getRealPath();
  896.                     $pKey = $parentAsset->getKey();
  897.                     if (!empty($pKey)) {
  898.                         $intendedPath .= $parentAsset->getKey() . '/';
  899.                     }
  901.                     $assetWithSamePath = Asset::getByPath($intendedPath . $asset->getKey());
  903.                     if ($assetWithSamePath != null) {
  904.                         $allowUpdate = false;
  905.                     }
  907.                     if ($asset->isLocked()) {
  908.                         $allowUpdate = false;
  909.                     }
  910.                 }
  911.             }
  913.             if ($allowUpdate) {
  914.                 if ($request->get('filename') != $asset->getFilename() && !$asset->isAllowed('rename')) {
  915.                     unset($updateData['filename']);
  916.                     Logger::debug('prevented renaming asset because of missing permissions ');
  917.                 }
  919.                 $asset->setValues($updateData);
  921.                 try {
  922.                     $asset->save();
  923.                     $success = true;
  924.                 } catch (\Exception $e) {
  925.                     return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  926.                 }
  927.             } else {
  928.                 $msg = 'prevented moving asset, asset with same path+key already exists at target location or the asset is locked. ID: ' . $asset->getId();
  929.                 Logger::debug($msg);
  931.                 return $this->adminJson(['success' => $success, 'message' => $msg]);
  932.             }
  933.         } elseif ($asset->isAllowed('rename') && $request->get('filename')) {
  934.             //just rename
  935.             try {
  936.                 $asset->setFilename($request->get('filename'));
  937.                 $asset->save();
  938.                 $success = true;
  939.             } catch (\Exception $e) {
  940.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  941.             }
  942.         } else {
  943.             Logger::debug('prevented update asset because of missing permissions ');
  944.         }
  946.         return $this->adminJson(['success' => $success]);
  947.     }
  949.     /**
  950.      * @Route("/webdav{path}", name="pimcore_admin_webdav", requirements={"path"=".*"})
  951.      */
  952.     public function webdavAction()
  953.     {
  954.         $homeDir = Asset::getById(1);
  956.         try {
  957.             $publicDir = new Asset\WebDAV\Folder($homeDir);
  958.             $objectTree = new Asset\WebDAV\Tree($publicDir);
  959.             $server = new \Sabre\DAV\Server($objectTree);
  960.             $server->setBaseUri($this->generateUrl('pimcore_admin_webdav', ['path' => '/']));
  962.             // lock plugin
  963.             /** @var \Doctrine\DBAL\Driver\PDOConnection $pdo */
  964.             $pdo = \Pimcore\Db::get()->getWrappedConnection();
  965.             $lockBackend = new \Sabre\DAV\Locks\Backend\PDO($pdo);
  966.             $lockBackend->tableName = 'webdav_locks';
  968.             $lockPlugin = new \Sabre\DAV\Locks\Plugin($lockBackend);
  969.             $server->addPlugin($lockPlugin);
  971.             // browser plugin
  972.             $server->addPlugin(new \Sabre\DAV\Browser\Plugin());
  974.             $server->start();
  975.         } catch (\Exception $e) {
  976.             Logger::error((string) $e);
  977.         }
  979.         exit;
  980.     }
  982.     /**
  983.      * @Route("/save", name="pimcore_admin_asset_save", methods={"PUT","POST"})
  984.      *
  985.      * @param Request $request
  986.      * @param EventDispatcherInterface $eventDispatcher
  987.      *
  988.      * @return JsonResponse
  989.      *
  990.      * @throws \Exception
  991.      */
  992.     public function saveAction(Request $request, EventDispatcherInterface $eventDispatcher)
  993.     {
  994.         $asset = Asset::getById((int) $request->get('id'));
  996.         if (!$asset) {
  997.             throw $this->createNotFoundException('Asset not found');
  998.         }
  1000.         if ($asset->isAllowed('publish')) {
  1001.             // metadata
  1002.             if ($request->get('metadata')) {
  1003.                 $metadata = $this->decodeJson($request->get('metadata'));
  1005.                 $metadataEvent = new GenericEvent($this, [
  1006.                     'id' => $asset->getId(),
  1007.                     'metadata' => $metadata,
  1008.                 ]);
  1009.                 $eventDispatcher->dispatch($metadataEvent, AdminEvents::ASSET_METADATA_PRE_SET);
  1011.                 $metadata = $metadataEvent->getArgument('metadata');
  1012.                 $metadataValues = $metadata['values'];
  1014.                 $metadataValues = Asset\Service::minimizeMetadata($metadataValues, 'editor');
  1015.                 $asset->setMetadataRaw($metadataValues);
  1016.             }
  1018.             // properties
  1019.             if ($request->get('properties')) {
  1020.                 $properties = [];
  1021.                 $propertiesData = $this->decodeJson($request->get('properties'));
  1023.                 if (is_array($propertiesData)) {
  1024.                     foreach ($propertiesData as $propertyName => $propertyData) {
  1025.                         $value = $propertyData['data'];
  1027.                         try {
  1028.                             $property = new Model\Property();
  1029.                             $property->setType($propertyData['type']);
  1030.                             $property->setName($propertyName);
  1031.                             $property->setCtype('asset');
  1032.                             $property->setDataFromEditmode($value);
  1033.                             $property->setInheritable($propertyData['inheritable']);
  1035.                             $properties[$propertyName] = $property;
  1036.                         } catch (\Exception $e) {
  1037.                             Logger::err("Can't add " . $propertyName . ' to asset ' . $asset->getRealFullPath());
  1038.                         }
  1039.                     }
  1041.                     $asset->setProperties($properties);
  1042.                 }
  1043.             }
  1045.             $this->applySchedulerDataToElement($request, $asset);
  1047.             if ($request->get('data')) {
  1048.                 $asset->setData($request->get('data'));
  1049.             }
  1051.             // image specific data
  1052.             if ($asset instanceof Asset\Image) {
  1053.                 if ($request->get('image')) {
  1054.                     $imageData = $this->decodeJson($request->get('image'));
  1055.                     if (isset($imageData['focalPoint'])) {
  1056.                         $asset->setCustomSetting('focalPointX', $imageData['focalPoint']['x']);
  1057.                         $asset->setCustomSetting('focalPointY', $imageData['focalPoint']['y']);
  1058.                         $asset->removeCustomSetting('disableFocalPointDetection');
  1059.                     }
  1060.                 } else {
  1061.                     // wipe all data
  1062.                     $asset->removeCustomSetting('focalPointX');
  1063.                     $asset->removeCustomSetting('focalPointY');
  1064.                     $asset->setCustomSetting('disableFocalPointDetection', true);
  1065.                 }
  1066.             }
  1068.             $asset->setUserModification($this->getAdminUser()->getId());
  1069.             if ($request->get('task') === 'session') {
  1070.                 // save to session only
  1071.                 Asset\Service::saveElementToSession($asset);
  1072.             } else {
  1073.                 $asset->save();
  1074.             }
  1076.             $treeData = $this->getTreeNodeConfig($asset);
  1078.             return $this->adminJson([
  1079.                 'success' => true,
  1080.                 'data' => [
  1081.                     'versionDate' => $asset->getModificationDate(),
  1082.                     'versionCount' => $asset->getVersionCount(),
  1083.                 ],
  1084.                 'treeData' => $treeData,
  1085.             ]);
  1086.         } else {
  1087.             throw $this->createAccessDeniedHttpException();
  1088.         }
  1089.     }
  1091.     /**
  1092.      * @Route("/publish-version", name="pimcore_admin_asset_publishversion", methods={"POST"})
  1093.      *
  1094.      * @param Request $request
  1095.      *
  1096.      * @return JsonResponse
  1097.      */
  1098.     public function publishVersionAction(Request $request)
  1099.     {
  1100.         $id = (int)$request->get('id');
  1101.         $version = Model\Version::getById($id);
  1102.         $asset = $version?->loadData();
  1104.         if (!$asset) {
  1105.             throw $this->createNotFoundException('Version with id [' . $id . "] doesn't exist");
  1106.         }
  1108.         $currentAsset = Asset::getById($asset->getId());
  1109.         if ($currentAsset->isAllowed('publish')) {
  1110.             try {
  1111.                 $asset->setUserModification($this->getAdminUser()->getId());
  1112.                 $asset->save();
  1114.                 $treeData = $this->getTreeNodeConfig($asset);
  1116.                 return $this->adminJson(['success' => true, 'treeData' => $treeData]);
  1117.             } catch (\Exception $e) {
  1118.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1119.             }
  1120.         }
  1122.         throw $this->createAccessDeniedHttpException();
  1123.     }
  1125.     /**
  1126.      * @Route("/show-version", name="pimcore_admin_asset_showversion", methods={"GET"})
  1127.      *
  1128.      * @param Request $request
  1129.      *
  1130.      * @return Response
  1131.      */
  1132.     public function showVersionAction(Request $request)
  1133.     {
  1134.         $id = (int)$request->get('id');
  1135.         $version = Model\Version::getById($id);
  1136.         $asset = $version?->loadData();
  1137.         if (!$asset) {
  1138.             throw $this->createNotFoundException('Version with id [' . $id . "] doesn't exist");
  1139.         }
  1141.         if (!$asset->isAllowed('versions')) {
  1142.             throw $this->createAccessDeniedHttpException('Permission denied, version id [' . $id . ']');
  1143.         }
  1145.         $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  1147.         return $this->render(
  1148.             '@PimcoreAdmin/Admin/Asset/showVersion' . ucfirst($asset->getType()) . '.html.twig',
  1149.             [
  1150.                 'asset' => $asset,
  1151.                 'loader' => $loader,
  1152.             ]
  1153.         );
  1154.     }
  1156.     /**
  1157.      * @Route("/download", name="pimcore_admin_asset_download", methods={"GET"})
  1158.      *
  1159.      * @param Request $request
  1160.      *
  1161.      * @return StreamedResponse
  1162.      */
  1163.     public function downloadAction(Request $request)
  1164.     {
  1165.         $asset = Asset::getById((int) $request->get('id'));
  1167.         if (!$asset) {
  1168.             throw $this->createNotFoundException('Asset not found');
  1169.         }
  1171.         if (!$asset->isAllowed('view')) {
  1172.             throw $this->createAccessDeniedException('not allowed to view asset');
  1173.         }
  1175.         $stream = $asset->getStream();
  1177.         if (!is_resource($stream)) {
  1178.             throw $this->createNotFoundException('Unable to get resource for asset ' . $asset->getId());
  1179.         }
  1181.         return new StreamedResponse(function () use ($stream) {
  1182.             fpassthru($stream);
  1183.         }, 200, [
  1184.             'Content-Type' => $asset->getMimeType(),
  1185.             'Content-Disposition' => sprintf('attachment; filename="%s"', $asset->getFilename()),
  1186.             'Content-Length' => $asset->getFileSize(),
  1187.         ]);
  1188.     }
  1190.     /**
  1191.      * @Route("/download-image-thumbnail", name="pimcore_admin_asset_downloadimagethumbnail", methods={"GET"})
  1192.      *
  1193.      * @param Request $request
  1194.      *
  1195.      * @return BinaryFileResponse
  1196.      */
  1197.     public function downloadImageThumbnailAction(Request $request)
  1198.     {
  1199.         $image = Asset\Image::getById((int) $request->get('id'));
  1201.         if (!$image) {
  1202.             throw $this->createNotFoundException('Asset not found');
  1203.         }
  1205.         if (!$image->isAllowed('view')) {
  1206.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1207.         }
  1209.         $config = null;
  1210.         $thumbnail = null;
  1211.         $thumbnailName = $request->get('thumbnail');
  1212.         $thumbnailFile = null;
  1213.         $deleteThumbnail = true;
  1215.         if ($request->get('config')) {
  1216.             $config = $this->decodeJson($request->get('config'));
  1217.         } elseif ($request->get('type')) {
  1218.             $predefined = [
  1219.                 'web' => [
  1220.                     'resize_mode' => 'scaleByWidth',
  1221.                     'width' => 3500,
  1222.                     'dpi' => 72,
  1223.                     'format' => 'JPEG',
  1224.                     'quality' => 85,
  1225.                 ],
  1226.                 'print' => [
  1227.                     'resize_mode' => 'scaleByWidth',
  1228.                     'width' => 6000,
  1229.                     'dpi' => 300,
  1230.                     'format' => 'JPEG',
  1231.                     'quality' => 95,
  1232.                 ],
  1233.                 'office' => [
  1234.                     'resize_mode' => 'scaleByWidth',
  1235.                     'width' => 1190,
  1236.                     'dpi' => 144,
  1237.                     'format' => 'JPEG',
  1238.                     'quality' => 90,
  1239.                 ],
  1240.             ];
  1242.             $config = $predefined[$request->get('type')];
  1243.         } elseif ($thumbnailName) {
  1244.             $thumbnail = $image->getThumbnail($thumbnailName);
  1245.             $deleteThumbnail = false;
  1246.         }
  1248.         if ($config) {
  1249.             $thumbnailConfig = new Asset\Image\Thumbnail\Config();
  1250.             $thumbnailConfig->setName('pimcore-download-' . $image->getId() . '-' . md5($request->get('config')));
  1252.             if ($config['resize_mode'] == 'scaleByWidth') {
  1253.                 $thumbnailConfig->addItem('scaleByWidth', [
  1254.                     'width' => $config['width'],
  1255.                 ]);
  1256.             } elseif ($config['resize_mode'] == 'scaleByHeight') {
  1257.                 $thumbnailConfig->addItem('scaleByHeight', [
  1258.                     'height' => $config['height'],
  1259.                 ]);
  1260.             } else {
  1261.                 $thumbnailConfig->addItem('resize', [
  1262.                     'width' => $config['width'],
  1263.                     'height' => $config['height'],
  1264.                 ]);
  1265.             }
  1267.             $thumbnailConfig->setQuality($config['quality']);
  1268.             $thumbnailConfig->setFormat($config['format']);
  1269.             $thumbnailConfig->setRasterizeSVG(true);
  1271.             if ($thumbnailConfig->getFormat() == 'JPEG') {
  1272.                 $thumbnailConfig->setPreserveMetaData(true);
  1274.                 if (empty($config['quality'])) {
  1275.                     $thumbnailConfig->setPreserveColor(true);
  1276.                 }
  1277.             }
  1279.             $thumbnail = $image->getThumbnail($thumbnailConfig);
  1280.             $thumbnailFile = $thumbnail->getLocalFile();
  1282.             $exiftool = \Pimcore\Tool\Console::getExecutable('exiftool');
  1283.             if ($thumbnailConfig->getFormat() == 'JPEG' && $exiftool && isset($config['dpi']) && $config['dpi']) {
  1284.                 $process = new Process([$exiftool, '-overwrite_original', '-xresolution=' . (int)$config['dpi'], '-yresolution=' . (int)$config['dpi'], '-resolutionunit=inches', $thumbnailFile]);
  1285.                 $process->run();
  1286.             }
  1287.         }
  1289.         if ($thumbnail) {
  1290.             $thumbnailFile = $thumbnailFile ?: $thumbnail->getLocalFile();
  1292.             $downloadFilename = preg_replace(
  1293.                 '/\.' . preg_quote(File::getFileExtension($image->getFilename())) . '$/i',
  1294.                 '.' . $thumbnail->getFileExtension(),
  1295.                 $image->getFilename()
  1296.             );
  1297.             $downloadFilename = strtolower($downloadFilename);
  1299.             clearstatcache();
  1301.             $response = new BinaryFileResponse($thumbnailFile);
  1302.             $response->headers->set('Content-Type', $thumbnail->getMimeType());
  1303.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $downloadFilename);
  1304.             $this->addThumbnailCacheHeaders($response);
  1305.             $response->deleteFileAfterSend($deleteThumbnail);
  1307.             return $response;
  1308.         }
  1310.         throw $this->createNotFoundException('Thumbnail not found');
  1311.     }
  1313.     /**
  1314.      * @Route("/get-asset", name="pimcore_admin_asset_getasset", methods={"GET"})
  1315.      *
  1316.      * @param Request $request
  1317.      *
  1318.      * @return StreamedResponse
  1319.      */
  1320.     public function getAssetAction(Request $request)
  1321.     {
  1322.         $image = Asset::getById((int)$request->get('id'));
  1324.         if (!$image) {
  1325.             throw $this->createNotFoundException('Asset not found');
  1326.         }
  1328.         if (!$image->isAllowed('view')) {
  1329.             throw $this->createAccessDeniedException('not allowed to view asset');
  1330.         }
  1332.         $stream = $image->getStream();
  1334.         if (!is_resource($stream)) {
  1335.             throw $this->createNotFoundException('Unable to get resource for asset ' . $image->getId());
  1336.         }
  1338.         $response = new StreamedResponse(function () use ($stream) {
  1339.             fpassthru($stream);
  1340.         }, 200, [
  1341.             'Content-Type' => $image->getMimeType(),
  1342.             'Access-Control-Allow-Origin' => '*',
  1343.         ]);
  1344.         $this->addThumbnailCacheHeaders($response);
  1346.         return $response;
  1347.     }
  1349.     /**
  1350.      * @Route("/get-image-thumbnail", name="pimcore_admin_asset_getimagethumbnail", methods={"GET"})
  1351.      *
  1352.      * @param Request $request
  1353.      *
  1354.      * @return StreamedResponse|JsonResponse|BinaryFileResponse
  1355.      */
  1356.     public function getImageThumbnailAction(Request $request)
  1357.     {
  1358.         $fileinfo = $request->get('fileinfo');
  1359.         $image = Asset\Image::getById((int)$request->get('id'));
  1361.         if (!$image) {
  1362.             throw $this->createNotFoundException('Asset not found');
  1363.         }
  1365.         if (!$image->isAllowed('view')) {
  1366.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1367.         }
  1369.         $thumbnailConfig = null;
  1371.         if ($request->get('thumbnail')) {
  1372.             $thumbnailConfig = $image->getThumbnailConfig($request->get('thumbnail'));
  1373.         }
  1374.         if (!$thumbnailConfig) {
  1375.             if ($request->get('config')) {
  1376.                 $thumbnailConfig = $image->getThumbnailConfig($this->decodeJson($request->get('config')));
  1377.             } else {
  1378.                 $thumbnailConfig = $image->getThumbnailConfig(array_merge($request->request->all(), $request->query->all()));
  1379.             }
  1380.         } else {
  1381.             // no high-res images in admin mode (editmode)
  1382.             // this is mostly because of the document's image editable, which doesn't know anything about the thumbnail
  1383.             // configuration, so the dimensions would be incorrect (double the size)
  1384.             $thumbnailConfig->setHighResolution(1);
  1385.         }
  1387.         $format = strtolower($thumbnailConfig->getFormat());
  1388.         if ($format == 'source' || $format == 'print') {
  1389.             $thumbnailConfig->setFormat('PNG');
  1390.             $thumbnailConfig->setRasterizeSVG(true);
  1391.         }
  1393.         if ($request->get('treepreview')) {
  1394.             $thumbnailConfig = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1395.             if ($request->get('origin') === 'treeNode' && !$image->getThumbnail($thumbnailConfig)->exists()) {
  1396.                 \Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1397.                     new AssetPreviewImageMessage($image->getId())
  1398.                 );
  1400.                 throw $this->createNotFoundException(sprintf('Tree preview thumbnail not available for asset %s', $image->getId()));
  1401.             }
  1402.         }
  1404.         $cropPercent = $request->get('cropPercent');
  1405.         if ($cropPercent && filter_var($cropPercent, FILTER_VALIDATE_BOOLEAN)) {
  1406.             $thumbnailConfig->addItemAt(0, 'cropPercent', [
  1407.                 'width' => $request->get('cropWidth'),
  1408.                 'height' => $request->get('cropHeight'),
  1409.                 'y' => $request->get('cropTop'),
  1410.                 'x' => $request->get('cropLeft'),
  1411.             ]);
  1413.             $thumbnailConfig->generateAutoName();
  1414.         }
  1416.         $thumbnail = $image->getThumbnail($thumbnailConfig);
  1418.         if ($fileinfo) {
  1419.             return $this->adminJson([
  1420.                 'width' => $thumbnail->getWidth(),
  1421.                 'height' => $thumbnail->getHeight(), ]);
  1422.         }
  1424.         $stream = $thumbnail->getStream();
  1426.         if (!$stream) {
  1427.             return new BinaryFileResponse(PIMCORE_PATH . '/bundles/AdminBundle/Resources/public/img/filetype-not-supported.svg');
  1428.         }
  1430.         $response = new StreamedResponse(function () use ($stream) {
  1431.             fpassthru($stream);
  1432.         }, 200, [
  1433.             'Content-Type' => $thumbnail->getMimeType(),
  1434.             'Access-Control-Allow-Origin', '*',
  1435.         ]);
  1437.         $this->addThumbnailCacheHeaders($response);
  1439.         return $response;
  1440.     }
  1442.     /**
  1443.      * @Route("/get-folder-thumbnail", name="pimcore_admin_asset_getfolderthumbnail", methods={"GET"})
  1444.      *
  1445.      * @param Request $request
  1446.      *
  1447.      * @return StreamedResponse
  1448.      */
  1449.     public function getFolderThumbnailAction(Request $request)
  1450.     {
  1451.         $folder = null;
  1453.         if ($request->get('id')) {
  1454.             $folder = Asset\Folder::getById((int)$request->get('id'));
  1455.             if ($folder instanceof  Asset\Folder) {
  1456.                 if (!$folder->isAllowed('view')) {
  1457.                     throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1458.                 }
  1460.                 $stream = $folder->getPreviewImage();
  1461.                 if (!$stream) {
  1462.                     throw $this->createNotFoundException(sprintf('Tree preview thumbnail not available for asset %s', $folder->getId()));
  1463.                 } else {
  1464.                     $response = new StreamedResponse(function () use ($stream) {
  1465.                         fpassthru($stream);
  1466.                     }, 200, [
  1467.                         'Content-Type' => 'image/jpg',
  1468.                     ]);
  1469.                 }
  1471.                 $this->addThumbnailCacheHeaders($response);
  1473.                 return $response;
  1474.             }
  1475.         }
  1477.         throw $this->createNotFoundException('could not load asset folder');
  1478.     }
  1480.     /**
  1481.      * @Route("/get-video-thumbnail", name="pimcore_admin_asset_getvideothumbnail", methods={"GET"})
  1482.      *
  1483.      * @param Request $request
  1484.      *
  1485.      * @return StreamedResponse
  1486.      */
  1487.     public function getVideoThumbnailAction(Request $request)
  1488.     {
  1489.         $video = null;
  1491.         if ($request->get('id')) {
  1492.             $video = Asset\Video::getById((int)$request->get('id'));
  1493.         } elseif ($request->get('path')) {
  1494.             $video = Asset\Video::getByPath($request->get('path'));
  1495.         }
  1497.         if (!$video) {
  1498.             throw $this->createNotFoundException('could not load video asset');
  1499.         }
  1501.         if (!$video->isAllowed('view')) {
  1502.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1503.         }
  1505.         $thumbnail = array_merge($request->request->all(), $request->query->all());
  1507.         if ($request->get('treepreview')) {
  1508.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1509.         }
  1511.         $time = null;
  1512.         if (is_numeric($request->get('time'))) {
  1513.             $time = (int)$request->get('time');
  1514.         }
  1516.         if ($request->get('settime')) {
  1517.             $video->removeCustomSetting('image_thumbnail_asset');
  1518.             $video->setCustomSetting('image_thumbnail_time', $time);
  1519.             $video->save();
  1520.         }
  1522.         $image = null;
  1523.         if ($request->get('image')) {
  1524.             $image = Asset\Image::getById((int)$request->get('image'));
  1525.         }
  1527.         if ($request->get('setimage') && $image) {
  1528.             $video->removeCustomSetting('image_thumbnail_time');
  1529.             $video->setCustomSetting('image_thumbnail_asset', $image->getId());
  1530.             $video->save();
  1531.         }
  1533.         $thumb = $video->getImageThumbnail($thumbnail, $time, $image);
  1535.         if ($request->get('origin') === 'treeNode' && !$thumb->exists()) {
  1536.             \Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1537.                 new AssetPreviewImageMessage($video->getId())
  1538.             );
  1540.             throw $this->createNotFoundException(sprintf('Tree preview thumbnail not available for asset %s', $video->getId()));
  1541.         }
  1543.         $stream = $thumb->getStream();
  1544.         if (!$stream) {
  1545.             throw $this->createNotFoundException('Unable to get video thumbnail for video ' . $video->getId());
  1546.         }
  1548.         $response = new StreamedResponse(function () use ($stream) {
  1549.             fpassthru($stream);
  1550.         }, 200, [
  1551.             'Content-Type' => 'image/' . $thumb->getFileExtension(),
  1552.         ]);
  1554.         $this->addThumbnailCacheHeaders($response);
  1556.         return $response;
  1557.     }
  1559.     /**
  1560.      * @Route("/get-document-thumbnail", name="pimcore_admin_asset_getdocumentthumbnail", methods={"GET"})
  1561.      *
  1562.      * @param Request $request
  1563.      *
  1564.      * @return StreamedResponse|BinaryFileResponse
  1565.      */
  1566.     public function getDocumentThumbnailAction(Request $request)
  1567.     {
  1568.         $document = Asset\Document::getById((int)$request->get('id'));
  1570.         if (!$document) {
  1571.             throw $this->createNotFoundException('could not load document asset');
  1572.         }
  1574.         if (!$document->isAllowed('view')) {
  1575.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1576.         }
  1578.         $thumbnail = Asset\Image\Thumbnail\Config::getByAutoDetect(array_merge($request->request->all(), $request->query->all()));
  1580.         $format = strtolower($thumbnail->getFormat());
  1581.         if ($format == 'source') {
  1582.             $thumbnail->setFormat('jpeg'); // default format for documents is JPEG not PNG (=too big)
  1583.         }
  1585.         if ($request->get('treepreview')) {
  1586.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig();
  1587.         }
  1589.         $page = 1;
  1590.         if (is_numeric($request->get('page'))) {
  1591.             $page = (int)$request->get('page');
  1592.         }
  1594.         $thumb = $document->getImageThumbnail($thumbnail, $page);
  1596.         if ($request->get('origin') === 'treeNode' && !$thumb->exists()) {
  1597.             \Pimcore::getContainer()->get('messenger.bus.pimcore-core')->dispatch(
  1598.                 new AssetPreviewImageMessage($document->getId())
  1599.             );
  1601.             throw $this->createNotFoundException(sprintf('Tree preview thumbnail not available for asset %s', $document->getId()));
  1602.         }
  1604.         $stream = $thumb->getStream();
  1605.         if ($stream) {
  1606.             $response = new StreamedResponse(function () use ($stream) {
  1607.                 fpassthru($stream);
  1608.             }, 200, [
  1609.                 'Content-Type' => 'image/' . $thumb->getFileExtension(),
  1610.             ]);
  1611.         } else {
  1612.             $response = new BinaryFileResponse(PIMCORE_PATH . '/bundles/AdminBundle/Resources/public/img/filetype-not-supported.svg');
  1613.         }
  1615.         $this->addThumbnailCacheHeaders($response);
  1617.         return $response;
  1618.     }
  1620.     /**
  1621.      * @param Response $response
  1622.      */
  1623.     protected function addThumbnailCacheHeaders(Response $response)
  1624.     {
  1625.         $lifetime = 300;
  1626.         $date = new \DateTime('now');
  1627.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  1629.         $response->setMaxAge($lifetime);
  1630.         $response->setPublic();
  1631.         $response->setExpires($date);
  1632.         $response->headers->set('Pragma', '');
  1633.     }
  1635.     /**
  1636.      * @Route("/get-preview-document", name="pimcore_admin_asset_getpreviewdocument", methods={"GET"})
  1637.      *
  1638.      * @param Request $request
  1639.      *
  1640.      * @return StreamedResponse
  1641.      */
  1642.     public function getPreviewDocumentAction(Request $request)
  1643.     {
  1644.         $asset = Asset\Document::getById((int) $request->get('id'));
  1646.         if (!$asset) {
  1647.             throw $this->createNotFoundException('could not load document asset');
  1648.         }
  1650.         if ($asset->isAllowed('view')) {
  1651.             $stream = $this->getDocumentPreviewPdf($asset);
  1652.             if ($stream) {
  1653.                 return new StreamedResponse(function () use ($stream) {
  1654.                     fpassthru($stream);
  1655.                 }, 200, [
  1656.                     'Content-Type' => 'application/pdf',
  1657.                 ]);
  1658.             } else {
  1659.                 throw $this->createNotFoundException('Unable to get preview for asset ' . $asset->getId());
  1660.             }
  1661.         } else {
  1662.             throw $this->createAccessDeniedException('Access to asset ' . $asset->getId() . ' denied');
  1663.         }
  1664.     }
  1666.     /**
  1667.      * @param Asset\Document $asset
  1668.      *
  1669.      * @return resource|null
  1670.      */
  1671.     protected function getDocumentPreviewPdf(Asset\Document $asset)
  1672.     {
  1673.         $stream = null;
  1675.         if ($asset->getMimeType() == 'application/pdf') {
  1676.             $stream = $asset->getStream();
  1677.         }
  1679.         if (!$stream && $asset->getPageCount() && \Pimcore\Document::isAvailable() && \Pimcore\Document::isFileTypeSupported($asset->getFilename())) {
  1680.             try {
  1681.                 $document = \Pimcore\Document::getInstance();
  1682.                 $stream = $document->getPdf($asset);
  1683.             } catch (\Exception $e) {
  1684.                 // nothing to do
  1685.             }
  1686.         }
  1688.         return $stream;
  1689.     }
  1691.     /**
  1692.      * @Route("/get-preview-video", name="pimcore_admin_asset_getpreviewvideo", methods={"GET"})
  1693.      *
  1694.      * @param Request $request
  1695.      *
  1696.      * @return Response
  1697.      */
  1698.     public function getPreviewVideoAction(Request $request)
  1699.     {
  1700.         $asset = Asset\Video::getById((int) $request->get('id'));
  1702.         if (!$asset) {
  1703.             throw $this->createNotFoundException('could not load video asset');
  1704.         }
  1706.         if (!$asset->isAllowed('view')) {
  1707.             throw $this->createAccessDeniedException('not allowed to preview');
  1708.         }
  1710.         $previewData = ['asset' => $asset];
  1711.         $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  1712.         $thumbnail = $asset->getThumbnail($config, ['mp4']);
  1714.         if ($thumbnail) {
  1715.             $previewData['asset'] = $asset;
  1716.             $previewData['thumbnail'] = $thumbnail;
  1718.             if ($thumbnail['status'] == 'finished') {
  1719.                 return $this->render(
  1720.                     '@PimcoreAdmin/Admin/Asset/getPreviewVideoDisplay.html.twig',
  1721.                     $previewData
  1722.                 );
  1723.             } else {
  1724.                 return $this->render(
  1725.                     '@PimcoreAdmin/Admin/Asset/getPreviewVideoError.html.twig',
  1726.                     $previewData
  1727.                 );
  1728.             }
  1729.         } else {
  1730.             return $this->render(
  1731.                 '@PimcoreAdmin/Admin/Asset/getPreviewVideoError.html.twig',
  1732.                 $previewData
  1733.             );
  1734.         }
  1735.     }
  1737.     /**
  1738.      * @Route("/serve-video-preview", name="pimcore_admin_asset_servevideopreview", methods={"GET"})
  1739.      *
  1740.      * @param Request $request
  1741.      *
  1742.      * @return StreamedResponse
  1743.      */
  1744.     public function serveVideoPreviewAction(Request $request)
  1745.     {
  1746.         $asset = Asset\Video::getById((int) $request->get('id'));
  1748.         if (!$asset) {
  1749.             throw $this->createNotFoundException('could not load video asset');
  1750.         }
  1752.         if (!$asset->isAllowed('view')) {
  1753.             throw $this->createAccessDeniedException('not allowed to preview');
  1754.         }
  1756.         $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  1757.         $thumbnail = $asset->getThumbnail($config, ['mp4']);
  1758.         $storagePath = $asset->getRealPath() . '/' . preg_replace('@^' . preg_quote($asset->getPath(), '@') . '@', '', urldecode($thumbnail['formats']['mp4']));
  1760.         $storage = Tool\Storage::get('thumbnail');
  1761.         if ($storage->fileExists($storagePath)) {
  1762.             $fs = $storage->fileSize($storagePath);
  1763.             $stream = $storage->readStream($storagePath);
  1765.             return new StreamedResponse(function () use ($stream) {
  1766.                 fpassthru($stream);
  1767.             }, 200, [
  1768.                 'Content-Type' => 'video/mp4',
  1769.                 'Content-Length' => $fs,
  1770.                 'Accept-Ranges' => 'bytes',
  1771.             ]);
  1772.         } else {
  1773.             throw $this->createNotFoundException('Video thumbnail not found');
  1774.         }
  1775.     }
  1777.     /**
  1778.      * @Route("/image-editor", name="pimcore_admin_asset_imageeditor", methods={"GET"})
  1779.      *
  1780.      * @param Request $request
  1781.      *
  1782.      * @return Response
  1783.      */
  1784.     public function imageEditorAction(Request $request)
  1785.     {
  1786.         $asset = Asset::getById((int) $request->get('id'));
  1788.         if (!$asset->isAllowed('view')) {
  1789.             throw $this->createAccessDeniedException('Not allowed to preview');
  1790.         }
  1792.         return $this->render(
  1793.             '@PimcoreAdmin/Admin/Asset/imageEditor.html.twig',
  1794.             ['asset' => $asset]
  1795.         );
  1796.     }
  1798.     /**
  1799.      * @Route("/image-editor-save", name="pimcore_admin_asset_imageeditorsave", methods={"PUT"})
  1800.      *
  1801.      * @param Request $request
  1802.      *
  1803.      * @return JsonResponse
  1804.      */
  1805.     public function imageEditorSaveAction(Request $request)
  1806.     {
  1807.         $asset = Asset::getById((int) $request->get('id'));
  1809.         if (!$asset) {
  1810.             throw $this->createNotFoundException('Asset not found');
  1811.         }
  1813.         if (!$asset->isAllowed('publish')) {
  1814.             throw $this->createAccessDeniedException('not allowed to publish');
  1815.         }
  1817.         $data = $request->get('dataUri');
  1818.         $data = substr($data, strpos($data, ','));
  1819.         $data = base64_decode($data);
  1820.         $asset->setData($data);
  1821.         $asset->setUserModification($this->getAdminUser()->getId());
  1822.         $asset->save();
  1824.         return $this->adminJson(['success' => true]);
  1825.     }
  1827.     /**
  1828.      * @Route("/get-folder-content-preview", name="pimcore_admin_asset_getfoldercontentpreview", methods={"GET"})
  1829.      *
  1830.      * @param Request $request
  1831.      *
  1832.      * @return JsonResponse
  1833.      */
  1834.     public function getFolderContentPreviewAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1835.     {
  1836.         $allParams = array_merge($request->request->all(), $request->query->all());
  1838.         $filterPrepareEvent = new GenericEvent($this, [
  1839.             'requestParams' => $allParams,
  1840.         ]);
  1841.         $eventDispatcher->dispatch($filterPrepareEvent, AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE);
  1843.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  1845.         $folder = Asset::getById($allParams['id']);
  1847.         $start = 0;
  1848.         $limit = 10;
  1850.         if ($allParams['limit']) {
  1851.             $limit = $allParams['limit'];
  1852.         }
  1853.         if ($allParams['start']) {
  1854.             $start = $allParams['start'];
  1855.         }
  1857.         $conditionFilters = [];
  1858.         $list = new Asset\Listing();
  1859.         $conditionFilters[] = 'path LIKE ' . ($folder->getRealFullPath() == '/' ? "'/%'" : $list->quote(Helper::escapeLike($folder->getRealFullPath()) . '/%')) . " AND type != 'folder'";
  1861.         if (!$this->getAdminUser()->isAdmin()) {
  1862.             $userIds = $this->getAdminUser()->getRoles();
  1863.             $userIds[] = $this->getAdminUser()->getId();
  1864.             $conditionFilters[] = ' (
  1865.                                                     (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(CONCAT(path, filename),cpath)=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  1866.                                                     OR
  1867.                                                     (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(cpath,CONCAT(path, filename))=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  1868.                                                  )';
  1869.         }
  1871.         $condition = implode(' AND ', $conditionFilters);
  1873.         $list->setCondition($condition);
  1874.         $list->setLimit($limit);
  1875.         $list->setOffset($start);
  1876.         $list->setOrderKey('CAST(filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci ASC', false);
  1878.         $beforeListLoadEvent = new GenericEvent($this, [
  1879.             'list' => $list,
  1880.             'context' => $allParams,
  1881.         ]);
  1882.         $eventDispatcher->dispatch($beforeListLoadEvent, AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD);
  1883.         /** @var Asset\Listing $list */
  1884.         $list = $beforeListLoadEvent->getArgument('list');
  1886.         $list->load();
  1888.         $assets = [];
  1890.         foreach ($list as $asset) {
  1891.             $filenameDisplay = $asset->getFilename();
  1892.             if (strlen($filenameDisplay) > 32) {
  1893.                 $filenameDisplay = substr($filenameDisplay, 0, 25) . '...' . \Pimcore\File::getFileExtension($filenameDisplay);
  1894.             }
  1896.             // Like for treeGetChildsByIdAction, so we respect isAllowed method which can be extended (object DI) for custom permissions, so relying only users_workspaces_asset is insufficient and could lead security breach
  1897.             if ($asset->isAllowed('list')) {
  1898.                 $assets[] = [
  1899.                     'id' => $asset->getId(),
  1900.                     'type' => $asset->getType(),
  1901.                     'filename' => $asset->getFilename(),
  1902.                     'filenameDisplay' => htmlspecialchars($filenameDisplay),
  1903.                     'url' => $this->getThumbnailUrl($asset),
  1904.                     'idPath' => $data['idPath'] = Element\Service::getIdPath($asset),
  1905.                 ];
  1906.             }
  1907.         }
  1909.         // We need to temporary use data key to be compatible with the ASSET_LIST_AFTER_LIST_LOAD global event
  1910.         $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  1912.         $afterListLoadEvent = new GenericEvent($this, [
  1913.             'list' => $result,
  1914.             'context' => $allParams,
  1915.         ]);
  1916.         $eventDispatcher->dispatch($afterListLoadEvent, AdminEvents::ASSET_LIST_AFTER_LIST_LOAD);
  1917.         $result = $afterListLoadEvent->getArgument('list');
  1919.         // Here we revert to assets key
  1920.         return $this->adminJson(['assets' => $result['data'], 'success' => $result['success'], 'total' => $result['total']]);
  1921.     }
  1923.     /**
  1924.      * @Route("/copy-info", name="pimcore_admin_asset_copyinfo", methods={"GET"})
  1925.      *
  1926.      * @param Request $request
  1927.      *
  1928.      * @return JsonResponse
  1929.      */
  1930.     public function copyInfoAction(Request $request)
  1931.     {
  1932.         $transactionId = time();
  1933.         $pasteJobs = [];
  1935.         Tool\Session::useSession(function (AttributeBagInterface $session) use ($transactionId) {
  1936.             $session->set((string) $transactionId, []);
  1937.         }, 'pimcore_copy');
  1939.         if ($request->get('type') == 'recursive') {
  1940.             $asset = Asset::getById((int) $request->get('sourceId'));
  1942.             if (!$asset) {
  1943.                 throw $this->createNotFoundException('Source not found');
  1944.             }
  1946.             // first of all the new parent
  1947.             $pasteJobs[] = [[
  1948.                 'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1949.                 'method' => 'POST',
  1950.                 'params' => [
  1951.                     'sourceId' => $request->get('sourceId'),
  1952.                     'targetId' => $request->get('targetId'),
  1953.                     'type' => 'child',
  1954.                     'transactionId' => $transactionId,
  1955.                     'saveParentId' => true,
  1956.                 ],
  1957.             ]];
  1959.             if ($asset->hasChildren()) {
  1960.                 // get amount of children
  1961.                 $list = new Asset\Listing();
  1962.                 $list->setCondition('path LIKE ?', [$list->escapeLike($asset->getRealFullPath()) . '/%']);
  1963.                 $list->setOrderKey('LENGTH(path)', false);
  1964.                 $list->setOrder('ASC');
  1965.                 $childIds = $list->loadIdList();
  1967.                 if (count($childIds) > 0) {
  1968.                     foreach ($childIds as $id) {
  1969.                         $pasteJobs[] = [[
  1970.                             'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1971.                             'method' => 'POST',
  1972.                             'params' => [
  1973.                                 'sourceId' => $id,
  1974.                                 'targetParentId' => $request->get('targetId'),
  1975.                                 'sourceParentId' => $request->get('sourceId'),
  1976.                                 'type' => 'child',
  1977.                                 'transactionId' => $transactionId,
  1978.                             ],
  1979.                         ]];
  1980.                     }
  1981.                 }
  1982.             }
  1983.         } elseif ($request->get('type') == 'child' || $request->get('type') == 'replace') {
  1984.             // the object itself is the last one
  1985.             $pasteJobs[] = [[
  1986.                 'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1987.                 'method' => 'POST',
  1988.                 'params' => [
  1989.                     'sourceId' => $request->get('sourceId'),
  1990.                     'targetId' => $request->get('targetId'),
  1991.                     'type' => $request->get('type'),
  1992.                     'transactionId' => $transactionId,
  1993.                 ],
  1994.             ]];
  1995.         }
  1997.         return $this->adminJson([
  1998.             'pastejobs' => $pasteJobs,
  1999.         ]);
  2000.     }
  2002.     /**
  2003.      * @Route("/copy", name="pimcore_admin_asset_copy", methods={"POST"})
  2004.      *
  2005.      * @param Request $request
  2006.      *
  2007.      * @return JsonResponse
  2008.      */
  2009.     public function copyAction(Request $request)
  2010.     {
  2011.         $success = false;
  2012.         $sourceId = (int)$request->get('sourceId');
  2013.         $source = Asset::getById($sourceId);
  2015.         $session = Tool\Session::get('pimcore_copy');
  2016.         $sessionBag = $session->get($request->get('transactionId'));
  2018.         $targetId = (int)$request->get('targetId');
  2019.         if ($request->get('targetParentId')) {
  2020.             $sourceParent = Asset::getById((int) $request->get('sourceParentId'));
  2022.             // this is because the key can get the prefix "_copy" if the target does already exists
  2023.             if ($sessionBag['parentId']) {
  2024.                 $targetParent = Asset::getById($sessionBag['parentId']);
  2025.             } else {
  2026.                 $targetParent = Asset::getById((int) $request->get('targetParentId'));
  2027.             }
  2029.             $targetPath = preg_replace('@^' . $sourceParent->getRealFullPath() . '@', $targetParent . '/', $source->getRealPath());
  2030.             $target = Asset::getByPath($targetPath);
  2031.         } else {
  2032.             $target = Asset::getById($targetId);
  2033.         }
  2035.         if (!$target) {
  2036.             throw $this->createNotFoundException('Target not found');
  2037.         }
  2039.         if ($target->isAllowed('create')) {
  2040.             $source = Asset::getById($sourceId);
  2041.             if ($source != null) {
  2042.                 if ($request->get('type') == 'child') {
  2043.                     $newAsset = $this->_assetService->copyAsChild($target, $source);
  2045.                     // this is because the key can get the prefix "_copy" if the target does already exists
  2046.                     if ($request->get('saveParentId')) {
  2047.                         $sessionBag['parentId'] = $newAsset->getId();
  2048.                     }
  2049.                 } elseif ($request->get('type') == 'replace') {
  2050.                     $this->_assetService->copyContents($target, $source);
  2051.                 }
  2053.                 $session->set($request->get('transactionId'), $sessionBag);
  2054.                 Tool\Session::writeClose();
  2056.                 $success = true;
  2057.             } else {
  2058.                 Logger::debug('prevended copy/paste because asset with same path+key already exists in this location');
  2059.             }
  2060.         } else {
  2061.             Logger::error('could not execute copy/paste because of missing permissions on target [ ' . $targetId . ' ]');
  2063.             throw $this->createAccessDeniedHttpException();
  2064.         }
  2066.         Tool\Session::writeClose();
  2068.         return $this->adminJson(['success' => $success]);
  2069.     }
  2071.     /**
  2072.      * @Route("/download-as-zip-jobs", name="pimcore_admin_asset_downloadaszipjobs", methods={"GET"})
  2073.      *
  2074.      * @param Request $request
  2075.      *
  2076.      * @return JsonResponse
  2077.      */
  2078.     public function downloadAsZipJobsAction(Request $request)
  2079.     {
  2080.         $jobId = uniqid();
  2081.         $filesPerJob = 5;
  2082.         $jobs = [];
  2083.         $asset = Asset::getById((int) $request->get('id'));
  2085.         if (!$asset) {
  2086.             throw $this->createNotFoundException('Asset not found');
  2087.         }
  2089.         if ($asset->isAllowed('view')) {
  2090.             $parentPath = $asset->getRealFullPath();
  2091.             if ($asset->getId() == 1) {
  2092.                 $parentPath = '';
  2093.             }
  2095.             $db = \Pimcore\Db::get();
  2096.             $conditionFilters = [];
  2097.             $selectedIds = explode(',', $request->get('selectedIds', ''));
  2098.             $quotedSelectedIds = [];
  2099.             foreach ($selectedIds as $selectedId) {
  2100.                 if ($selectedId) {
  2101.                     $quotedSelectedIds[] = $db->quote($selectedId);
  2102.                 }
  2103.             }
  2104.             if (!empty($quotedSelectedIds)) {
  2105.                 //add a condition if id numbers are specified
  2106.                 $conditionFilters[] = 'id IN (' . implode(',', $quotedSelectedIds) . ')';
  2107.             }
  2108.             $conditionFilters[] = 'path LIKE ' . $db->quote(Helper::escapeLike($parentPath) . '/%') . ' AND type != ' . $db->quote('folder');
  2109.             if (!$this->getAdminUser()->isAdmin()) {
  2110.                 $userIds = $this->getAdminUser()->getRoles();
  2111.                 $userIds[] = $this->getAdminUser()->getId();
  2112.                 $conditionFilters[] = ' (
  2113.                     (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(CONCAT(path, filename),cpath)=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  2114.                     OR
  2115.                     (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(cpath,CONCAT(path, filename))=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  2116.                 )';
  2117.             }
  2119.             $condition = implode(' AND ', $conditionFilters);
  2121.             $assetList = new Asset\Listing();
  2122.             $assetList->setCondition($condition);
  2123.             $assetList->setOrderKey('LENGTH(path)', false);
  2124.             $assetList->setOrder('ASC');
  2126.             for ($i = 0; $i < ceil($assetList->getTotalCount() / $filesPerJob); $i++) {
  2127.                 $jobs[] = [[
  2128.                     'url' => $this->generateUrl('pimcore_admin_asset_downloadaszipaddfiles'),
  2129.                     'method' => 'GET',
  2130.                     'params' => [
  2131.                         'id' => $asset->getId(),
  2132.                         'selectedIds' => implode(',', $selectedIds),
  2133.                         'offset' => $i * $filesPerJob,
  2134.                         'limit' => $filesPerJob,
  2135.                         'jobId' => $jobId,
  2136.                     ],
  2137.                 ]];
  2138.             }
  2139.         }
  2141.         return $this->adminJson([
  2142.             'success' => true,
  2143.             'jobs' => $jobs,
  2144.             'jobId' => $jobId,
  2145.         ]);
  2146.     }
  2148.     /**
  2149.      * @Route("/download-as-zip-add-files", name="pimcore_admin_asset_downloadaszipaddfiles", methods={"GET"})
  2150.      *
  2151.      * @param Request $request
  2152.      *
  2153.      * @return JsonResponse
  2154.      */
  2155.     public function downloadAsZipAddFilesAction(Request $request)
  2156.     {
  2157.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  2158.         $asset = Asset::getById((int) $request->get('id'));
  2159.         $success = false;
  2161.         if (!$asset) {
  2162.             throw $this->createNotFoundException('Asset not found');
  2163.         }
  2165.         if ($asset->isAllowed('view')) {
  2166.             $zip = new \ZipArchive();
  2167.             if (!is_file($zipFile)) {
  2168.                 $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  2169.             } else {
  2170.                 $zipState = $zip->open($zipFile);
  2171.             }
  2173.             if ($zipState === true) {
  2174.                 $parentPath = $asset->getRealFullPath();
  2175.                 if ($asset->getId() == 1) {
  2176.                     $parentPath = '';
  2177.                 }
  2179.                 $db = \Pimcore\Db::get();
  2180.                 $conditionFilters = [];
  2181.                 $selectedIds = $request->get('selectedIds', []);
  2183.                 if (!empty($selectedIds)) {
  2184.                     $selectedIds = explode(',', $selectedIds);
  2186.                     $quotedSelectedIds = [];
  2187.                     foreach ($selectedIds as $selectedId) {
  2188.                         if ($selectedId) {
  2189.                             $quotedSelectedIds[] = $db->quote($selectedId);
  2190.                         }
  2191.                     }
  2193.                     //add a condition if id numbers are specified
  2194.                     $conditionFilters[] = 'id IN (' . implode(',', $quotedSelectedIds) . ')';
  2195.                 }
  2196.                 $conditionFilters[] = "type != 'folder' AND path LIKE " . $db->quote(Helper::escapeLike($parentPath) . '/%');
  2197.                 if (!$this->getAdminUser()->isAdmin()) {
  2198.                     $userIds = $this->getAdminUser()->getRoles();
  2199.                     $userIds[] = $this->getAdminUser()->getId();
  2200.                     $conditionFilters[] = ' (
  2201.                         (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(CONCAT(path, filename),cpath)=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  2202.                         OR
  2203.                         (select list from users_workspaces_asset where userId in (' . implode(',', $userIds) . ') and LOCATE(cpath,CONCAT(path, filename))=1  ORDER BY LENGTH(cpath) DESC LIMIT 1)=1
  2204.                     )';
  2205.                 }
  2207.                 $condition = implode(' AND ', $conditionFilters);
  2209.                 $assetList = new Asset\Listing();
  2210.                 $assetList->setCondition($condition);
  2211.                 $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  2212.                 $assetList->setOffset((int)$request->get('offset'));
  2213.                 $assetList->setLimit((int)$request->get('limit'));
  2215.                 foreach ($assetList as $a) {
  2216.                     if ($a->isAllowed('view')) {
  2217.                         if (!$a instanceof Asset\Folder) {
  2218.                             // add the file with the relative path to the parent directory
  2219.                             $zip->addFile($a->getLocalFile(), preg_replace('@^' . preg_quote($asset->getRealPath(), '@') . '@i', '', $a->getRealFullPath()));
  2220.                         }
  2221.                     }
  2222.                 }
  2224.                 $zip->close();
  2225.                 $success = true;
  2226.             }
  2227.         }
  2229.         return $this->adminJson([
  2230.             'success' => $success,
  2231.         ]);
  2232.     }
  2234.     /**
  2235.      * @Route("/download-as-zip", name="pimcore_admin_asset_downloadaszip", methods={"GET"})
  2236.      *
  2237.      * @param Request $request
  2238.      *
  2239.      * @return BinaryFileResponse
  2240.      * Download all assets contained in the folder with parameter id as ZIP file.
  2241.      * The suggested filename is either [folder name].zip or assets.zip for the root folder.
  2242.      */
  2243.     public function downloadAsZipAction(Request $request)
  2244.     {
  2245.         $asset = Asset::getById((int) $request->get('id'));
  2246.         if (!$asset) {
  2247.             throw $this->createNotFoundException('Asset not found');
  2248.         }
  2249.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  2250.         $suggestedFilename = $asset->getFilename();
  2251.         if (empty($suggestedFilename)) {
  2252.             $suggestedFilename = 'assets';
  2253.         }
  2255.         $response = new BinaryFileResponse($zipFile);
  2256.         $response->headers->set('Content-Type', 'application/zip');
  2257.         $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $suggestedFilename . '.zip');
  2258.         $response->deleteFileAfterSend(true);
  2260.         return $response;
  2261.     }
  2263.     /**
  2264.      * @Route("/import-zip", name="pimcore_admin_asset_importzip", methods={"POST"})
  2265.      *
  2266.      * @param Request $request
  2267.      * @param TranslatorInterface $translator
  2268.      *
  2269.      * @return Response
  2270.      */
  2271.     public function importZipAction(Request $request, TranslatorInterface $translator)
  2272.     {
  2273.         $jobId = uniqid();
  2274.         $filesPerJob = 5;
  2275.         $jobs = [];
  2276.         $asset = Asset::getById((int) $request->get('parentId'));
  2278.         if (!is_file($_FILES['Filedata']['tmp_name'])) {
  2279.             return $this->adminJson([
  2280.                 'success' => false,
  2281.                 'message' => 'Something went wrong, please check upload_max_filesize and post_max_size in your php.ini as well as the write permissions on the file system',
  2282.             ]);
  2283.         }
  2285.         if (!$asset) {
  2286.             throw $this->createNotFoundException('Parent asset not found');
  2287.         }
  2289.         if (!$asset->isAllowed('create')) {
  2290.             throw $this->createAccessDeniedException('not allowed to create');
  2291.         }
  2293.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  2295.         copy($_FILES['Filedata']['tmp_name'], $zipFile);
  2297.         $zip = new \ZipArchive;
  2298.         $retCode = $zip->open($zipFile);
  2299.         if ($retCode === true) {
  2300.             $jobAmount = ceil($zip->numFiles / $filesPerJob);
  2301.             for ($i = 0; $i < $jobAmount; $i++) {
  2302.                 $jobs[] = [[
  2303.                     'url' => $this->generateUrl('pimcore_admin_asset_importzipfiles'),
  2304.                     'method' => 'POST',
  2305.                     'params' => [
  2306.                         'parentId' => $asset->getId(),
  2307.                         'offset' => $i * $filesPerJob,
  2308.                         'limit' => $filesPerJob,
  2309.                         'jobId' => $jobId,
  2310.                         'last' => (($i + 1) >= $jobAmount) ? 'true' : '',
  2311.                     ],
  2312.                 ]];
  2313.             }
  2314.             $zip->close();
  2316.             // here we have to use this method and not the JSON action helper ($this->_helper->json()) because this will add
  2317.             // Content-Type: application/json which fires a download window in most browsers, because this is a normal POST
  2318.             // request and not XHR where the content-type doesn't matter
  2319.             $responseJson = $this->encodeJson([
  2320.                 'success' => true,
  2321.                 'jobs' => $jobs,
  2322.                 'jobId' => $jobId,
  2323.             ]);
  2325.             return new Response($responseJson);
  2326.         } else {
  2327.             return $this->adminJson([
  2328.                 'success' => false,
  2329.                 'message' => $translator->trans('could_not_open_zip_file', [], 'admin'),
  2330.             ]);
  2331.         }
  2332.     }
  2334.     /**
  2335.      * @Route("/import-zip-files", name="pimcore_admin_asset_importzipfiles", methods={"POST"})
  2336.      *
  2337.      * @param Request $request
  2338.      *
  2339.      * @return JsonResponse
  2340.      */
  2341.     public function importZipFilesAction(Request $request)
  2342.     {
  2343.         $jobId = $request->get('jobId');
  2344.         $limit = (int)$request->get('limit');
  2345.         $offset = (int)$request->get('offset');
  2346.         $importAsset = Asset::getById((int) $request->get('parentId'));
  2347.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  2348.         $tmpDir = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/zip-import';
  2350.         if (!is_dir($tmpDir)) {
  2351.             File::mkdir($tmpDir, 0777, true);
  2352.         }
  2354.         $zip = new \ZipArchive;
  2355.         if ($zip->open($zipFile) === true) {
  2356.             for ($i = $offset; $i < ($offset + $limit); $i++) {
  2357.                 $path = $zip->getNameIndex($i);
  2359.                 if (str_starts_with($path, '__MACOSX/') || str_ends_with($path, '/Thumbs.db')) {
  2360.                     continue;
  2361.                 }
  2363.                 if ($path !== false) {
  2364.                     if ($zip->extractTo($tmpDir . '/', $path)) {
  2365.                         $tmpFile = $tmpDir . '/' . preg_replace('@^/@', '', $path);
  2367.                         $filename = Element\Service::getValidKey(basename($path), 'asset');
  2369.                         $relativePath = '';
  2370.                         if (dirname($path) != '.') {
  2371.                             $relativePath = dirname($path);
  2372.                         }
  2374.                         $parentPath = $importAsset->getRealFullPath() . '/' . preg_replace('@^/@', '', $relativePath);
  2375.                         $parent = Asset\Service::createFolderByPath($parentPath);
  2377.                         // check for duplicate filename
  2378.                         $filename = $this->getSafeFilename($parent->getRealFullPath(), $filename);
  2380.                         if ($parent->isAllowed('create')) {
  2381.                             $asset = Asset::create($parent->getId(), [
  2382.                                 'filename' => $filename,
  2383.                                 'sourcePath' => $tmpFile,
  2384.                                 'userOwner' => $this->getAdminUser()->getId(),
  2385.                                 'userModification' => $this->getAdminUser()->getId(),
  2386.                             ]);
  2388.                             @unlink($tmpFile);
  2389.                         } else {
  2390.                             Logger::debug('prevented creating asset because of missing permissions');
  2391.                         }
  2392.                     }
  2393.                 }
  2394.             }
  2395.             $zip->close();
  2396.         }
  2398.         if ($request->get('last')) {
  2399.             unlink($zipFile);
  2400.         }
  2402.         return $this->adminJson([
  2403.             'success' => true,
  2404.         ]);
  2405.     }
  2407.     /**
  2408.      * @Route("/import-server", name="pimcore_admin_asset_importserver", methods={"POST"})
  2409.      *
  2410.      * @param Request $request
  2411.      *
  2412.      * @return JsonResponse
  2413.      */
  2414.     public function importServerAction(Request $request)
  2415.     {
  2416.         $success = true;
  2417.         $filesPerJob = 5;
  2418.         $jobs = [];
  2419.         $importDirectory = str_replace('/fileexplorer', PIMCORE_PROJECT_ROOT, $request->get('serverPath'));
  2420.         if (preg_match('@^' . preg_quote(PIMCORE_PROJECT_ROOT, '@') . '@', $importDirectory) && is_dir($importDirectory)) {
  2421.             $this->checkForPharStreamWrapper($importDirectory);
  2422.             $files = rscandir($importDirectory . '/');
  2423.             $count = count($files);
  2424.             $jobFiles = [];
  2426.             for ($i = 0; $i < $count; $i++) {
  2427.                 if (is_dir($files[$i])) {
  2428.                     continue;
  2429.                 }
  2431.                 $jobFiles[] = preg_replace('@^' . preg_quote($importDirectory, '@') . '@', '', $files[$i]);
  2433.                 if (count($jobFiles) >= $filesPerJob || $i >= ($count - 1)) {
  2434.                     $relativeImportDirectory = preg_replace('@^' . preg_quote(PIMCORE_PROJECT_ROOT, '@') . '@', '', $importDirectory);
  2435.                     $jobs[] = [[
  2436.                         'url' => $this->generateUrl('pimcore_admin_asset_importserverfiles'),
  2437.                         'method' => 'POST',
  2438.                         'params' => [
  2439.                             'parentId' => $request->get('parentId'),
  2440.                             'serverPath' => $relativeImportDirectory,
  2441.                             'files' => implode('::', $jobFiles),
  2442.                         ],
  2443.                     ]];
  2444.                     $jobFiles = [];
  2445.                 }
  2446.             }
  2447.         }
  2449.         return $this->adminJson([
  2450.             'success' => $success,
  2451.             'jobs' => $jobs,
  2452.         ]);
  2453.     }
  2455.     /**
  2456.      * @Route("/import-server-files", name="pimcore_admin_asset_importserverfiles", methods={"POST"})
  2457.      *
  2458.      * @param Request $request
  2459.      *
  2460.      * @return JsonResponse
  2461.      */
  2462.     public function importServerFilesAction(Request $request)
  2463.     {
  2464.         if(!Tool\Admin::getCurrentUser()->isAdmin()) {
  2465.             throw $this->createAccessDeniedException('Permission denied. You don\'t have the rights to import files from the server!');
  2466.         }
  2468.         $assetFolder = Asset::getById((int) $request->get('parentId'));
  2469.         if (!$assetFolder) {
  2470.             throw $this->createNotFoundException('Parent asset not found');
  2471.         }
  2473.         $serverPath = realpath(PIMCORE_PROJECT_ROOT . $request->get('serverPath'));
  2474.         if(!str_starts_with($serverPath, rtrim(str_replace('../', '', PIMCORE_PROJECT_ROOT), './'))) {
  2475.             throw $this->createAccessDeniedException('Please do not navigate out of the web root directory!');
  2476.         }
  2478.         $files = explode('::', $request->get('files'));
  2480.         // prevent directory traversal
  2481.         foreach ($files as $file) {
  2482.             $absolutePath = realpath($serverPath.$file);
  2483.             if (!str_starts_with($absolutePath, $serverPath)) {
  2484.                 throw $this->createAccessDeniedException('Please do not navigate out of the web root directory!');
  2485.             }
  2486.         }
  2488.         foreach ($files as $file) {
  2489.             $absolutePath = $serverPath . $file;
  2490.             $this->checkForPharStreamWrapper($absolutePath);
  2491.             if (is_file($absolutePath)) {
  2492.                 $relFolderPath = str_replace('\\', '/', dirname($file));
  2493.                 $folder = Asset\Service::createFolderByPath($assetFolder->getRealFullPath() . $relFolderPath);
  2494.                 $filename = basename($file);
  2496.                 // check for duplicate filename
  2497.                 $filename = Element\Service::getValidKey($filename, 'asset');
  2498.                 $filename = $this->getSafeFilename($folder->getRealFullPath(), $filename);
  2500.                 if ($assetFolder->isAllowed('create')) {
  2501.                     $asset = Asset::create($folder->getId(), [
  2502.                         'filename' => $filename,
  2503.                         'sourcePath' => $absolutePath,
  2504.                         'userOwner' => $this->getAdminUser()->getId(),
  2505.                         'userModification' => $this->getAdminUser()->getId(),
  2506.                     ]);
  2507.                 } else {
  2508.                     Logger::debug('prevented creating asset because of missing permissions ');
  2509.                 }
  2510.             }
  2511.         }
  2513.         return $this->adminJson([
  2514.             'success' => true,
  2515.         ]);
  2516.     }
  2518.     protected function checkForPharStreamWrapper($path)
  2519.     {
  2520.         if (stripos($path, 'phar://') !== false) {
  2521.             throw $this->createAccessDeniedException('Using PHAR files is not allowed!');
  2522.         }
  2523.     }
  2525.     /**
  2526.      * @Route("/import-url", name="pimcore_admin_asset_importurl", methods={"POST"})
  2527.      *
  2528.      * @param Request $request
  2529.      *
  2530.      * @return JsonResponse
  2531.      *
  2532.      * @throws \Exception
  2533.      */
  2534.     public function importUrlAction(Request $request)
  2535.     {
  2536.         $success = true;
  2538.         $data = Tool::getHttpData($request->get('url'));
  2539.         $filename = basename($request->get('url'));
  2540.         $parentId = $request->get('id');
  2541.         $parentAsset = Asset::getById((int)$parentId);
  2543.         if (!$parentAsset) {
  2544.             throw $this->createNotFoundException('Parent asset not found');
  2545.         }
  2547.         $filename = Element\Service::getValidKey($filename, 'asset');
  2548.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2550.         if (empty($filename)) {
  2551.             throw new \Exception('The filename of the asset is empty');
  2552.         }
  2554.         // check for duplicate filename
  2555.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2557.         if ($parentAsset->isAllowed('create')) {
  2558.             $asset = Asset::create($parentId, [
  2559.                 'filename' => $filename,
  2560.                 'data' => $data,
  2561.                 'userOwner' => $this->getAdminUser()->getId(),
  2562.                 'userModification' => $this->getAdminUser()->getId(),
  2563.             ]);
  2564.             $success = true;
  2565.         } else {
  2566.             Logger::debug('prevented creating asset because of missing permissions');
  2567.         }
  2569.         return $this->adminJson(['success' => $success]);
  2570.     }
  2572.     /**
  2573.      * @Route("/clear-thumbnail", name="pimcore_admin_asset_clearthumbnail", methods={"POST"})
  2574.      *
  2575.      * @param Request $request
  2576.      *
  2577.      * @return JsonResponse
  2578.      */
  2579.     public function clearThumbnailAction(Request $request)
  2580.     {
  2581.         $success = false;
  2583.         if ($asset = Asset::getById((int) $request->get('id'))) {
  2584.             if (method_exists($asset, 'clearThumbnails')) {
  2585.                 if (!$asset->isAllowed('publish')) {
  2586.                     throw $this->createAccessDeniedException('not allowed to publish');
  2587.                 }
  2589.                 $asset->clearThumbnails(true); // force clear
  2590.                 $asset->save();
  2592.                 $success = true;
  2593.             }
  2594.         }
  2596.         return $this->adminJson(['success' => $success]);
  2597.     }
  2599.     /**
  2600.      * @Route("/grid-proxy", name="pimcore_admin_asset_gridproxy", methods={"GET", "POST", "PUT"})
  2601.      *
  2602.      * @param Request $request
  2603.      * @param EventDispatcherInterface $eventDispatcher
  2604.      * @param GridHelperService $gridHelperService
  2605.      * @param CsrfProtectionHandler $csrfProtection
  2606.      *
  2607.      * @return JsonResponse
  2608.      */
  2609.     public function gridProxyAction(Request $request, EventDispatcherInterface $eventDispatcher, GridHelperService $gridHelperService, CsrfProtectionHandler $csrfProtection)
  2610.     {
  2611.         $allParams = array_merge($request->request->all(), $request->query->all());
  2613.         $filterPrepareEvent = new GenericEvent($this, [
  2614.             'requestParams' => $allParams,
  2615.         ]);
  2616.         $language = $request->get('language') != 'default' ? $request->get('language') : null;
  2618.         $eventDispatcher->dispatch($filterPrepareEvent, AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE);
  2620.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  2622.         $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  2624.         if (isset($allParams['data']) && $allParams['data']) {
  2625.             $csrfProtection->checkCsrfToken($request);
  2626.             if ($allParams['xaction'] == 'update') {
  2627.                 try {
  2628.                     $data = $this->decodeJson($allParams['data']);
  2630.                     $updateEvent = new GenericEvent($this, [
  2631.                         'data' => $data,
  2632.                         'processed' => false,
  2633.                     ]);
  2635.                     $eventDispatcher->dispatch($updateEvent, AdminEvents::ASSET_LIST_BEFORE_UPDATE);
  2637.                     $processed = $updateEvent->getArgument('processed');
  2639.                     if ($processed) {
  2640.                         // update already processed by event handler
  2641.                         return $this->adminJson(['success' => true]);
  2642.                     }
  2644.                     $data = $updateEvent->getArgument('data');
  2646.                     // save
  2647.                     $asset = Asset::getById($data['id']);
  2649.                     if (!$asset) {
  2650.                         throw $this->createNotFoundException('Asset not found');
  2651.                     }
  2653.                     if (!$asset->isAllowed('publish')) {
  2654.                         throw $this->createAccessDeniedException("Permission denied. You don't have the rights to save this asset.");
  2655.                     }
  2657.                     $metadata = $asset->getMetadata(null, null, false, true);
  2658.                     $dirty = false;
  2660.                     unset($data['id']);
  2661.                     foreach ($data as $key => $value) {
  2662.                         $fieldDef = explode('~', $key);
  2663.                         $key = $fieldDef[0];
  2664.                         if (isset($fieldDef[1])) {
  2665.                             $language = ($fieldDef[1] == 'none' ? '' : $fieldDef[1]);
  2666.                         }
  2668.                         foreach ($metadata as $idx => &$em) {
  2669.                             if ($em['name'] == $key && $em['language'] == $language) {
  2670.                                 try {
  2671.                                     $dataImpl = $loader->build($em['type']);
  2672.                                     $value = $dataImpl->getDataFromListfolderGrid($value, $em);
  2673.                                 } catch (UnsupportedException $le) {
  2674.                                     Logger::error('could not resolve metadata implementation for ' . $em['type']);
  2675.                                 }
  2677.                                 $em['data'] = $value;
  2678.                                 $dirty = true;
  2680.                                 break;
  2681.                             }
  2682.                         }
  2684.                         if (!$dirty) {
  2685.                             $defaulMetadata = ['title', 'alt', 'copyright'];
  2686.                             if (in_array($key, $defaulMetadata)) {
  2687.                                 $newEm = [
  2688.                                     'name' => $key,
  2689.                                     'language' => $language,
  2690.                                     'type' => 'input',
  2691.                                     'data' => $value,
  2692.                                 ];
  2694.                                 try {
  2695.                                     $dataImpl = $loader->build($newEm['type']);
  2696.                                     $newEm['data'] = $dataImpl->getDataFromListfolderGrid($value, $newEm);
  2697.                                 } catch (UnsupportedException $le) {
  2698.                                     Logger::error('could not resolve metadata implementation for ' . $newEm['type']);
  2699.                                 }
  2701.                                 $metadata[] = $newEm;
  2703.                                 $dirty = true;
  2704.                             } else {
  2705.                                 $predefined = Model\Metadata\Predefined::getByName($key);
  2706.                                 if ($predefined && (empty($predefined->getTargetSubtype())
  2707.                                         || $predefined->getTargetSubtype() == $asset->getType())) {
  2708.                                     $newEm = [
  2709.                                         'name' => $key,
  2710.                                         'language' => $language,
  2711.                                         'type' => $predefined->getType(),
  2712.                                         'data' => $value,
  2713.                                     ];
  2715.                                     try {
  2716.                                         $dataImpl = $loader->build($newEm['type']);
  2717.                                         $newEm['data'] = $dataImpl->getDataFromListfolderGrid($value, $newEm);
  2718.                                     } catch (UnsupportedException $le) {
  2719.                                         Logger::error('could not resolve metadata implementation for ' . $newEm['type']);
  2720.                                     }
  2722.                                     $metadata[] = $newEm;
  2723.                                     $dirty = true;
  2724.                                 }
  2725.                             }
  2726.                         }
  2727.                     }
  2729.                     if ($dirty) {
  2730.                         // $metadata = Asset\Service::minimizeMetadata($metadata, "grid");
  2731.                         $asset->setMetadataRaw($metadata);
  2732.                         $asset->save();
  2734.                         return $this->adminJson(['success' => true]);
  2735.                     }
  2737.                     return $this->adminJson(['success' => false, 'message' => 'something went wrong.']);
  2738.                 } catch (\Exception $e) {
  2739.                     return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  2740.                 }
  2741.             }
  2742.         } else {
  2743.             $list = $gridHelperService->prepareAssetListingForGrid($allParams, $this->getAdminUser());
  2745.             $beforeListLoadEvent = new GenericEvent($this, [
  2746.                 'list' => $list,
  2747.                 'context' => $allParams,
  2748.             ]);
  2749.             $eventDispatcher->dispatch($beforeListLoadEvent, AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD);
  2750.             /** @var Asset\Listing $list */
  2751.             $list = $beforeListLoadEvent->getArgument('list');
  2753.             $list->load();
  2755.             $assets = [];
  2756.             foreach ($list->getAssets() as $index => $asset) {
  2757.                 // Like for treeGetChildsByIdAction, so we respect isAllowed method which can be extended (object DI) for custom permissions, so relying only users_workspaces_asset is insufficient and could lead security breach
  2758.                 if ($asset->isAllowed('list')) {
  2759.                     $a = Asset\Service::gridAssetData($asset, $allParams['fields'], $allParams['language'] ?? '');
  2760.                     $assets[] = $a;
  2761.                 }
  2762.             }
  2764.             $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  2766.             $afterListLoadEvent = new GenericEvent($this, [
  2767.                 'list' => $result,
  2768.                 'context' => $allParams,
  2769.             ]);
  2770.             $eventDispatcher->dispatch($afterListLoadEvent, AdminEvents::ASSET_LIST_AFTER_LIST_LOAD);
  2771.             $result = $afterListLoadEvent->getArgument('list');
  2773.             return $this->adminJson($result);
  2774.         }
  2776.         return $this->adminJson(['success' => false]);
  2777.     }
  2779.     /**
  2780.      * @Route("/get-text", name="pimcore_admin_asset_gettext", methods={"GET"})
  2781.      *
  2782.      * @param Request $request
  2783.      *
  2784.      * @return JsonResponse
  2785.      */
  2786.     public function getTextAction(Request $request)
  2787.     {
  2788.         $asset = Asset::getById((int) $request->get('id'));
  2790.         if (!$asset) {
  2791.             throw $this->createNotFoundException('Asset not found');
  2792.         }
  2794.         if (!$asset->isAllowed('view')) {
  2795.             throw $this->createAccessDeniedException('not allowed to view');
  2796.         }
  2798.         $page = $request->get('page');
  2799.         $text = null;
  2800.         if ($asset instanceof Asset\Document) {
  2801.             $text = $asset->getText($page);
  2802.         }
  2804.         return $this->adminJson(['success' => 'true', 'text' => $text]);
  2805.     }
  2807.     /**
  2808.      * @Route("/detect-image-features", name="pimcore_admin_asset_detectimagefeatures", methods={"GET"})
  2809.      *
  2810.      * @param Request $request
  2811.      *
  2812.      * @return JsonResponse
  2813.      */
  2814.     public function detectImageFeaturesAction(Request $request)
  2815.     {
  2816.         $asset = Asset\Image::getById((int)$request->get('id'));
  2817.         if (!$asset instanceof Asset) {
  2818.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  2819.         }
  2821.         if ($asset->isAllowed('publish')) {
  2822.             $asset->detectFaces();
  2823.             $asset->removeCustomSetting('disableImageFeatureAutoDetection');
  2824.             $asset->save();
  2826.             return $this->adminJson(['success' => true]);
  2827.         }
  2829.         throw $this->createAccessDeniedHttpException();
  2830.     }
  2832.     /**
  2833.      * @Route("/delete-image-features", name="pimcore_admin_asset_deleteimagefeatures", methods={"GET"})
  2834.      *
  2835.      * @param Request $request
  2836.      *
  2837.      * @return JsonResponse
  2838.      */
  2839.     public function deleteImageFeaturesAction(Request $request)
  2840.     {
  2841.         $asset = Asset::getById((int)$request->get('id'));
  2842.         if (!$asset instanceof Asset) {
  2843.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  2844.         }
  2846.         if ($asset->isAllowed('publish')) {
  2847.             $asset->removeCustomSetting('faceCoordinates');
  2848.             $asset->setCustomSetting('disableImageFeatureAutoDetection', true);
  2849.             $asset->save();
  2851.             return $this->adminJson(['success' => true]);
  2852.         }
  2854.         throw $this->createAccessDeniedHttpException();
  2855.     }
  2857.     /**
  2858.      * @param ControllerEvent $event
  2859.      */
  2860.     public function onKernelControllerEvent(ControllerEvent $event)
  2861.     {
  2862.         if (!$event->isMainRequest()) {
  2863.             return;
  2864.         }
  2866.         $this->checkActionPermission($event, 'assets', [
  2867.             'getImageThumbnailAction', 'getVideoThumbnailAction', 'getDocumentThumbnailAction',
  2868.         ]);
  2870.         $this->_assetService = new Asset\Service($this->getAdminUser());
  2871.     }
  2873.     /**
  2874.      * @throws ValidationException
  2875.      */
  2876.     private function validateManyToManyRelationAssetType(array $context, string $filename, string $sourcePath): void
  2877.     {
  2878.         if (isset($context['containerType'], $context['objectId'], $context['fieldname'])
  2879.             && 'object' === $context['containerType']
  2880.             && $object = Concrete::getById($context['objectId'])
  2881.         ) {
  2882.             $fieldDefinition = $object->getClass()?->getFieldDefinition($context['fieldname']);
  2883.             if (!$fieldDefinition instanceof ManyToManyRelation) {
  2884.                 return;
  2885.             }
  2887.             $mimeType = MimeTypes::getDefault()->guessMimeType($sourcePath);
  2888.             $type = Asset::getTypeFromMimeMapping($mimeType, $filename);
  2890.             $allowedAssetTypes = $fieldDefinition->getAssetTypes();
  2891.             $allowedAssetTypes = array_column($allowedAssetTypes, 'assetTypes');
  2893.             if (
  2894.                 !(
  2895.                     $fieldDefinition->getAssetsAllowed()
  2896.                     && ($allowedAssetTypes === [] || in_array($type, $allowedAssetTypes, true))
  2897.                 )
  2898.             ) {
  2899.                 throw new ValidationException(sprintf('Invalid relation in field `%s` [type: %s]', $context['fieldname'], $type));
  2900.             }
  2901.         }
  2902.     }
  2903. }