vendor/pimcore/pimcore/bundles/AdminBundle/Controller/Admin/AssetController.php line 1274

Open in your IDE?
  1. <?php
  2. /**
  3.  * Pimcore
  4.  *
  5.  * This source file is available under two different licenses:
  6.  * - GNU General Public License version 3 (GPLv3)
  7.  * - Pimcore Enterprise License (PEL)
  8.  * Full copyright and license information is available in
  9.  * LICENSE.md which is distributed with this source code.
  10.  *
  11.  * @copyright  Copyright (c) Pimcore GmbH (http://www.pimcore.org)
  12.  * @license    http://www.pimcore.org/license     GPLv3 and PEL
  13.  */
  15. namespace Pimcore\Bundle\AdminBundle\Controller\Admin;
  17. use Pimcore\Bundle\AdminBundle\Controller\Traits\AdminStyleTrait;
  18. use Pimcore\Bundle\AdminBundle\Controller\Traits\ApplySchedulerDataTrait;
  19. use Pimcore\Bundle\AdminBundle\Helper\GridHelperService;
  20. use Pimcore\Config;
  21. use Pimcore\Controller\Configuration\TemplatePhp;
  22. use Pimcore\Controller\EventedControllerInterface;
  23. use Pimcore\Controller\Traits\ElementEditLockHelperTrait;
  24. use Pimcore\Db;
  25. use Pimcore\Event\Admin\ElementAdminStyleEvent;
  26. use Pimcore\Event\AdminEvents;
  27. use Pimcore\Event\AssetEvents;
  28. use Pimcore\File;
  29. use Pimcore\Loader\ImplementationLoader\Exception\UnsupportedException;
  30. use Pimcore\Logger;
  31. use Pimcore\Model;
  32. use Pimcore\Model\Asset;
  33. use Pimcore\Model\Element;
  34. use Pimcore\Tool;
  35. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  36. use Symfony\Component\EventDispatcher\GenericEvent;
  37. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  38. use Symfony\Component\HttpFoundation\JsonResponse;
  39. use Symfony\Component\HttpFoundation\Request;
  40. use Symfony\Component\HttpFoundation\Response;
  41. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  42. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  43. use Symfony\Component\HttpKernel\Event\FilterControllerEvent;
  44. use Symfony\Component\HttpKernel\Event\FilterResponseEvent;
  45. use Symfony\Component\Routing\Annotation\Route;
  47. /**
  48.  * @Route("/asset")
  49.  */
  50. class AssetController extends ElementControllerBase implements EventedControllerInterface
  51. {
  52.     use AdminStyleTrait;
  53.     use ElementEditLockHelperTrait;
  54.     use ApplySchedulerDataTrait;
  56.     /**
  57.      * @var Asset\Service
  58.      */
  59.     protected $_assetService;
  61.     /**
  62.      * @Route("/tree-get-root", name="pimcore_admin_asset_treegetroot", methods={"GET"})
  63.      *
  64.      * @param Request $request
  65.      *
  66.      * @return JsonResponse
  67.      */
  68.     public function treeGetRootAction(Request $request)
  69.     {
  70.         return parent::treeGetRootAction($request);
  71.     }
  73.     /**
  74.      * @Route("/delete-info", name="pimcore_admin_asset_deleteinfo", methods={"GET"})
  75.      *
  76.      * @param Request $request
  77.      *
  78.      * @return JsonResponse
  79.      */
  80.     public function deleteInfoAction(Request $request)
  81.     {
  82.         return parent::deleteInfoAction($request);
  83.     }
  85.     /**
  86.      * @Route("/get-data-by-id", name="pimcore_admin_asset_getdatabyid", methods={"GET"})
  87.      *
  88.      * @param Request $request
  89.      *
  90.      * @return JsonResponse
  91.      */
  92.     public function getDataByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  93.     {
  94.         $asset = Asset::getById((int)$request->get('id'));
  95.         if (!$asset instanceof Asset) {
  96.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  97.         }
  99.         // check for lock
  100.         if ($asset->isAllowed('publish') || $asset->isAllowed('delete')) {
  101.             if (Element\Editlock::isLocked($request->get('id'), 'asset')) {
  102.                 return $this->getEditLockResponse($request->get('id'), 'asset');
  103.             }
  105.             Element\Editlock::lock($request->get('id'), 'asset');
  106.         }
  108.         $asset = clone $asset;
  109.         $asset->getScheduledTasks();
  110.         $asset->setLocked($asset->isLocked());
  111.         $asset->setParent(null);
  113.         $asset->setStream(null);
  114.         $data = $asset->getObjectVars();
  116.         if ($asset instanceof Asset\Text) {
  117.             if ($asset->getFileSize() < 2000000) {
  118.                 // it doesn't make sense to show a preview for files bigger than 2MB
  119.                 $data['data'] = \ForceUTF8\Encoding::toUTF8($asset->getData());
  120.             } else {
  121.                 $data['data'] = false;
  122.             }
  123.         } elseif ($asset instanceof Asset\Document) {
  124.             $data['pdfPreviewAvailable'] = (bool) $this->getDocumentPreviewPdf($asset);
  125.         } elseif ($asset instanceof Asset\Video) {
  126.             $videoInfo = [];
  128.             if (\Pimcore\Video::isAvailable()) {
  129.                 $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  130.                 $thumbnail = $asset->getThumbnail($config, ['mp4']);
  131.                 if ($thumbnail) {
  132.                     if ($thumbnail['status'] == 'finished') {
  133.                         $videoInfo['previewUrl'] = $thumbnail['formats']['mp4'];
  134.                         $videoInfo['width'] = $asset->getWidth();
  135.                         $videoInfo['height'] = $asset->getHeight();
  137.                         $metaData = $asset->getSphericalMetaData();
  138.                         if (isset($metaData['ProjectionType']) && strtolower($metaData['ProjectionType']) == 'equirectangular') {
  139.                             $videoInfo['isVrVideo'] = true;
  140.                         }
  141.                     }
  142.                 }
  143.             }
  145.             $data['videoInfo'] = $videoInfo;
  146.         } elseif ($asset instanceof Asset\Image) {
  147.             $imageInfo = [];
  149.             $previewUrl = $this->generateUrl('pimcore_admin_asset_getimagethumbnail', [
  150.                 'id' => $asset->getId(),
  151.                 'treepreview' => true,
  152.                 'hdpi' => true,
  153.                 '_dc' => time(),
  154.             ]);
  156.             if ($asset->isAnimated()) {
  157.                 $previewUrl = $this->generateUrl('pimcore_admin_asset_getasset', [
  158.                     'id' => $asset->getId(),
  159.                     '_dc' => time(),
  160.                 ]);
  161.             }
  163.             $imageInfo['previewUrl'] = $previewUrl;
  165.             if ($asset->getWidth() && $asset->getHeight()) {
  166.                 $imageInfo['dimensions'] = [];
  167.                 $imageInfo['dimensions']['width'] = $asset->getWidth();
  168.                 $imageInfo['dimensions']['height'] = $asset->getHeight();
  169.             }
  171.             $imageInfo['exiftoolAvailable'] = (bool) \Pimcore\Tool\Console::getExecutable('exiftool');
  173.             if (!$asset->getEmbeddedMetaData(false)) {
  174.                 $asset->getEmbeddedMetaData(true, false); // read Exif, IPTC and XPM like in the old days ...
  175.             }
  177.             $data['imageInfo'] = $imageInfo;
  178.         }
  180.         $data['properties'] = Element\Service::minimizePropertiesForEditmode($asset->getProperties());
  181.         $data['metadata'] = Asset\Service::expandMetadataForEditmode($asset->getMetadata());
  182.         $data['versionDate'] = $asset->getModificationDate();
  183.         $data['filesizeFormatted'] = $asset->getFileSize(true);
  184.         $data['filesize'] = $asset->getFileSize();
  185.         $data['url'] = Tool::getHostUrl(null, $request) . $asset->getRealFullPath();
  186.         $data['fileExtension'] = File::getFileExtension($asset->getFilename());
  187.         $data['idPath'] = Element\Service::getIdPath($asset);
  188.         $data['userPermissions'] = $asset->getUserPermissions();
  190.         $this->addAdminStyle($asset, ElementAdminStyleEvent::CONTEXT_EDITOR, $data);
  192.         $data['php'] = [
  193.             'classes' => array_merge([get_class($asset)], array_values(class_parents($asset))),
  194.             'interfaces' => array_values(class_implements($asset)),
  195.         ];
  197.         $event = new GenericEvent($this, [
  198.             'data' => $data,
  199.             'asset' => $asset,
  200.         ]);
  201.         $eventDispatcher->dispatch(AdminEvents::ASSET_GET_PRE_SEND_DATA, $event);
  202.         $data = $event->getArgument('data');
  204.         if ($asset->isAllowed('view')) {
  205.             return $this->adminJson($data);
  206.         }
  208.         throw $this->createAccessDeniedHttpException();
  209.     }
  211.     /**
  212.      * @Route("/tree-get-childs-by-id", name="pimcore_admin_asset_treegetchildsbyid", methods={"GET"})
  213.      *
  214.      * @param Request $request
  215.      *
  216.      * @return JsonResponse
  217.      */
  218.     public function treeGetChildsByIdAction(Request $request, EventDispatcherInterface $eventDispatcher)
  219.     {
  220.         $allParams = array_merge($request->request->all(), $request->query->all());
  222.         $assets = [];
  223.         $cv = false;
  224.         $asset = Asset::getById($allParams['node']);
  226.         $filter = $request->get('filter');
  227.         $limit = intval($allParams['limit']);
  228.         if (!is_null($filter)) {
  229.             if (substr($filter, -1) != '*') {
  230.                 $filter .= '*';
  231.             }
  232.             $filter = str_replace('*', '%', $filter);
  234.             $limit = 100;
  235.             $offset = 0;
  236.         } elseif (!$allParams['limit']) {
  237.             $limit = 100000000;
  238.         }
  240.         $offset = isset($allParams['start']) ? intval($allParams['start']) : 0;
  242.         $filteredTotalCount = 0;
  244.         if ($asset->hasChildren()) {
  245.             if ($allParams['view']) {
  246.                 $cv = \Pimcore\Model\Element\Service::getCustomViewById($allParams['view']);
  247.             }
  249.             // get assets
  250.             $childsList = new Asset\Listing();
  251.             $db = Db::get();
  253.             if ($this->getAdminUser()->isAdmin()) {
  254.                 $condition = 'parentId =  ' . $db->quote($asset->getId());
  255.             } else {
  256.                 $userIds = $this->getAdminUser()->getRoles();
  257.                 $userIds[] = $this->getAdminUser()->getId();
  259.                 $condition = 'parentId = ' . $db->quote($asset->getId()) . ' AND
  260.                 (
  261.                     (SELECT list FROM users_workspaces_asset WHERE userId IN (' . implode(',', $userIds) . ') AND LOCATE(CONCAT(path,filename),cpath)=1 ORDER BY LENGTH(cpath) DESC, FIELD(userId, '. $this->getAdminUser()->getId() .') DESC, list DESC LIMIT 1)=1
  262.                     or
  263.                     (SELECT list FROM users_workspaces_asset WHERE userId IN (' . implode(',', $userIds) . ') AND LOCATE(cpath,CONCAT(path,filename))=1 ORDER BY LENGTH(cpath) DESC, FIELD(userId, '. $this->getAdminUser()->getId() .') DESC, list DESC LIMIT 1)=1
  264.                 )';
  265.             }
  267.             if (! is_null($filter)) {
  268.                 $db = Db::get();
  270.                 $condition = '(' . $condition . ')' . ' AND  CAST(assets.filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci LIKE ' . $db->quote($filter);
  271.             }
  273.             $childsList->setCondition($condition);
  275.             $childsList->setLimit($limit);
  276.             $childsList->setOffset($offset);
  277.             $childsList->setOrderKey("FIELD(assets.type, 'folder') DESC, CAST(assets.filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci ASC", false);
  279.             \Pimcore\Model\Element\Service::addTreeFilterJoins($cv, $childsList);
  281.             $beforeListLoadEvent = new GenericEvent($this, [
  282.                 'list' => $childsList,
  283.                 'context' => $allParams,
  284.             ]);
  285.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  286.             /** @var Asset\Listing $childsList */
  287.             $childsList = $beforeListLoadEvent->getArgument('list');
  289.             $childs = $childsList->load();
  291.             $filteredTotalCount = $childsList->getTotalCount();
  293.             foreach ($childs as $childAsset) {
  294.                 if ($childAsset->isAllowed('list')) {
  295.                     $assets[] = $this->getTreeNodeConfig($childAsset);
  296.                 }
  297.             }
  298.         }
  300.         //Hook for modifying return value - e.g. for changing permissions based on asset data
  301.         $event = new GenericEvent($this, [
  302.             'assets' => $assets,
  303.         ]);
  304.         $eventDispatcher->dispatch(AdminEvents::ASSET_TREE_GET_CHILDREN_BY_ID_PRE_SEND_DATA, $event);
  305.         $assets = $event->getArgument('assets');
  307.         if ($allParams['limit']) {
  308.             return $this->adminJson([
  309.                 'offset' => $offset,
  310.                 'limit' => $limit,
  311.                 'total' => $asset->getChildAmount($this->getAdminUser()),
  312.                 'overflow' => !is_null($filter) && ($filteredTotalCount > $limit),
  313.                 'nodes' => $assets,
  314.                 'filter' => $request->get('filter') ? $request->get('filter') : '',
  315.                 'inSearch' => intval($request->get('inSearch')),
  316.             ]);
  317.         } else {
  318.             return $this->adminJson($assets);
  319.         }
  320.     }
  322.     /**
  323.      * @Route("/add-asset", name="pimcore_admin_asset_addasset", methods={"POST"})
  324.      *
  325.      * @param Request $request
  326.      * @param Config $config
  327.      *
  328.      * @return JsonResponse
  329.      */
  330.     public function addAssetAction(Request $request, Config $config)
  331.     {
  332.         try {
  333.             $res = $this->addAsset($request, $config);
  335.             $response = [
  336.                 'success' => $res['success'],
  337.             ];
  339.             if ($res['success']) {
  340.                 $response['asset'] = [
  341.                     'id' => $res['asset']->getId(),
  342.                     'path' => $res['asset']->getFullPath(),
  343.                     'type' => $res['asset']->getType(),
  344.                 ];
  345.             }
  347.             return $this->adminJson($response);
  348.         } catch (\Exception $e) {
  349.             return $this->adminJson([
  350.                 'success' => false,
  351.                 'message' => $e->getMessage(),
  352.             ]);
  353.         }
  354.     }
  356.     /**
  357.      * @Route("/add-asset-compatibility", name="pimcore_admin_asset_addassetcompatibility", methods={"POST"})
  358.      *
  359.      * @param Request $request
  360.      * @param Config $config
  361.      *
  362.      * @return JsonResponse
  363.      */
  364.     public function addAssetCompatibilityAction(Request $request, Config $config)
  365.     {
  366.         try {
  367.             // this is a special action for the compatibility mode upload (without flash)
  368.             $res = $this->addAsset($request, $config);
  370.             $response = $this->adminJson([
  371.                 'success' => $res['success'],
  372.                 'msg' => $res['success'] ? 'Success' : 'Error',
  373.                 'id' => $res['asset'] ? $res['asset']->getId() : null,
  374.                 'fullpath' => $res['asset'] ? $res['asset']->getRealFullPath() : null,
  375.                 'type' => $res['asset'] ? $res['asset']->getType() : null,
  376.             ]);
  377.             $response->headers->set('Content-Type', 'text/html');
  379.             return $response;
  380.         } catch (\Exception $e) {
  381.             return $this->adminJson([
  382.                 'success' => false,
  383.                 'message' => $e->getMessage(),
  384.             ]);
  385.         }
  386.     }
  388.     /**
  389.      * @param Request $request
  390.      * @param Config $config
  391.      *
  392.      * @return array
  393.      *
  394.      * @throws \Exception
  395.      */
  396.     protected function addAsset(Request $request, Config $config)
  397.     {
  398.         $success = false;
  399.         $defaultUploadPath = $config['assets']['default_upload_path'] ?? '/';
  401.         if (array_key_exists('Filedata', $_FILES)) {
  402.             $filename = $_FILES['Filedata']['name'];
  403.             $sourcePath = $_FILES['Filedata']['tmp_name'];
  404.         } elseif ($request->get('type') == 'base64') {
  405.             $filename = $request->get('filename');
  406.             $sourcePath = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/upload-base64' . uniqid() . '.tmp';
  407.             $data = preg_replace('@^data:[^,]+;base64,@', '', $request->get('data'));
  408.             File::put($sourcePath, base64_decode($data));
  409.         } else {
  410.             throw new \Exception('The filename of the asset is empty');
  411.         }
  413.         $parentId = $request->get('parentId');
  414.         $parentPath = $request->get('parentPath');
  416.         if ($request->get('dir') && $request->get('parentId')) {
  417.             // this is for uploading folders with Drag&Drop
  418.             // param "dir" contains the relative path of the file
  419.             $parent = Asset::getById($request->get('parentId'));
  420.             $newPath = $parent->getRealFullPath() . '/' . trim($request->get('dir'), '/ ');
  422.             // check if the path is outside of the asset directory
  423.             $newRealPath = PIMCORE_ASSET_DIRECTORY . $newPath;
  424.             $newRealPath = resolvePath($newRealPath);
  425.             if (strpos($newRealPath, PIMCORE_ASSET_DIRECTORY) !== 0) {
  426.                 throw new \Exception('not allowed');
  427.             }
  429.             $maxRetries = 5;
  430.             $newParent = null;
  431.             for ($retries = 0; $retries < $maxRetries; $retries++) {
  432.                 try {
  433.                     $newParent = Asset\Service::createFolderByPath($newPath);
  434.                     break;
  435.                 } catch (\Exception $e) {
  436.                     if ($retries < ($maxRetries - 1)) {
  437.                         $waitTime = rand(100000, 900000); // microseconds
  438.                         usleep($waitTime); // wait specified time until we restart the transaction
  439.                     } else {
  440.                         // if the transaction still fail after $maxRetries retries, we throw out the exception
  441.                         throw $e;
  442.                     }
  443.                 }
  444.             }
  445.             if ($newParent) {
  446.                 $parentId = $newParent->getId();
  447.             }
  448.         } elseif (!$request->get('parentId') && $parentPath) {
  449.             $parent = Asset::getByPath($parentPath);
  450.             if ($parent instanceof Asset\Folder) {
  451.                 $parentId = $parent->getId();
  452.             }
  453.         }
  455.         $filename = Element\Service::getValidKey($filename, 'asset');
  456.         if (empty($filename)) {
  457.             throw new \Exception('The filename of the asset is empty');
  458.         }
  460.         $context = $request->get('context');
  461.         if ($context) {
  462.             $context = json_decode($context, true);
  463.             $context = $context ? $context : [];
  464.             $event = new \Pimcore\Event\Model\Asset\ResolveUploadTargetEvent($parentId, $filename, $context);
  465.             \Pimcore::getEventDispatcher()->dispatch(AssetEvents::RESOLVE_UPLOAD_TARGET, $event);
  466.             $filename = Element\Service::getValidKey($event->getFilename(), 'asset');
  467.             $parentId = $event->getParentId();
  468.         }
  470.         if (!$parentId) {
  471.             $parentId = Asset\Service::createFolderByPath($defaultUploadPath)->getId();
  472.         }
  474.         $parentAsset = Asset::getById(intval($parentId));
  476.         // check for duplicate filename
  477.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  478.         $asset = null;
  480.         if ($parentAsset->isAllowed('create')) {
  481.             if (is_file($sourcePath) && filesize($sourcePath) < 1) {
  482.                 throw new \Exception('File is empty!');
  483.             } elseif (!is_file($sourcePath)) {
  484.                 throw new \Exception('Something went wrong, please check upload_max_filesize and post_max_size in your php.ini and write permissions of ' . PIMCORE_PUBLIC_VAR);
  485.             }
  487.             $asset = Asset::create($parentId, [
  488.                 'filename' => $filename,
  489.                 'sourcePath' => $sourcePath,
  490.                 'userOwner' => $this->getAdminUser()->getId(),
  491.                 'userModification' => $this->getAdminUser()->getId(),
  492.             ]);
  493.             $success = true;
  495.             @unlink($sourcePath);
  496.         } else {
  497.             Logger::debug('prevented creating asset because of missing permissions, parent asset is ' . $parentAsset->getRealFullPath());
  498.         }
  500.         return [
  501.             'success' => $success,
  502.             'asset' => $asset,
  503.         ];
  504.     }
  506.     /**
  507.      * @param string $targetPath
  508.      * @param string $filename
  509.      *
  510.      * @return string
  511.      */
  512.     protected function getSafeFilename($targetPath, $filename)
  513.     {
  514.         $pathinfo = pathinfo($filename);
  515.         $originalFilename = $pathinfo['filename'];
  516.         $originalFileextension = empty($pathinfo['extension']) ? '' : '.' . $pathinfo['extension'];
  517.         $count = 1;
  519.         if ($targetPath == '/') {
  520.             $targetPath = '';
  521.         }
  523.         while (true) {
  524.             if (Asset\Service::pathExists($targetPath . '/' . $filename)) {
  525.                 $filename = $originalFilename . '_' . $count . $originalFileextension;
  526.                 $count++;
  527.             } else {
  528.                 return $filename;
  529.             }
  530.         }
  531.     }
  533.     /**
  534.      * @Route("/replace-asset", name="pimcore_admin_asset_replaceasset", methods={"POST", "PUT"})
  535.      *
  536.      * @param Request $request
  537.      *
  538.      * @return JsonResponse
  539.      *
  540.      * @throws \Exception
  541.      */
  542.     public function replaceAssetAction(Request $request)
  543.     {
  544.         $asset = Asset::getById($request->get('id'));
  546.         $newFilename = Element\Service::getValidKey($_FILES['Filedata']['name'], 'asset');
  547.         $mimetype = Tool\Mime::detect($_FILES['Filedata']['tmp_name'], $newFilename);
  548.         $newType = Asset::getTypeFromMimeMapping($mimetype, $newFilename);
  550.         if ($newType != $asset->getType()) {
  551.             $translator = $this->get('translator');
  553.             return $this->adminJson([
  554.                 'success' => false,
  555.                 'message' => sprintf($translator->trans('asset_type_change_not_allowed', [], 'admin'), $asset->getType(), $newType),
  556.             ]);
  557.         }
  559.         $stream = fopen($_FILES['Filedata']['tmp_name'], 'r+');
  560.         $asset->setStream($stream);
  561.         $asset->setCustomSetting('thumbnails', null);
  562.         $asset->setUserModification($this->getAdminUser()->getId());
  564.         $newFileExt = File::getFileExtension($newFilename);
  565.         $currentFileExt = File::getFileExtension($asset->getFilename());
  566.         if ($newFileExt != $currentFileExt) {
  567.             $newFilename = preg_replace('/\.' . $currentFileExt . '$/i', '.'.$newFileExt, $asset->getFilename());
  568.             $newFilename = Element\Service::getSaveCopyName('asset', $newFilename, $asset->getParent());
  569.             $asset->setFilename($newFilename);
  570.         }
  572.         if ($asset->isAllowed('publish')) {
  573.             $asset->save();
  575.             $response = $this->adminJson([
  576.                 'id' => $asset->getId(),
  577.                 'path' => $asset->getRealFullPath(),
  578.                 'success' => true,
  579.             ]);
  581.             // set content-type to text/html, otherwise (when application/json is sent) chrome will complain in
  582.             // Ext.form.Action.Submit and mark the submission as failed
  583.             $response->headers->set('Content-Type', 'text/html');
  585.             return $response;
  586.         } else {
  587.             throw new \Exception('missing permission');
  588.         }
  589.     }
  591.     /**
  592.      * @Route("/add-folder", name="pimcore_admin_asset_addfolder", methods={"POST"})
  593.      *
  594.      * @param Request $request
  595.      *
  596.      * @return JsonResponse
  597.      */
  598.     public function addFolderAction(Request $request)
  599.     {
  600.         $success = false;
  601.         $parentAsset = Asset::getById(intval($request->get('parentId')));
  602.         $equalAsset = Asset::getByPath($parentAsset->getRealFullPath() . '/' . $request->get('name'));
  604.         if ($parentAsset->isAllowed('create')) {
  605.             if (!$equalAsset) {
  606.                 $asset = Asset::create($request->get('parentId'), [
  607.                     'filename' => $request->get('name'),
  608.                     'type' => 'folder',
  609.                     'userOwner' => $this->getAdminUser()->getId(),
  610.                     'userModification' => $this->getAdminUser()->getId(),
  611.                 ]);
  612.                 $success = true;
  613.             }
  614.         } else {
  615.             Logger::debug('prevented creating asset because of missing permissions');
  616.         }
  618.         return $this->adminJson(['success' => $success]);
  619.     }
  621.     /**
  622.      * @Route("/delete", name="pimcore_admin_asset_delete", methods={"DELETE"})
  623.      *
  624.      * @param Request $request
  625.      *
  626.      * @return JsonResponse
  627.      */
  628.     public function deleteAction(Request $request)
  629.     {
  630.         if ($request->get('type') == 'childs') {
  631.             $parentAsset = Asset::getById($request->get('id'));
  633.             $list = new Asset\Listing();
  634.             $list->setCondition('path LIKE ?', [$list->escapeLike($parentAsset->getRealFullPath()) . '/%']);
  635.             $list->setLimit(intval($request->get('amount')));
  636.             $list->setOrderKey('LENGTH(path)', false);
  637.             $list->setOrder('DESC');
  639.             $deletedItems = [];
  640.             foreach ($list as $asset) {
  641.                 $deletedItems[$asset->getId()] = $asset->getRealFullPath();
  642.                 if ($asset->isAllowed('delete') && !$asset->isLocked()) {
  643.                     $asset->delete();
  644.                 }
  645.             }
  647.             return $this->adminJson(['success' => true, 'deleted' => $deletedItems]);
  648.         } elseif ($request->get('id')) {
  649.             $asset = Asset::getById($request->get('id'));
  650.             if ($asset && $asset->isAllowed('delete')) {
  651.                 if ($asset->isLocked()) {
  652.                     return $this->adminJson([
  653.                         'success' => false,
  654.                         'message' => 'prevented deleting asset, because it is locked: ID: ' . $asset->getId(),
  655.                     ]);
  656.                 } else {
  657.                     $asset->delete();
  659.                     return $this->adminJson(['success' => true]);
  660.                 }
  661.             }
  662.         }
  664.         throw $this->createAccessDeniedHttpException();
  665.     }
  667.     /**
  668.      * @param Asset $element
  669.      *
  670.      * @return array
  671.      */
  672.     protected function getTreeNodeConfig($element)
  673.     {
  674.         $asset = $element;
  676.         $tmpAsset = [
  677.             'id' => $asset->getId(),
  678.             'text' => htmlspecialchars($asset->getFilename()),
  679.             'type' => $asset->getType(),
  680.             'path' => $asset->getRealFullPath(),
  681.             'basePath' => $asset->getRealPath(),
  682.             'locked' => $asset->isLocked(),
  683.             'lockOwner' => $asset->getLocked() ? true : false,
  684.             'elementType' => 'asset',
  685.             'permissions' => [
  686.                 'remove' => $asset->isAllowed('delete'),
  687.                 'settings' => $asset->isAllowed('settings'),
  688.                 'rename' => $asset->isAllowed('rename'),
  689.                 'publish' => $asset->isAllowed('publish'),
  690.                 'view' => $asset->isAllowed('view'),
  691.             ],
  692.         ];
  694.         // set type specific settings
  695.         if ($asset->getType() == 'folder') {
  696.             $tmpAsset['leaf'] = false;
  697.             $tmpAsset['expanded'] = !$asset->hasChildren();
  698.             $tmpAsset['loaded'] = !$asset->hasChildren();
  699.             $tmpAsset['permissions']['create'] = $asset->isAllowed('create');
  701.             $folderThumbs = [];
  702.             $children = new Asset\Listing();
  703.             $children->setCondition('path LIKE ?', [$children->escapeLike($asset->getRealFullPath()) . '/%']);
  704.             $children->addConditionParam('type IN (\'image\', \'video\', \'document\')', 'AND');
  705.             $children->setLimit(35);
  707.             foreach ($children as $child) {
  708.                 if ($child->isAllowed('view')) {
  709.                     if ($thumbnailUrl = $this->getThumbnailUrl($child)) {
  710.                         $folderThumbs[] = $thumbnailUrl;
  711.                     }
  712.                 }
  713.             }
  715.             if (!empty($folderThumbs)) {
  716.                 $tmpAsset['thumbnails'] = $folderThumbs;
  717.             }
  718.         } else {
  719.             $tmpAsset['leaf'] = true;
  720.             $tmpAsset['expandable'] = false;
  721.             $tmpAsset['expanded'] = false;
  722.         }
  724.         $this->addAdminStyle($asset, ElementAdminStyleEvent::CONTEXT_TREE, $tmpAsset);
  726.         if ($asset->getType() == 'image') {
  727.             try {
  728.                 $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  729.                 $tmpAsset['thumbnailHdpi'] = $this->getThumbnailUrl($asset, true);
  731.                 // this is for backward-compatibility, to calculate the dimensions if they are not there
  732.                 if (!$asset->getCustomSetting('imageDimensionsCalculated')) {
  733.                     $asset->save();
  734.                 }
  736.                 // we need the dimensions for the wysiwyg editors, so that they can resize the image immediately
  737.                 if ($asset->getCustomSetting('imageWidth') && $asset->getCustomSetting('imageHeight')) {
  738.                     $tmpAsset['imageWidth'] = $asset->getCustomSetting('imageWidth');
  739.                     $tmpAsset['imageHeight'] = $asset->getCustomSetting('imageHeight');
  740.                 }
  741.             } catch (\Exception $e) {
  742.                 Logger::debug('Cannot get dimensions of image, seems to be broken.');
  743.             }
  744.         } elseif ($asset->getType() == 'video') {
  745.             try {
  746.                 if (\Pimcore\Video::isAvailable()) {
  747.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  748.                     $tmpAsset['thumbnailHdpi'] = $this->getThumbnailUrl($asset, true);
  749.                 }
  750.             } catch (\Exception $e) {
  751.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  752.             }
  753.         } elseif ($asset->getType() == 'document') {
  754.             try {
  755.                 // add the PDF check here, otherwise the preview layer in admin is shown without content
  756.                 if (\Pimcore\Document::isAvailable() && \Pimcore\Document::isFileTypeSupported($asset->getFilename())) {
  757.                     $tmpAsset['thumbnail'] = $this->getThumbnailUrl($asset);
  758.                     $tmpAsset['thumbnailHdpi'] = $this->getThumbnailUrl($asset, true);
  759.                 }
  760.             } catch (\Exception $e) {
  761.                 Logger::debug('Cannot get dimensions of video, seems to be broken.');
  762.             }
  763.         }
  765.         $tmpAsset['cls'] = '';
  766.         if ($asset->isLocked()) {
  767.             $tmpAsset['cls'] .= 'pimcore_treenode_locked ';
  768.         }
  769.         if ($asset->getLocked()) {
  770.             $tmpAsset['cls'] .= 'pimcore_treenode_lockOwner ';
  771.         }
  773.         return $tmpAsset;
  774.     }
  776.     /**
  777.      * @param Asset $asset
  778.      * @param bool $hdpi
  779.      * @param bool $grid
  780.      *
  781.      * @return null|string
  782.      */
  783.     protected function getThumbnailUrl(Asset $asset, $hdpi = false, $grid = false)
  784.     {
  785.         $params = [
  786.             'id' => $asset->getId(),
  787.             'treepreview' => true,
  788.         ];
  790.         if ($hdpi) {
  791.             $params['hdpi'] = true;
  792.         }
  794.         if ($grid) {
  795.             $params['grid'] = true;
  796.         }
  798.         if ($asset instanceof Asset\Image) {
  799.             return $this->generateUrl('pimcore_admin_asset_getimagethumbnail', $params);
  800.         }
  802.         if ($asset instanceof Asset\Video && \Pimcore\Video::isAvailable()) {
  803.             return $this->generateUrl('pimcore_admin_asset_getvideothumbnail', $params);
  804.         }
  806.         if ($asset instanceof Asset\Document && \Pimcore\Document::isAvailable()) {
  807.             return $this->generateUrl('pimcore_admin_asset_getdocumentthumbnail', $params);
  808.         }
  810.         return null;
  811.     }
  813.     /**
  814.      * @Route("/update", name="pimcore_admin_asset_update", methods={"PUT"})
  815.      *
  816.      * @param Request $request
  817.      *
  818.      * @return JsonResponse
  819.      *
  820.      * @throws \Exception
  821.      */
  822.     public function updateAction(Request $request)
  823.     {
  824.         $success = false;
  825.         $allowUpdate = true;
  827.         $updateData = array_merge($request->request->all(), $request->query->all());
  829.         $asset = Asset::getById($request->get('id'));
  830.         if ($asset->isAllowed('settings')) {
  831.             $asset->setUserModification($this->getAdminUser()->getId());
  833.             // if the position is changed the path must be changed || also from the children
  834.             if ($request->get('parentId')) {
  835.                 $parentAsset = Asset::getById($request->get('parentId'));
  837.                 //check if parent is changed i.e. asset is moved
  838.                 if ($asset->getParentId() != $parentAsset->getId()) {
  839.                     if (!$parentAsset->isAllowed('create')) {
  840.                         throw new \Exception('Prevented moving asset - no create permission on new parent ');
  841.                     }
  843.                     $intendedPath = $parentAsset->getRealPath();
  844.                     $pKey = $parentAsset->getKey();
  845.                     if (!empty($pKey)) {
  846.                         $intendedPath .= $parentAsset->getKey() . '/';
  847.                     }
  849.                     $assetWithSamePath = Asset::getByPath($intendedPath . $asset->getKey());
  851.                     if ($assetWithSamePath != null) {
  852.                         $allowUpdate = false;
  853.                     }
  855.                     if ($asset->isLocked()) {
  856.                         $allowUpdate = false;
  857.                     }
  858.                 }
  859.             }
  861.             if ($allowUpdate) {
  862.                 if ($request->get('filename') != $asset->getFilename() and !$asset->isAllowed('rename')) {
  863.                     unset($updateData['filename']);
  864.                     Logger::debug('prevented renaming asset because of missing permissions ');
  865.                 }
  867.                 $asset->setValues($updateData);
  869.                 try {
  870.                     $asset->save();
  871.                     $success = true;
  872.                 } catch (\Exception $e) {
  873.                     return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  874.                 }
  875.             } else {
  876.                 $msg = 'prevented moving asset, asset with same path+key already exists at target location or the asset is locked. ID: ' . $asset->getId();
  877.                 Logger::debug($msg);
  879.                 return $this->adminJson(['success' => $success, 'message' => $msg]);
  880.             }
  881.         } elseif ($asset->isAllowed('rename') && $request->get('filename')) {
  882.             //just rename
  883.             try {
  884.                 $asset->setFilename($request->get('filename'));
  885.                 $asset->save();
  886.                 $success = true;
  887.             } catch (\Exception $e) {
  888.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  889.             }
  890.         } else {
  891.             Logger::debug('prevented update asset because of missing permissions ');
  892.         }
  894.         return $this->adminJson(['success' => $success]);
  895.     }
  897.     /**
  898.      * @Route("/webdav{path}", name="pimcore_admin_webdav", requirements={"path"=".*"})
  899.      *
  900.      * @param Request $request
  901.      */
  902.     public function webdavAction(Request $request)
  903.     {
  904.         $homeDir = Asset::getById(1);
  906.         try {
  907.             $publicDir = new Asset\WebDAV\Folder($homeDir);
  908.             $objectTree = new Asset\WebDAV\Tree($publicDir);
  909.             $server = new \Sabre\DAV\Server($objectTree);
  910.             $server->setBaseUri($this->generateUrl('pimcore_admin_webdav', [ 'path' => '/' ]));
  912.             // lock plugin
  913.             $lockBackend = new \Sabre\DAV\Locks\Backend\File(PIMCORE_SYSTEM_TEMP_DIRECTORY . '/webdav-locks.dat');
  914.             $lockPlugin = new \Sabre\DAV\Locks\Plugin($lockBackend);
  915.             $server->addPlugin($lockPlugin);
  917.             // sync plugin
  918.             $server->addPlugin(new \Sabre\DAV\Sync\Plugin());
  920.             // browser plugin
  921.             $server->addPlugin(new \Sabre\DAV\Browser\Plugin());
  923.             $server->exec();
  924.         } catch (\Exception $e) {
  925.             Logger::error($e);
  926.         }
  928.         exit;
  929.     }
  931.     /**
  932.      * @Route("/save", name="pimcore_admin_asset_save", methods={"PUT","POST"})
  933.      *
  934.      * @param Request $request
  935.      * @param EventDispatcherInterface $eventDispatcher
  936.      *
  937.      * @return JsonResponse
  938.      *
  939.      * @throws \Exception
  940.      */
  941.     public function saveAction(Request $request, EventDispatcherInterface $eventDispatcher)
  942.     {
  943.         $asset = Asset::getById($request->get('id'));
  945.         if (!$asset) {
  946.             throw $this->createNotFoundException('Asset not found');
  947.         }
  949.         if ($asset->isAllowed('publish')) {
  950.             // metadata
  951.             if ($request->get('metadata')) {
  952.                 $metadata = $this->decodeJson($request->get('metadata'));
  954.                 $metadataEvent = new GenericEvent($this, [
  955.                     'id' => $asset->getId(),
  956.                     'metadata' => $metadata,
  957.                 ]);
  958.                 $eventDispatcher->dispatch(AdminEvents::ASSET_METADATA_PRE_SET, $metadataEvent);
  960.                 $metadata = $metadataEvent->getArgument('metadata');
  961.                 $metadataValues = $metadata['values'];
  963.                 $metadataValues = Asset\Service::minimizeMetadata($metadataValues, 'editor');
  964.                 $asset->setMetadataRaw($metadataValues);
  965.             }
  967.             // properties
  968.             if ($request->get('properties')) {
  969.                 $properties = [];
  970.                 $propertiesData = $this->decodeJson($request->get('properties'));
  972.                 if (is_array($propertiesData)) {
  973.                     foreach ($propertiesData as $propertyName => $propertyData) {
  974.                         $value = $propertyData['data'];
  976.                         try {
  977.                             $property = new Model\Property();
  978.                             $property->setType($propertyData['type']);
  979.                             $property->setName($propertyName);
  980.                             $property->setCtype('asset');
  981.                             $property->setDataFromEditmode($value);
  982.                             $property->setInheritable($propertyData['inheritable']);
  984.                             $properties[$propertyName] = $property;
  985.                         } catch (\Exception $e) {
  986.                             Logger::err("Can't add " . $propertyName . ' to asset ' . $asset->getRealFullPath());
  987.                         }
  988.                     }
  990.                     $asset->setProperties($properties);
  991.                 }
  992.             }
  994.             $this->applySchedulerDataToElement($request, $asset);
  996.             if ($request->get('data')) {
  997.                 $asset->setData($request->get('data'));
  998.             }
  1000.             // image specific data
  1001.             if ($asset instanceof Asset\Image) {
  1002.                 if ($request->get('image')) {
  1003.                     $imageData = $this->decodeJson($request->get('image'));
  1004.                     if (isset($imageData['focalPoint'])) {
  1005.                         $asset->setCustomSetting('focalPointX', $imageData['focalPoint']['x']);
  1006.                         $asset->setCustomSetting('focalPointY', $imageData['focalPoint']['y']);
  1007.                         $asset->removeCustomSetting('disableFocalPointDetection');
  1008.                     }
  1009.                 } else {
  1010.                     // wipe all data
  1011.                     $asset->removeCustomSetting('focalPointX');
  1012.                     $asset->removeCustomSetting('focalPointY');
  1013.                     $asset->setCustomSetting('disableFocalPointDetection', true);
  1014.                 }
  1015.             }
  1017.             $asset->setUserModification($this->getAdminUser()->getId());
  1018.             if ($request->get('task') === 'session') {
  1019.                 // save to session only
  1020.                 Asset\Service::saveElementToSession($asset);
  1021.             } else {
  1022.                 $asset->save();
  1023.             }
  1025.             $treeData = $this->getTreeNodeConfig($asset);
  1027.             return $this->adminJson([
  1028.                 'success' => true,
  1029.                 'data' => [
  1030.                     'versionDate' => $asset->getModificationDate(),
  1031.                     'versionCount' => $asset->getVersionCount(),
  1032.                 ],
  1033.                 'treeData' => $treeData,
  1034.             ]);
  1035.         } else {
  1036.             throw $this->createAccessDeniedHttpException();
  1037.         }
  1038.     }
  1040.     /**
  1041.      * @Route("/publish-version", name="pimcore_admin_asset_publishversion", methods={"POST"})
  1042.      *
  1043.      * @param Request $request
  1044.      *
  1045.      * @return JsonResponse
  1046.      */
  1047.     public function publishVersionAction(Request $request)
  1048.     {
  1049.         $version = Model\Version::getById($request->get('id'));
  1050.         $asset = $version->loadData();
  1052.         $currentAsset = Asset::getById($asset->getId());
  1053.         if ($currentAsset->isAllowed('publish')) {
  1054.             try {
  1055.                 $asset->setUserModification($this->getAdminUser()->getId());
  1056.                 $asset->save();
  1058.                 $treeData = $this->getTreeNodeConfig($asset);
  1060.                 return $this->adminJson(['success' => true, 'treeData' => $treeData]);
  1061.             } catch (\Exception $e) {
  1062.                 return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  1063.             }
  1064.         }
  1066.         throw $this->createAccessDeniedHttpException();
  1067.     }
  1069.     /**
  1070.      * @Route("/show-version", name="pimcore_admin_asset_showversion", methods={"GET"})
  1071.      * @TemplatePhp()
  1072.      *
  1073.      * @param Request $request
  1074.      *
  1075.      * @return Response
  1076.      */
  1077.     public function showVersionAction(Request $request)
  1078.     {
  1079.         $id = intval($request->get('id'));
  1080.         $version = Model\Version::getById($id);
  1081.         if (!$version) {
  1082.             throw $this->createNotFoundException('Version not found');
  1083.         }
  1084.         $asset = $version->loadData();
  1086.         if (!$asset->isAllowed('versions')) {
  1087.             throw $this->createAccessDeniedHttpException('Permission denied, version id [' . $id . ']');
  1088.         }
  1090.         return $this->render(
  1091.             'PimcoreAdminBundle:Admin/Asset:showVersion' . ucfirst($asset->getType()) . '.html.php',
  1092.             ['asset' => $asset]
  1093.         );
  1094.     }
  1096.     /**
  1097.      * @Route("/download", name="pimcore_admin_asset_download", methods={"GET"})
  1098.      *
  1099.      * @param Request $request
  1100.      *
  1101.      * @return BinaryFileResponse
  1102.      */
  1103.     public function downloadAction(Request $request)
  1104.     {
  1105.         $asset = Asset::getById($request->get('id'));
  1107.         if (!$asset) {
  1108.             throw $this->createNotFoundException('Asset not found');
  1109.         }
  1111.         if (!$asset->isAllowed('view')) {
  1112.             throw $this->createAccessDeniedException('not allowed to view asset');
  1113.         }
  1115.         $response = new BinaryFileResponse($asset->getFileSystemPath());
  1116.         $response->headers->set('Content-Type', $asset->getMimetype());
  1117.         $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $asset->getFilename());
  1119.         return $response;
  1120.     }
  1122.     /**
  1123.      * @Route("/download-image-thumbnail", name="pimcore_admin_asset_downloadimagethumbnail", methods={"GET"})
  1124.      *
  1125.      * @param Request $request
  1126.      *
  1127.      * @return BinaryFileResponse
  1128.      */
  1129.     public function downloadImageThumbnailAction(Request $request)
  1130.     {
  1131.         $image = Asset\Image::getById($request->get('id'));
  1133.         if (!$image) {
  1134.             throw $this->createNotFoundException('Asset not found');
  1135.         }
  1137.         if (!$image->isAllowed('view')) {
  1138.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1139.         }
  1141.         $config = null;
  1142.         $thumbnail = null;
  1143.         $thumbnailName = $request->get('thumbnail');
  1144.         $thumbnailFile = null;
  1146.         if ($request->get('config')) {
  1147.             $config = $this->decodeJson($request->get('config'));
  1148.         } elseif ($request->get('type')) {
  1149.             $predefined = [
  1150.                 'web' => [
  1151.                     'resize_mode' => 'scaleByWidth',
  1152.                     'width' => 3500,
  1153.                     'dpi' => 72,
  1154.                     'format' => 'JPEG',
  1155.                     'quality' => 85,
  1156.                 ],
  1157.                 'print' => [
  1158.                     'resize_mode' => 'scaleByWidth',
  1159.                     'width' => 6000,
  1160.                     'dpi' => 300,
  1161.                     'format' => 'JPEG',
  1162.                     'quality' => 95,
  1163.                 ],
  1164.                 'office' => [
  1165.                     'resize_mode' => 'scaleByWidth',
  1166.                     'width' => 1190,
  1167.                     'dpi' => 144,
  1168.                     'format' => 'JPEG',
  1169.                     'quality' => 90,
  1170.                 ],
  1171.             ];
  1173.             $config = $predefined[$request->get('type')];
  1174.         } elseif ($thumbnailName) {
  1175.             $thumbnail = $image->getThumbnail($thumbnailName);
  1176.         }
  1178.         if ($config) {
  1179.             $thumbnailConfig = new Asset\Image\Thumbnail\Config();
  1180.             $thumbnailConfig->setName('pimcore-download-' . $image->getId() . '-' . md5($request->get('config')));
  1182.             if ($config['resize_mode'] == 'scaleByWidth') {
  1183.                 $thumbnailConfig->addItem('scaleByWidth', [
  1184.                     'width' => $config['width'],
  1185.                 ]);
  1186.             } elseif ($config['resize_mode'] == 'scaleByHeight') {
  1187.                 $thumbnailConfig->addItem('scaleByHeight', [
  1188.                     'height' => $config['height'],
  1189.                 ]);
  1190.             } else {
  1191.                 $thumbnailConfig->addItem('resize', [
  1192.                     'width' => $config['width'],
  1193.                     'height' => $config['height'],
  1194.                 ]);
  1195.             }
  1197.             $thumbnailConfig->setQuality($config['quality']);
  1198.             $thumbnailConfig->setFormat($config['format']);
  1200.             if ($thumbnailConfig->getFormat() == 'JPEG') {
  1201.                 $thumbnailConfig->setPreserveMetaData(true);
  1203.                 if (empty($config['quality'])) {
  1204.                     $thumbnailConfig->setPreserveColor(true);
  1205.                 }
  1206.             }
  1208.             $thumbnail = $image->getThumbnail($thumbnailConfig);
  1209.             $thumbnailFile = $thumbnail->getFileSystemPath();
  1211.             $exiftool = \Pimcore\Tool\Console::getExecutable('exiftool');
  1212.             if ($thumbnailConfig->getFormat() == 'JPEG' && $exiftool && isset($config['dpi']) && $config['dpi']) {
  1213.                 \Pimcore\Tool\Console::exec($exiftool . ' -overwrite_original -xresolution=' . escapeshellarg((int) $config['dpi']) . ' -yresolution=' . escapeshellarg((int) $config['dpi']) . ' -resolutionunit=inches ' . escapeshellarg($thumbnailFile));
  1214.             }
  1215.         }
  1216.         if ($thumbnail) {
  1217.             $thumbnailFile = $thumbnailFile ?: $thumbnail->getFileSystemPath();
  1219.             $downloadFilename = preg_replace(
  1220.                 '/\.' . preg_quote(File::getFileExtension($image->getFilename())) . '$/i',
  1221.                 '.' . $thumbnail->getFileExtension(),
  1222.                 $image->getFilename()
  1223.             );
  1224.             $downloadFilename = strtolower($downloadFilename);
  1226.             clearstatcache();
  1228.             $response = new BinaryFileResponse($thumbnailFile);
  1229.             $response->headers->set('Content-Type', $thumbnail->getMimeType());
  1230.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $downloadFilename);
  1231.             $this->addThumbnailCacheHeaders($response);
  1232.             $response->deleteFileAfterSend(true);
  1234.             return $response;
  1235.         }
  1237.         throw $this->createNotFoundException('Thumbnail not found');
  1238.     }
  1240.     /**
  1241.      * @Route("/get-asset", name="pimcore_admin_asset_getasset", methods={"GET"})
  1242.      *
  1243.      * @param Request $request
  1244.      *
  1245.      * @return BinaryFileResponse
  1246.      */
  1247.     public function getAssetAction(Request $request)
  1248.     {
  1249.         $image = Asset::getById(intval($request->get('id')));
  1251.         if (!$image) {
  1252.             throw $this->createNotFoundException('Asset not found');
  1253.         }
  1255.         if (!$image->isAllowed('view')) {
  1256.             throw $this->createAccessDeniedException('not allowed to view asset');
  1257.         }
  1259.         $response = new BinaryFileResponse($image->getFileSystemPath());
  1260.         $response->headers->set('Content-type', $image->getMimetype());
  1261.         $response->headers->set('Access-Control-Allow-Origin', '*');
  1262.         $this->addThumbnailCacheHeaders($response);
  1264.         return $response;
  1265.     }
  1267.     /**
  1268.      * @Route("/get-image-thumbnail", name="pimcore_admin_asset_getimagethumbnail", methods={"GET"})
  1269.      *
  1270.      * @param Request $request
  1271.      *
  1272.      * @return BinaryFileResponse|JsonResponse
  1273.      */
  1274.     public function getImageThumbnailAction(Request $request)
  1275.     {
  1276.         $fileinfo = $request->get('fileinfo');
  1277.         $image = Asset\Image::getById(intval($request->get('id')));
  1279.         if (!$image) {
  1280.             throw $this->createNotFoundException('Asset not found');
  1281.         }
  1283.         if (!$image->isAllowed('view')) {
  1284.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1285.         }
  1287.         $thumbnailConfig = null;
  1289.         if ($request->get('thumbnail')) {
  1290.             $thumbnailConfig = $image->getThumbnailConfig($request->get('thumbnail'));
  1291.         }
  1292.         if (!$thumbnailConfig) {
  1293.             if ($request->get('config')) {
  1294.                 $thumbnailConfig = $image->getThumbnailConfig($this->decodeJson($request->get('config')));
  1295.             } else {
  1296.                 $thumbnailConfig = $image->getThumbnailConfig(array_merge($request->request->all(), $request->query->all()));
  1297.             }
  1298.         } else {
  1299.             // no high-res images in admin mode (editmode)
  1300.             // this is mostly because of the document's image editable, which doesn't know anything about the thumbnail
  1301.             // configuration, so the dimensions would be incorrect (double the size)
  1302.             $thumbnailConfig->setHighResolution(1);
  1303.         }
  1305.         $format = strtolower($thumbnailConfig->getFormat());
  1306.         if ($format == 'source' || $format == 'print') {
  1307.             $thumbnailConfig->setFormat('PNG');
  1308.             $thumbnailConfig->setRasterizeSVG(true);
  1309.         }
  1311.         if ($request->get('treepreview')) {
  1312.             $thumbnailConfig = Asset\Image\Thumbnail\Config::getPreviewConfig((bool) $request->get('hdpi'));
  1313.         }
  1315.         $cropPercent = $request->get('cropPercent');
  1316.         if ($cropPercent && filter_var($cropPercent, FILTER_VALIDATE_BOOLEAN)) {
  1317.             $thumbnailConfig->addItemAt(0, 'cropPercent', [
  1318.                 'width' => $request->get('cropWidth'),
  1319.                 'height' => $request->get('cropHeight'),
  1320.                 'y' => $request->get('cropTop'),
  1321.                 'x' => $request->get('cropLeft'),
  1322.             ]);
  1324.             $hash = md5(Tool\Serialize::serialize(array_merge($request->request->all(), $request->query->all())));
  1325.             $thumbnailConfig->setName($thumbnailConfig->getName() . '_auto_' . $hash);
  1326.         }
  1328.         $thumbnail = $image->getThumbnail($thumbnailConfig);
  1330.         if ($fileinfo) {
  1331.             return $this->adminJson([
  1332.                 'width' => $thumbnail->getWidth(),
  1333.                 'height' => $thumbnail->getHeight(), ]);
  1334.         }
  1336.         $thumbnailFile = $thumbnail->getFileSystemPath();
  1338.         $response = new BinaryFileResponse($thumbnailFile);
  1339.         $response->headers->set('Content-Type', $thumbnail->getMimeType());
  1340.         $response->headers->set('Access-Control-Allow-Origin', '*');
  1342.         $this->addThumbnailCacheHeaders($response);
  1344.         return $response;
  1345.     }
  1347.     /**
  1348.      * @Route("/get-video-thumbnail", name="pimcore_admin_asset_getvideothumbnail", methods={"GET"})
  1349.      *
  1350.      * @param Request $request
  1351.      *
  1352.      * @return BinaryFileResponse
  1353.      */
  1354.     public function getVideoThumbnailAction(Request $request)
  1355.     {
  1356.         $video = null;
  1358.         if ($request->get('id')) {
  1359.             $video = Asset\Video::getById(intval($request->get('id')));
  1360.         } elseif ($request->get('path')) {
  1361.             $video = Asset\Video::getByPath($request->get('path'));
  1362.         }
  1364.         if (!$video) {
  1365.             throw $this->createNotFoundException('could not load video asset');
  1366.         }
  1368.         if (!$video->isAllowed('view')) {
  1369.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1370.         }
  1372.         $thumbnail = array_merge($request->request->all(), $request->query->all());
  1374.         if ($request->get('treepreview')) {
  1375.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig((bool) $request->get('hdpi'));
  1376.         }
  1378.         $time = null;
  1379.         if ($request->get('time')) {
  1380.             $time = intval($request->get('time'));
  1381.         }
  1383.         if ($request->get('settime')) {
  1384.             $video->removeCustomSetting('image_thumbnail_asset');
  1385.             $video->setCustomSetting('image_thumbnail_time', $time);
  1386.             $video->save();
  1387.         }
  1389.         $image = null;
  1390.         if ($request->get('image')) {
  1391.             $image = Asset::getById(intval($request->get('image')));
  1392.         }
  1394.         if ($request->get('setimage') && $image) {
  1395.             $video->removeCustomSetting('image_thumbnail_time');
  1396.             $video->setCustomSetting('image_thumbnail_asset', $image->getId());
  1397.             $video->save();
  1398.         }
  1400.         $thumb = $video->getImageThumbnail($thumbnail, $time, $image);
  1401.         $thumbnailFile = $thumb->getFileSystemPath();
  1403.         $response = new BinaryFileResponse($thumbnailFile);
  1404.         $response->headers->set('Content-type', 'image/' . File::getFileExtension($thumbnailFile));
  1406.         $this->addThumbnailCacheHeaders($response);
  1408.         return $response;
  1409.     }
  1411.     /**
  1412.      * @Route("/get-document-thumbnail", name="pimcore_admin_asset_getdocumentthumbnail", methods={"GET"})
  1413.      *
  1414.      * @param Request $request
  1415.      *
  1416.      * @return BinaryFileResponse
  1417.      */
  1418.     public function getDocumentThumbnailAction(Request $request)
  1419.     {
  1420.         $document = Asset\Document::getById(intval($request->get('id')));
  1422.         if (!$document) {
  1423.             throw $this->createNotFoundException('could not load document asset');
  1424.         }
  1426.         if (!$document->isAllowed('view')) {
  1427.             throw $this->createAccessDeniedException('not allowed to view thumbnail');
  1428.         }
  1430.         $thumbnail = Asset\Image\Thumbnail\Config::getByAutoDetect(array_merge($request->request->all(), $request->query->all()));
  1432.         $format = strtolower($thumbnail->getFormat());
  1433.         if ($format == 'source') {
  1434.             $thumbnail->setFormat('jpeg'); // default format for documents is JPEG not PNG (=too big)
  1435.         }
  1437.         if ($request->get('treepreview')) {
  1438.             $thumbnail = Asset\Image\Thumbnail\Config::getPreviewConfig((bool) $request->get('hdpi'));
  1439.         }
  1441.         $page = 1;
  1442.         if (is_numeric($request->get('page'))) {
  1443.             $page = (int)$request->get('page');
  1444.         }
  1446.         $thumb = $document->getImageThumbnail($thumbnail, $page);
  1447.         $thumbnailFile = $thumb->getFileSystemPath();
  1449.         $response = new BinaryFileResponse($thumbnailFile);
  1450.         $this->addThumbnailCacheHeaders($response);
  1452.         return $response;
  1453.     }
  1455.     /**
  1456.      * @param Response $response
  1457.      */
  1458.     protected function addThumbnailCacheHeaders(Response $response)
  1459.     {
  1460.         $lifetime = 300;
  1461.         $date = new \DateTime('now');
  1462.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  1464.         $response->setMaxAge($lifetime);
  1465.         $response->setPublic();
  1466.         $response->setExpires($date);
  1467.         $response->headers->set('Pragma', '');
  1468.     }
  1470.     /**
  1471.      * @Route("/get-preview-document", name="pimcore_admin_asset_getpreviewdocument", methods={"GET"})
  1472.      * @TemplatePhp()
  1473.      *
  1474.      * @param Request $request
  1475.      *
  1476.      * @return BinaryFileResponse
  1477.      */
  1478.     public function getPreviewDocumentAction(Request $request)
  1479.     {
  1480.         $asset = Asset\Document::getById($request->get('id'));
  1482.         if (!$asset) {
  1483.             throw $this->createNotFoundException('could not load document asset');
  1484.         }
  1486.         if ($asset->isAllowed('view')) {
  1487.             $pdfFsPath = $this->getDocumentPreviewPdf($asset);
  1488.             if ($pdfFsPath) {
  1489.                 $response = new BinaryFileResponse($pdfFsPath);
  1490.                 $response->headers->set('Content-Type', 'application/pdf');
  1492.                 return $response;
  1493.             } else {
  1494.                 throw $this->createNotFoundException('Unable to get preview for asset ' . $asset->getId());
  1495.             }
  1496.         } else {
  1497.             throw $this->createAccessDeniedException('Access to asset ' . $asset->getId() . ' denied');
  1498.         }
  1499.     }
  1501.     /**
  1502.      * @param Asset\Document $asset
  1503.      *
  1504.      * @return string|null
  1505.      */
  1506.     protected function getDocumentPreviewPdf(Asset\Document $asset)
  1507.     {
  1508.         $pdfFsPath = null;
  1510.         if ($asset->getMimetype() == 'application/pdf') {
  1511.             $pdfFsPath = $asset->getFileSystemPath();
  1512.         }
  1514.         if (!$pdfFsPath && $asset->getPageCount() && \Pimcore\Document::isAvailable() && \Pimcore\Document::isFileTypeSupported($asset->getFilename())) {
  1515.             try {
  1516.                 $document = \Pimcore\Document::getInstance();
  1517.                 $pdfFsPath = $document->getPdf($asset->getFileSystemPath());
  1518.             } catch (\Exception $e) {
  1519.                 // nothing to do
  1520.             }
  1521.         }
  1523.         return $pdfFsPath;
  1524.     }
  1526.     /**
  1527.      * @Route("/get-preview-video", name="pimcore_admin_asset_getpreviewvideo", methods={"GET"})
  1528.      * @TemplatePhp()
  1529.      *
  1530.      * @param Request $request
  1531.      *
  1532.      * @return Response
  1533.      */
  1534.     public function getPreviewVideoAction(Request $request)
  1535.     {
  1536.         $asset = Asset\Video::getById($request->get('id'));
  1538.         if (!$asset) {
  1539.             throw $this->createNotFoundException('could not load video asset');
  1540.         }
  1542.         if (!$asset->isAllowed('view')) {
  1543.             throw $this->createAccessDeniedException('not allowed to preview');
  1544.         }
  1546.         $previewData = ['asset' => $asset];
  1547.         $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  1548.         $thumbnail = $asset->getThumbnail($config, ['mp4']);
  1550.         if ($thumbnail) {
  1551.             $previewData['asset'] = $asset;
  1552.             $previewData['thumbnail'] = $thumbnail;
  1554.             if ($thumbnail['status'] == 'finished') {
  1555.                 return $this->render(
  1556.                     'PimcoreAdminBundle:Admin/Asset:getPreviewVideoDisplay.html.php',
  1557.                     $previewData
  1558.                 );
  1559.             } else {
  1560.                 return $this->render(
  1561.                     'PimcoreAdminBundle:Admin/Asset:getPreviewVideoError.html.php',
  1562.                     $previewData
  1563.                 );
  1564.             }
  1565.         } else {
  1566.             return $this->render(
  1567.                 'PimcoreAdminBundle:Admin/Asset:getPreviewVideoError.html.php',
  1568.                 $previewData
  1569.             );
  1570.         }
  1571.     }
  1573.     /**
  1574.      * @Route("/serve-video-preview", name="pimcore_admin_asset_servevideopreview", methods={"GET"})
  1575.      *
  1576.      * @param Request $request
  1577.      *
  1578.      * @return BinaryFileResponse
  1579.      */
  1580.     public function serveVideoPreviewAction(Request $request)
  1581.     {
  1582.         $asset = Asset\Video::getById($request->get('id'));
  1584.         if (!$asset) {
  1585.             throw $this->createNotFoundException('could not load video asset');
  1586.         }
  1588.         if (!$asset->isAllowed('view')) {
  1589.             throw $this->createAccessDeniedException('not allowed to preview');
  1590.         }
  1592.         $config = Asset\Video\Thumbnail\Config::getPreviewConfig();
  1593.         $thumbnail = $asset->getThumbnail($config, ['mp4']);
  1594.         $fsFile = $asset->getVideoThumbnailSavePath() . '/' . preg_replace('@^' . preg_quote($asset->getPath(), '@') . '@', '', urldecode($thumbnail['formats']['mp4']));
  1596.         if (file_exists($fsFile)) {
  1597.             $response = new BinaryFileResponse($fsFile);
  1598.             $response->headers->set('Content-Type', 'video/mp4');
  1600.             return $response;
  1601.         } else {
  1602.             throw $this->createNotFoundException('Video thumbnail not found');
  1603.         }
  1604.     }
  1606.     /**
  1607.      * @Route("/image-editor", name="pimcore_admin_asset_imageeditor", methods={"GET"})
  1608.      *
  1609.      * @param Request $request
  1610.      * @TemplatePhp()
  1611.      *
  1612.      * @return array
  1613.      */
  1614.     public function imageEditorAction(Request $request)
  1615.     {
  1616.         $asset = Asset::getById($request->get('id'));
  1618.         if (!$asset->isAllowed('view')) {
  1619.             throw new \Exception('not allowed to preview');
  1620.         }
  1622.         return ['asset' => $asset];
  1623.     }
  1625.     /**
  1626.      * @Route("/image-editor-save", name="pimcore_admin_asset_imageeditorsave", methods={"PUT"})
  1627.      *
  1628.      * @param Request $request
  1629.      *
  1630.      * @return JsonResponse
  1631.      */
  1632.     public function imageEditorSaveAction(Request $request)
  1633.     {
  1634.         $asset = Asset::getById($request->get('id'));
  1636.         if (!$asset) {
  1637.             throw $this->createNotFoundException('Asset not found');
  1638.         }
  1640.         if (!$asset->isAllowed('publish')) {
  1641.             throw $this->createAccessDeniedException('not allowed to publish');
  1642.         }
  1644.         $data = $request->get('dataUri');
  1645.         $data = substr($data, strpos($data, ','));
  1646.         $data = base64_decode($data);
  1647.         $asset->setData($data);
  1648.         $asset->setUserModification($this->getAdminUser()->getId());
  1649.         $asset->save();
  1651.         return $this->adminJson(['success' => true]);
  1652.     }
  1654.     /**
  1655.      * @Route("/get-folder-content-preview", name="pimcore_admin_asset_getfoldercontentpreview", methods={"GET"})
  1656.      *
  1657.      * @param Request $request
  1658.      *
  1659.      * @return JsonResponse
  1660.      */
  1661.     public function getFolderContentPreviewAction(Request $request, EventDispatcherInterface $eventDispatcher)
  1662.     {
  1663.         $allParams = array_merge($request->request->all(), $request->query->all());
  1665.         $filterPrepareEvent = new GenericEvent($this, [
  1666.             'requestParams' => $allParams,
  1667.         ]);
  1668.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE, $filterPrepareEvent);
  1670.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  1672.         $folder = Asset::getById($allParams['id']);
  1674.         $start = 0;
  1675.         $limit = 10;
  1677.         if ($allParams['limit']) {
  1678.             $limit = $allParams['limit'];
  1679.         }
  1680.         if ($allParams['start']) {
  1681.             $start = $allParams['start'];
  1682.         }
  1684.         $conditionFilters = [];
  1685.         $list = new Asset\Listing();
  1686.         $conditionFilters[] = 'path LIKE ' . ($folder->getRealFullPath() == '/' ? "'/%'" : $list->quote($list->escapeLike($folder->getRealFullPath()) . '/%')) ." AND type != 'folder'";
  1688.         if (!$this->getAdminUser()->isAdmin()) {
  1689.             $userIds = $this->getAdminUser()->getRoles();
  1690.             $userIds[] = $this->getAdminUser()->getId();
  1691.             $conditionFilters[] = ' (
  1692.                                                     (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
  1693.                                                     OR
  1694.                                                     (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
  1695.                                                  )';
  1696.         }
  1698.         $condition = implode(' AND ', $conditionFilters);
  1700.         $list->setCondition($condition);
  1701.         $list->setLimit($limit);
  1702.         $list->setOffset($start);
  1703.         $list->setOrderKey('CAST(filename AS CHAR CHARACTER SET utf8) COLLATE utf8_general_ci ASC', false);
  1705.         $beforeListLoadEvent = new GenericEvent($this, [
  1706.             'list' => $list,
  1707.             'context' => $allParams,
  1708.         ]);
  1709.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  1710.         /** @var Asset\Listing $list */
  1711.         $list = $beforeListLoadEvent->getArgument('list');
  1713.         $list->load();
  1715.         $assets = [];
  1717.         foreach ($list as $asset) {
  1718.             $thumbnailMethod = Asset\Service::getPreviewThumbnail($asset, [], true);
  1720.             if (!empty($thumbnailMethod)) {
  1721.                 $filenameDisplay = $asset->getFilename();
  1722.                 if (strlen($filenameDisplay) > 32) {
  1723.                     $filenameDisplay = substr($filenameDisplay, 0, 25) . '...' . \Pimcore\File::getFileExtension($filenameDisplay);
  1724.                 }
  1726.                 // 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
  1727.                 if ($asset->isAllowed('list')) {
  1728.                     $assets[] = [
  1729.                         'id' => $asset->getId(),
  1730.                         'type' => $asset->getType(),
  1731.                         'filename' => $asset->getFilename(),
  1732.                         'filenameDisplay' => htmlspecialchars($filenameDisplay),
  1733.                         'url' => $this->getThumbnailUrl($asset, true, true),
  1734.                         'idPath' => $data['idPath'] = Element\Service::getIdPath($asset),
  1735.                     ];
  1736.                 }
  1737.             }
  1738.         }
  1740.         // We need to temporary use data key to be compatible with the ASSET_LIST_AFTER_LIST_LOAD global event
  1741.         $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  1743.         $afterListLoadEvent = new GenericEvent($this, [
  1744.             'list' => $result,
  1745.             'context' => $allParams,
  1746.         ]);
  1747.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_AFTER_LIST_LOAD, $afterListLoadEvent);
  1748.         $result = $afterListLoadEvent->getArgument('list');
  1750.         // Here we revert to assets key
  1751.         return $this->adminJson(['assets' => $result['data'], 'success' => $result['success'], 'total' => $result['total']]);
  1752.     }
  1754.     /**
  1755.      * @Route("/copy-info", name="pimcore_admin_asset_copyinfo", methods={"GET"})
  1756.      *
  1757.      * @param Request $request
  1758.      *
  1759.      * @return JsonResponse
  1760.      */
  1761.     public function copyInfoAction(Request $request)
  1762.     {
  1763.         $transactionId = time();
  1764.         $pasteJobs = [];
  1766.         Tool\Session::useSession(function (AttributeBagInterface $session) use ($transactionId) {
  1767.             $session->set($transactionId, []);
  1768.         }, 'pimcore_copy');
  1770.         if ($request->get('type') == 'recursive') {
  1771.             $asset = Asset::getById($request->get('sourceId'));
  1773.             if (!$asset) {
  1774.                 throw $this->createNotFoundException('Source not found');
  1775.             }
  1777.             // first of all the new parent
  1778.             $pasteJobs[] = [[
  1779.                 'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1780.                 'method' => 'POST',
  1781.                 'params' => [
  1782.                     'sourceId' => $request->get('sourceId'),
  1783.                     'targetId' => $request->get('targetId'),
  1784.                     'type' => 'child',
  1785.                     'transactionId' => $transactionId,
  1786.                     'saveParentId' => true,
  1787.                 ],
  1788.             ]];
  1790.             if ($asset->hasChildren()) {
  1791.                 // get amount of children
  1792.                 $list = new Asset\Listing();
  1793.                 $list->setCondition('path LIKE ?', [$list->escapeLike($asset->getRealFullPath()) . '/%']);
  1794.                 $list->setOrderKey('LENGTH(path)', false);
  1795.                 $list->setOrder('ASC');
  1796.                 $childIds = $list->loadIdList();
  1798.                 if (count($childIds) > 0) {
  1799.                     foreach ($childIds as $id) {
  1800.                         $pasteJobs[] = [[
  1801.                             'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1802.                             'method' => 'POST',
  1803.                             'params' => [
  1804.                                 'sourceId' => $id,
  1805.                                 'targetParentId' => $request->get('targetId'),
  1806.                                 'sourceParentId' => $request->get('sourceId'),
  1807.                                 'type' => 'child',
  1808.                                 'transactionId' => $transactionId,
  1809.                             ],
  1810.                         ]];
  1811.                     }
  1812.                 }
  1813.             }
  1814.         } elseif ($request->get('type') == 'child' || $request->get('type') == 'replace') {
  1815.             // the object itself is the last one
  1816.             $pasteJobs[] = [[
  1817.                 'url' => $this->generateUrl('pimcore_admin_asset_copy'),
  1818.                 'method' => 'POST',
  1819.                 'params' => [
  1820.                     'sourceId' => $request->get('sourceId'),
  1821.                     'targetId' => $request->get('targetId'),
  1822.                     'type' => $request->get('type'),
  1823.                     'transactionId' => $transactionId,
  1824.                 ],
  1825.             ]];
  1826.         }
  1828.         return $this->adminJson([
  1829.             'pastejobs' => $pasteJobs,
  1830.         ]);
  1831.     }
  1833.     /**
  1834.      * @Route("/copy", name="pimcore_admin_asset_copy", methods={"POST"})
  1835.      *
  1836.      * @param Request $request
  1837.      *
  1838.      * @return JsonResponse
  1839.      */
  1840.     public function copyAction(Request $request)
  1841.     {
  1842.         $success = false;
  1843.         $sourceId = intval($request->get('sourceId'));
  1844.         $source = Asset::getById($sourceId);
  1846.         $session = Tool\Session::get('pimcore_copy');
  1847.         $sessionBag = $session->get($request->get('transactionId'));
  1849.         $targetId = intval($request->get('targetId'));
  1850.         if ($request->get('targetParentId')) {
  1851.             $sourceParent = Asset::getById($request->get('sourceParentId'));
  1853.             // this is because the key can get the prefix "_copy" if the target does already exists
  1854.             if ($sessionBag['parentId']) {
  1855.                 $targetParent = Asset::getById($sessionBag['parentId']);
  1856.             } else {
  1857.                 $targetParent = Asset::getById($request->get('targetParentId'));
  1858.             }
  1860.             $targetPath = preg_replace('@^' . $sourceParent->getRealFullPath() . '@', $targetParent . '/', $source->getRealPath());
  1861.             $target = Asset::getByPath($targetPath);
  1862.         } else {
  1863.             $target = Asset::getById($targetId);
  1864.         }
  1866.         if (!$target) {
  1867.             throw $this->createNotFoundException('Target not found');
  1868.         }
  1870.         if ($target->isAllowed('create')) {
  1871.             $source = Asset::getById($sourceId);
  1872.             if ($source != null) {
  1873.                 if ($request->get('type') == 'child') {
  1874.                     $newAsset = $this->_assetService->copyAsChild($target, $source);
  1876.                     // this is because the key can get the prefix "_copy" if the target does already exists
  1877.                     if ($request->get('saveParentId')) {
  1878.                         $sessionBag['parentId'] = $newAsset->getId();
  1879.                     }
  1880.                 } elseif ($request->get('type') == 'replace') {
  1881.                     $this->_assetService->copyContents($target, $source);
  1882.                 }
  1884.                 $session->set($request->get('transactionId'), $sessionBag);
  1885.                 Tool\Session::writeClose();
  1887.                 $success = true;
  1888.             } else {
  1889.                 Logger::debug('prevended copy/paste because asset with same path+key already exists in this location');
  1890.             }
  1891.         } else {
  1892.             Logger::error('could not execute copy/paste because of missing permissions on target [ ' . $targetId . ' ]');
  1893.             throw $this->createAccessDeniedHttpException();
  1894.         }
  1896.         Tool\Session::writeClose();
  1898.         return $this->adminJson(['success' => $success]);
  1899.     }
  1901.     /**
  1902.      * @Route("/download-as-zip-jobs", name="pimcore_admin_asset_downloadaszipjobs", methods={"GET"})
  1903.      *
  1904.      * @param Request $request
  1905.      *
  1906.      * @return JsonResponse
  1907.      */
  1908.     public function downloadAsZipJobsAction(Request $request)
  1909.     {
  1910.         $jobId = uniqid();
  1911.         $filesPerJob = 5;
  1912.         $jobs = [];
  1913.         $asset = Asset::getById($request->get('id'));
  1915.         if (!$asset) {
  1916.             throw $this->createNotFoundException('Asset not found');
  1917.         }
  1919.         if ($asset->isAllowed('view')) {
  1920.             $parentPath = $asset->getRealFullPath();
  1921.             if ($asset->getId() == 1) {
  1922.                 $parentPath = '';
  1923.             }
  1925.             $db = \Pimcore\Db::get();
  1926.             $conditionFilters = [];
  1927.             $selectedIds = explode(',', $request->get('selectedIds', ''));
  1928.             $quotedSelectedIds = [];
  1929.             foreach ($selectedIds as $selectedId) {
  1930.                 if ($selectedId) {
  1931.                     $quotedSelectedIds[] = $db->quote($selectedId);
  1932.                 }
  1933.             }
  1934.             if (!empty($quotedSelectedIds)) {
  1935.                 //add a condition if id numbers are specified
  1936.                 $conditionFilters[] = 'id IN (' . implode(',', $quotedSelectedIds) . ')';
  1937.             }
  1938.             $conditionFilters[] = 'path LIKE ' . $db->quote($db->escapeLike($parentPath) . '/%') .' AND type != ' . $db->quote('folder');
  1939.             if (!$this->getAdminUser()->isAdmin()) {
  1940.                 $userIds = $this->getAdminUser()->getRoles();
  1941.                 $userIds[] = $this->getAdminUser()->getId();
  1942.                 $conditionFilters[] = ' (
  1943.                                                     (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
  1944.                                                     OR
  1945.                                                     (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
  1946.                                                  )';
  1947.             }
  1949.             $condition = implode(' AND ', $conditionFilters);
  1951.             $assetList = new Asset\Listing();
  1952.             $assetList->setCondition($condition);
  1953.             $assetList->setOrderKey('LENGTH(path)', false);
  1954.             $assetList->setOrder('ASC');
  1956.             for ($i = 0; $i < ceil($assetList->getTotalCount() / $filesPerJob); $i++) {
  1957.                 $jobs[] = [[
  1958.                     'url' => $this->generateUrl('pimcore_admin_asset_downloadaszipaddfiles'),
  1959.                     'method' => 'GET',
  1960.                     'params' => [
  1961.                         'id' => $asset->getId(),
  1962.                         'selectedIds' => implode(',', $selectedIds),
  1963.                         'offset' => $i * $filesPerJob,
  1964.                         'limit' => $filesPerJob,
  1965.                         'jobId' => $jobId,
  1966.                     ],
  1967.                 ]];
  1968.             }
  1969.         }
  1971.         return $this->adminJson([
  1972.             'success' => true,
  1973.             'jobs' => $jobs,
  1974.             'jobId' => $jobId,
  1975.         ]);
  1976.     }
  1978.     /**
  1979.      * @Route("/download-as-zip-add-files", name="pimcore_admin_asset_downloadaszipaddfiles", methods={"GET"})
  1980.      *
  1981.      * @param Request $request
  1982.      *
  1983.      * @return JsonResponse
  1984.      */
  1985.     public function downloadAsZipAddFilesAction(Request $request)
  1986.     {
  1987.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  1988.         $asset = Asset::getById($request->get('id'));
  1989.         $success = false;
  1991.         if (!$asset) {
  1992.             throw $this->createNotFoundException('Asset not found');
  1993.         }
  1995.         if ($asset->isAllowed('view')) {
  1996.             $zip = new \ZipArchive();
  1997.             if (!is_file($zipFile)) {
  1998.                 $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  1999.             } else {
  2000.                 $zipState = $zip->open($zipFile);
  2001.             }
  2003.             if ($zipState === true) {
  2004.                 $parentPath = $asset->getRealFullPath();
  2005.                 if ($asset->getId() == 1) {
  2006.                     $parentPath = '';
  2007.                 }
  2009.                 $db = \Pimcore\Db::get();
  2010.                 $conditionFilters = [];
  2012.                 $selectedIds = $request->get('selectedIds', []);
  2014.                 if (!empty($selectedIds)) {
  2015.                     $selectedIds = explode(',', $selectedIds);
  2016.                     //add a condition if id numbers are specified
  2017.                     $conditionFilters[] = 'id IN (' . implode(',', $selectedIds) . ')';
  2018.                 }
  2019.                 $conditionFilters[] = "type != 'folder' AND path LIKE " . $db->quote($db->escapeLike($parentPath) . '/%');
  2020.                 if (!$this->getAdminUser()->isAdmin()) {
  2021.                     $userIds = $this->getAdminUser()->getRoles();
  2022.                     $userIds[] = $this->getAdminUser()->getId();
  2023.                     $conditionFilters[] = ' (
  2024.                                                     (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
  2025.                                                     OR
  2026.                                                     (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
  2027.                                                  )';
  2028.                 }
  2030.                 $condition = implode(' AND ', $conditionFilters);
  2032.                 $assetList = new Asset\Listing();
  2033.                 $assetList->setCondition($condition);
  2034.                 $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  2035.                 $assetList->setOffset((int)$request->get('offset'));
  2036.                 $assetList->setLimit((int)$request->get('limit'));
  2038.                 foreach ($assetList as $a) {
  2039.                     if ($a->isAllowed('view')) {
  2040.                         if (!$a instanceof Asset\Folder) {
  2041.                             // add the file with the relative path to the parent directory
  2042.                             $zip->addFromString(preg_replace('@^' . preg_quote($asset->getRealPath(), '@') . '@i', '', $a->getRealFullPath()), file_get_contents($a->getFileSystemPath()));
  2043.                         }
  2044.                     }
  2045.                 }
  2047.                 $zip->close();
  2048.                 $success = true;
  2049.             }
  2050.         }
  2052.         return $this->adminJson([
  2053.             'success' => $success,
  2054.         ]);
  2055.     }
  2057.     /**
  2058.      * @Route("/download-as-zip", name="pimcore_admin_asset_downloadaszip", methods={"GET"})
  2059.      *
  2060.      * @param Request $request
  2061.      *
  2062.      * @return BinaryFileResponse
  2063.      * Download all assets contained in the folder with parameter id as ZIP file.
  2064.      * The suggested filename is either [folder name].zip or assets.zip for the root folder.
  2065.      */
  2066.     public function downloadAsZipAction(Request $request)
  2067.     {
  2068.         $asset = Asset::getById($request->get('id'));
  2069.         if (!$asset) {
  2070.             throw $this->createNotFoundException('Asset not found');
  2071.         }
  2072.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/download-zip-' . $request->get('jobId') . '.zip';
  2073.         $suggestedFilename = $asset->getFilename();
  2074.         if (empty($suggestedFilename)) {
  2075.             $suggestedFilename = 'assets';
  2076.         }
  2078.         $response = new BinaryFileResponse($zipFile);
  2079.         $response->headers->set('Content-Type', 'application/zip');
  2080.         $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $suggestedFilename . '.zip');
  2081.         $response->deleteFileAfterSend(true);
  2083.         return $response;
  2084.     }
  2086.     /**
  2087.      * @Route("/import-zip", name="pimcore_admin_asset_importzip", methods={"POST"})
  2088.      *
  2089.      * @param Request $request
  2090.      *
  2091.      * @return Response
  2092.      */
  2093.     public function importZipAction(Request $request)
  2094.     {
  2095.         $jobId = uniqid();
  2096.         $filesPerJob = 5;
  2097.         $jobs = [];
  2098.         $asset = Asset::getById($request->get('parentId'));
  2100.         if (!is_file($_FILES['Filedata']['tmp_name'])) {
  2101.             return $this->adminJson([
  2102.                 'success' => false,
  2103.                 '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',
  2104.             ]);
  2105.         }
  2107.         if (!$asset) {
  2108.             throw $this->createNotFoundException('Parent asset not found');
  2109.         }
  2111.         if (!$asset->isAllowed('create')) {
  2112.             throw $this->createAccessDeniedException('not allowed to create');
  2113.         }
  2115.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  2117.         copy($_FILES['Filedata']['tmp_name'], $zipFile);
  2119.         $zip = new \ZipArchive;
  2120.         if ($zip->open($zipFile) === true) {
  2121.             $jobAmount = ceil($zip->numFiles / $filesPerJob);
  2122.             for ($i = 0; $i < $jobAmount; $i++) {
  2123.                 $jobs[] = [[
  2124.                     'url' => $this->generateUrl('pimcore_admin_asset_importzipfiles'),
  2125.                     'method' => 'POST',
  2126.                     'params' => [
  2127.                         'parentId' => $asset->getId(),
  2128.                         'offset' => $i * $filesPerJob,
  2129.                         'limit' => $filesPerJob,
  2130.                         'jobId' => $jobId,
  2131.                         'last' => (($i + 1) >= $jobAmount) ? 'true' : '',
  2132.                     ],
  2133.                 ]];
  2134.             }
  2135.             $zip->close();
  2136.         }
  2138.         // here we have to use this method and not the JSON action helper ($this->_helper->json()) because this will add
  2139.         // Content-Type: application/json which fires a download window in most browsers, because this is a normal POST
  2140.         // request and not XHR where the content-type doesn't matter
  2141.         $responseJson = $this->encodeJson([
  2142.             'success' => true,
  2143.             'jobs' => $jobs,
  2144.             'jobId' => $jobId,
  2145.         ]);
  2147.         return new Response($responseJson);
  2148.     }
  2150.     /**
  2151.      * @Route("/import-zip-files", name="pimcore_admin_asset_importzipfiles", methods={"POST"})
  2152.      *
  2153.      * @param Request $request
  2154.      *
  2155.      * @return JsonResponse
  2156.      */
  2157.     public function importZipFilesAction(Request $request)
  2158.     {
  2159.         $jobId = $request->get('jobId');
  2160.         $limit = (int)$request->get('limit');
  2161.         $offset = (int)$request->get('offset');
  2162.         $importAsset = Asset::getById($request->get('parentId'));
  2163.         $zipFile = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/' . $jobId . '.zip';
  2164.         $tmpDir = PIMCORE_SYSTEM_TEMP_DIRECTORY . '/zip-import';
  2166.         if (!is_dir($tmpDir)) {
  2167.             File::mkdir($tmpDir, 0777, true);
  2168.         }
  2170.         $zip = new \ZipArchive;
  2171.         if ($zip->open($zipFile) === true) {
  2172.             for ($i = $offset; $i < ($offset + $limit); $i++) {
  2173.                 $path = $zip->getNameIndex($i);
  2175.                 if ($path !== false) {
  2176.                     if ($zip->extractTo($tmpDir . '/', $path)) {
  2177.                         $tmpFile = $tmpDir . '/' . preg_replace('@^/@', '', $path);
  2179.                         $filename = Element\Service::getValidKey(basename($path), 'asset');
  2181.                         $relativePath = '';
  2182.                         if (dirname($path) != '.') {
  2183.                             $relativePath = dirname($path);
  2184.                         }
  2186.                         $parentPath = $importAsset->getRealFullPath() . '/' . preg_replace('@^/@', '', $relativePath);
  2187.                         $parent = Asset\Service::createFolderByPath($parentPath);
  2189.                         // check for duplicate filename
  2190.                         $filename = $this->getSafeFilename($parent->getRealFullPath(), $filename);
  2192.                         if ($parent->isAllowed('create')) {
  2193.                             $asset = Asset::create($parent->getId(), [
  2194.                                 'filename' => $filename,
  2195.                                 'sourcePath' => $tmpFile,
  2196.                                 'userOwner' => $this->getAdminUser()->getId(),
  2197.                                 'userModification' => $this->getAdminUser()->getId(),
  2198.                             ]);
  2200.                             @unlink($tmpFile);
  2201.                         } else {
  2202.                             Logger::debug('prevented creating asset because of missing permissions');
  2203.                         }
  2204.                     }
  2205.                 }
  2206.             }
  2207.             $zip->close();
  2208.         }
  2210.         if ($request->get('last')) {
  2211.             unlink($zipFile);
  2212.         }
  2214.         return $this->adminJson([
  2215.             'success' => true,
  2216.         ]);
  2217.     }
  2219.     /**
  2220.      * @Route("/import-server", name="pimcore_admin_asset_importserver", methods={"POST"})
  2221.      *
  2222.      * @param Request $request
  2223.      *
  2224.      * @return JsonResponse
  2225.      */
  2226.     public function importServerAction(Request $request)
  2227.     {
  2228.         $success = true;
  2229.         $filesPerJob = 5;
  2230.         $jobs = [];
  2231.         $importDirectory = str_replace('/fileexplorer', PIMCORE_PROJECT_ROOT, $request->get('serverPath'));
  2232.         if (preg_match('@^' . preg_quote(PIMCORE_PROJECT_ROOT, '@') . '@', $importDirectory) && is_dir($importDirectory)) {
  2233.             $this->checkForPharStreamWrapper($importDirectory);
  2234.             $files = rscandir($importDirectory . '/');
  2235.             $count = count($files);
  2236.             $jobFiles = [];
  2238.             for ($i = 0; $i < $count; $i++) {
  2239.                 if (is_dir($files[$i])) {
  2240.                     continue;
  2241.                 }
  2243.                 $jobFiles[] = preg_replace('@^' . preg_quote($importDirectory, '@') . '@', '', $files[$i]);
  2245.                 if (count($jobFiles) >= $filesPerJob || $i >= ($count - 1)) {
  2246.                     $relativeImportDirectory = preg_replace('@^' . preg_quote(PIMCORE_PROJECT_ROOT, '@') . '@', '', $importDirectory);
  2247.                     $jobs[] = [[
  2248.                         'url' => $this->generateUrl('pimcore_admin_asset_importserverfiles'),
  2249.                         'method' => 'POST',
  2250.                         'params' => [
  2251.                             'parentId' => $request->get('parentId'),
  2252.                             'serverPath' => $relativeImportDirectory,
  2253.                             'files' => implode('::', $jobFiles),
  2254.                         ],
  2255.                     ]];
  2256.                     $jobFiles = [];
  2257.                 }
  2258.             }
  2259.         }
  2261.         return $this->adminJson([
  2262.             'success' => $success,
  2263.             'jobs' => $jobs,
  2264.         ]);
  2265.     }
  2267.     /**
  2268.      * @Route("/import-server-files", name="pimcore_admin_asset_importserverfiles", methods={"POST"})
  2269.      *
  2270.      * @param Request $request
  2271.      *
  2272.      * @return JsonResponse
  2273.      */
  2274.     public function importServerFilesAction(Request $request)
  2275.     {
  2276.         $assetFolder = Asset::getById($request->get('parentId'));
  2277.         if (!$assetFolder) {
  2278.             throw $this->createNotFoundException('Parent asset not found');
  2279.         }
  2280.         $serverPath = PIMCORE_PROJECT_ROOT . $request->get('serverPath');
  2281.         $files = explode('::', $request->get('files'));
  2283.         foreach ($files as $file) {
  2284.             $absolutePath = $serverPath . $file;
  2285.             $this->checkForPharStreamWrapper($absolutePath);
  2286.             if (is_file($absolutePath)) {
  2287.                 $relFolderPath = str_replace('\\', '/', dirname($file));
  2288.                 $folder = Asset\Service::createFolderByPath($assetFolder->getRealFullPath() . $relFolderPath);
  2289.                 $filename = basename($file);
  2291.                 // check for duplicate filename
  2292.                 $filename = Element\Service::getValidKey($filename, 'asset');
  2293.                 $filename = $this->getSafeFilename($folder->getRealFullPath(), $filename);
  2295.                 if ($assetFolder->isAllowed('create')) {
  2296.                     $asset = Asset::create($folder->getId(), [
  2297.                         'filename' => $filename,
  2298.                         'sourcePath' => $absolutePath,
  2299.                         'userOwner' => $this->getAdminUser()->getId(),
  2300.                         'userModification' => $this->getAdminUser()->getId(),
  2301.                     ]);
  2302.                 } else {
  2303.                     Logger::debug('prevented creating asset because of missing permissions ');
  2304.                 }
  2305.             }
  2306.         }
  2308.         return $this->adminJson([
  2309.             'success' => true,
  2310.         ]);
  2311.     }
  2313.     protected function checkForPharStreamWrapper($path)
  2314.     {
  2315.         if (stripos($path, 'phar://') !== false) {
  2316.             throw $this->createAccessDeniedException('Using PHAR files is not allowed!');
  2317.         }
  2318.     }
  2320.     /**
  2321.      * @Route("/import-url", name="pimcore_admin_asset_importurl", methods={"POST"})
  2322.      *
  2323.      * @param Request $request
  2324.      *
  2325.      * @return JsonResponse
  2326.      *
  2327.      * @throws \Exception
  2328.      */
  2329.     public function importUrlAction(Request $request)
  2330.     {
  2331.         $success = true;
  2333.         $data = Tool::getHttpData($request->get('url'));
  2334.         $filename = basename($request->get('url'));
  2335.         $parentId = $request->get('id');
  2336.         $parentAsset = Asset::getById(intval($parentId));
  2338.         if (!$parentAsset) {
  2339.             throw $this->createNotFoundException('Parent asset not found');
  2340.         }
  2342.         $filename = Element\Service::getValidKey($filename, 'asset');
  2343.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2345.         if (empty($filename)) {
  2346.             throw new \Exception('The filename of the asset is empty');
  2347.         }
  2349.         // check for duplicate filename
  2350.         $filename = $this->getSafeFilename($parentAsset->getRealFullPath(), $filename);
  2352.         if ($parentAsset->isAllowed('create')) {
  2353.             $asset = Asset::create($parentId, [
  2354.                 'filename' => $filename,
  2355.                 'data' => $data,
  2356.                 'userOwner' => $this->getAdminUser()->getId(),
  2357.                 'userModification' => $this->getAdminUser()->getId(),
  2358.             ]);
  2359.             $success = true;
  2360.         } else {
  2361.             Logger::debug('prevented creating asset because of missing permissions');
  2362.         }
  2364.         return $this->adminJson(['success' => $success]);
  2365.     }
  2367.     /**
  2368.      * @Route("/clear-thumbnail", name="pimcore_admin_asset_clearthumbnail", methods={"POST"})
  2369.      *
  2370.      * @param Request $request
  2371.      *
  2372.      * @return JsonResponse
  2373.      */
  2374.     public function clearThumbnailAction(Request $request)
  2375.     {
  2376.         $success = false;
  2378.         if ($asset = Asset::getById($request->get('id'))) {
  2379.             if (method_exists($asset, 'clearThumbnails')) {
  2380.                 if (!$asset->isAllowed('publish')) {
  2381.                     throw $this->createAccessDeniedException('not allowed to publish');
  2382.                 }
  2384.                 $asset->clearThumbnails(true); // force clear
  2385.                 $asset->save();
  2387.                 $success = true;
  2388.             }
  2389.         }
  2391.         return $this->adminJson(['success' => $success]);
  2392.     }
  2394.     /**
  2395.      * @Route("/grid-proxy", name="pimcore_admin_asset_gridproxy", methods={"GET", "POST", "PUT"})
  2396.      *
  2397.      * @param Request $request
  2398.      *
  2399.      * @return JsonResponse
  2400.      */
  2401.     public function gridProxyAction(Request $request, EventDispatcherInterface $eventDispatcher, GridHelperService $gridHelperService)
  2402.     {
  2403.         $allParams = array_merge($request->request->all(), $request->query->all());
  2405.         $filterPrepareEvent = new GenericEvent($this, [
  2406.             'requestParams' => $allParams,
  2407.         ]);
  2408.         $language = $request->get('language') != 'default' ? $request->get('language') : null;
  2410.         $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_FILTER_PREPARE, $filterPrepareEvent);
  2412.         $allParams = $filterPrepareEvent->getArgument('requestParams');
  2414.         $loader = \Pimcore::getContainer()->get('pimcore.implementation_loader.asset.metadata.data');
  2416.         if (isset($allParams['data']) && $allParams['data']) {
  2417.             $this->checkCsrfToken($request);
  2418.             if ($allParams['xaction'] == 'update') {
  2419.                 try {
  2420.                     $data = $this->decodeJson($allParams['data']);
  2422.                     $updateEvent = new GenericEvent($this, [
  2423.                         'data' => $data,
  2424.                         'processed' => false,
  2425.                     ]);
  2427.                     $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_UPDATE, $updateEvent);
  2429.                     $processed = $updateEvent->getArgument('processed');
  2431.                     if ($processed) {
  2432.                         // update already processed by event handler
  2433.                         return $this->adminJson(['success' => true]);
  2434.                     }
  2436.                     $data = $updateEvent->getArgument('data');
  2438.                     // save
  2439.                     $asset = Asset::getById($data['id']);
  2441.                     if (!$asset) {
  2442.                         throw $this->createNotFoundException('Asset not found');
  2443.                     }
  2445.                     if (!$asset->isAllowed('publish')) {
  2446.                         throw $this->createAccessDeniedException("Permission denied. You don't have the rights to save this asset.");
  2447.                     }
  2449.                     $metadata = $asset->getMetadata(null, null, false, true);
  2450.                     $dirty = false;
  2452.                     unset($data['id']);
  2453.                     foreach ($data as $key => $value) {
  2454.                         $fieldDef = explode('~', $key);
  2455.                         $key = $fieldDef[0];
  2456.                         if (isset($fieldDef[1])) {
  2457.                             $language = ($fieldDef[1] == 'none' ? '' : $fieldDef[1]);
  2458.                         }
  2460.                         foreach ($metadata as $idx => &$em) {
  2461.                             if ($em['name'] == $key && $em['language'] == $language) {
  2462.                                 try {
  2463.                                     $dataImpl = $loader->build($em['type']);
  2464.                                     $value = $dataImpl->getDataFromListfolderGrid($value, $em);
  2465.                                 } catch (UnsupportedException $le) {
  2466.                                     Logger::error('could not resolve metadata implementation for ' . $em['type']);
  2467.                                 }
  2469.                                 $em['data'] = $value;
  2470.                                 $dirty = true;
  2471.                                 break;
  2472.                             }
  2473.                         }
  2475.                         if (!$dirty) {
  2476.                             $defaulMetadata = ['title', 'alt', 'copyright'];
  2477.                             if (in_array($key, $defaulMetadata)) {
  2478.                                 $newEm = [
  2479.                                     'name' => $key,
  2480.                                     'language' => $language,
  2481.                                     'type' => 'input',
  2482.                                     'data' => $value,
  2483.                                 ];
  2485.                                 try {
  2486.                                     $dataImpl = $loader->build($newEm['type']);
  2487.                                     $newEm['data'] = $dataImpl->getDataFromListfolderGrid($value, $newEm);
  2488.                                 } catch (UnsupportedException $le) {
  2489.                                     Logger::error('could not resolve metadata implementation for ' . $newEm['type']);
  2490.                                 }
  2492.                                 $metadata[] = $newEm;
  2494.                                 $dirty = true;
  2495.                             } else {
  2496.                                 $predefined = Model\Metadata\Predefined::getByName($key);
  2497.                                 if ($predefined && (empty($predefined->getTargetSubtype())
  2498.                                         || $predefined->getTargetSubtype() == $asset->getType())) {
  2499.                                     $newEm = [
  2500.                                         'name' => $key,
  2501.                                         'language' => $language,
  2502.                                         'type' => $predefined->getType(),
  2503.                                         'data' => $value,
  2504.                                     ];
  2506.                                     try {
  2507.                                         $dataImpl = $loader->build($newEm['type']);
  2508.                                         $newEm['data'] = $dataImpl->getDataFromListfolderGrid($value, $newEm);
  2509.                                     } catch (UnsupportedException $le) {
  2510.                                         Logger::error('could not resolve metadata implementation for ' . $newEm['type']);
  2511.                                     }
  2513.                                     $metadata[] = $newEm;
  2514.                                     $dirty = true;
  2515.                                 }
  2516.                             }
  2517.                         }
  2518.                     }
  2520.                     if ($dirty) {
  2521.                         // $metadata = Asset\Service::minimizeMetadata($metadata, "grid");
  2522.                         $asset->setMetadataRaw($metadata);
  2523.                         $asset->save();
  2525.                         return $this->adminJson(['success' => true]);
  2526.                     }
  2528.                     return $this->adminJson(['success' => false, 'message' => 'something went wrong.']);
  2529.                 } catch (\Exception $e) {
  2530.                     return $this->adminJson(['success' => false, 'message' => $e->getMessage()]);
  2531.                 }
  2532.             }
  2533.         } else {
  2534.             $list = $gridHelperService->prepareAssetListingForGrid($allParams, $this->getAdminUser());
  2536.             $beforeListLoadEvent = new GenericEvent($this, [
  2537.                 'list' => $list,
  2538.                 'context' => $allParams,
  2539.             ]);
  2540.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_BEFORE_LIST_LOAD, $beforeListLoadEvent);
  2541.             /** @var Asset\Listing $list */
  2542.             $list = $beforeListLoadEvent->getArgument('list');
  2544.             $list->load();
  2546.             $assets = [];
  2547.             foreach ($list->getAssets() as $index => $asset) {
  2549.                 // 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
  2550.                 if ($asset->isAllowed('list')) {
  2551.                     $a = Asset\Service::gridAssetData($asset, $allParams['fields'], $allParams['language'] ?? '');
  2552.                     $assets[] = $a;
  2553.                 }
  2554.             }
  2556.             $result = ['data' => $assets, 'success' => true, 'total' => $list->getTotalCount()];
  2558.             $afterListLoadEvent = new GenericEvent($this, [
  2559.                 'list' => $result,
  2560.                 'context' => $allParams,
  2561.             ]);
  2562.             $eventDispatcher->dispatch(AdminEvents::ASSET_LIST_AFTER_LIST_LOAD, $afterListLoadEvent);
  2563.             $result = $afterListLoadEvent->getArgument('list');
  2565.             return $this->adminJson($result);
  2566.         }
  2568.         return $this->adminJson(['success' => false]);
  2569.     }
  2571.     /**
  2572.      * @Route("/get-text", name="pimcore_admin_asset_gettext", methods={"GET"})
  2573.      *
  2574.      * @param Request $request
  2575.      *
  2576.      * @return JsonResponse
  2577.      */
  2578.     public function getTextAction(Request $request)
  2579.     {
  2580.         $asset = Asset::getById($request->get('id'));
  2582.         if (!$asset) {
  2583.             throw $this->createNotFoundException('Asset not found');
  2584.         }
  2586.         if (!$asset->isAllowed('view')) {
  2587.             throw $this->createAccessDeniedException('not allowed to view');
  2588.         }
  2590.         $page = $request->get('page');
  2591.         $text = null;
  2592.         if ($asset instanceof Asset\Document) {
  2593.             $text = $asset->getText($page);
  2594.         }
  2596.         return $this->adminJson(['success' => 'true', 'text' => $text]);
  2597.     }
  2599.     /**
  2600.      * @Route("/detect-image-features", name="pimcore_admin_asset_detectimagefeatures", methods={"GET"})
  2601.      *
  2602.      * @param Request $request
  2603.      *
  2604.      * @return JsonResponse
  2605.      */
  2606.     public function detectImageFeaturesAction(Request $request)
  2607.     {
  2608.         $asset = Asset\Image::getById((int)$request->get('id'));
  2609.         if (!$asset instanceof Asset) {
  2610.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  2611.         }
  2613.         if ($asset->isAllowed('publish')) {
  2614.             $asset->detectFaces();
  2615.             $asset->removeCustomSetting('disableImageFeatureAutoDetection');
  2616.             $asset->save();
  2618.             return $this->adminJson(['success' => true]);
  2619.         }
  2621.         throw $this->createAccessDeniedHttpException();
  2622.     }
  2624.     /**
  2625.      * @Route("/delete-image-features", name="pimcore_admin_asset_deleteimagefeatures", methods={"GET"})
  2626.      *
  2627.      * @param Request $request
  2628.      *
  2629.      * @return JsonResponse
  2630.      */
  2631.     public function deleteImageFeaturesAction(Request $request)
  2632.     {
  2633.         $asset = Asset::getById((int)$request->get('id'));
  2634.         if (!$asset instanceof Asset) {
  2635.             return $this->adminJson(['success' => false, 'message' => "asset doesn't exist"]);
  2636.         }
  2638.         if ($asset->isAllowed('publish')) {
  2639.             $asset->removeCustomSetting('faceCoordinates');
  2640.             $asset->setCustomSetting('disableImageFeatureAutoDetection', true);
  2641.             $asset->save();
  2643.             return $this->adminJson(['success' => true]);
  2644.         }
  2646.         throw $this->createAccessDeniedHttpException();
  2647.     }
  2649.     /**
  2650.      * @param FilterControllerEvent $event
  2651.      */
  2652.     public function onKernelController(FilterControllerEvent $event)
  2653.     {
  2654.         $isMasterRequest = $event->isMasterRequest();
  2655.         if (!$isMasterRequest) {
  2656.             return;
  2657.         }
  2659.         $this->checkActionPermission($event, 'assets', [
  2660.             'getImageThumbnailAction', 'getVideoThumbnailAction', 'getDocumentThumbnailAction',
  2661.         ]);
  2663.         $this->_assetService = new Asset\Service($this->getAdminUser());
  2664.     }
  2666.     /**
  2667.      * @param FilterResponseEvent $event
  2668.      */
  2669.     public function onKernelResponse(FilterResponseEvent $event)
  2670.     {
  2671.         // nothing to do
  2672.     }
  2673. }